栈java实现

　　这几天，过得挺充实的，每天都在不停的上课，早上很早就起来去跑步，晚上到图书馆看书。一边紧张的学习，一边在默默的备战软考。最近还接手了一个公司官网的建设。这是我在川信最后的一个完整学期了，每件事我都要认真去做。就算会有失落，会有失败，会有不甘，也不轻言放弃。

　　刚刚下去跑了几圈，吹着夜晚的冷风，在操场狂奔。汗水湿透了全身，滴在镜片上，我快看不清了远方。想起很多事来，来川信的两年，参加了两次运动会，这是第三次，且每次都是长跑，我享受着这种超越自己的感觉。长跑远没有结束，我一直在这条路上。

　　对于时间的安排，我的重点还是软考下午的5道大题，算法数据结构，设计模式，数据流图，数据库设计，uml例图，项目设计等。经过这几天努力，用java实现了常用的几种数据结构，画了很多的图，其中真是奥妙无穷。下一步，是算法设计，然后设计模式等。因为高中学了2年的计算机基础和网络知识，所以上午的一知半解。准备通过反复做题和百度练习。将下午的复习完毕之后，将进入全面复习阶段。通过真题训练，反复看书，做题，看代码，写代码。希望通过这次的复习，能够吸收这些知识转换为自己的思想，而不是死记硬背，应付考试。

　　下面是栈的顺序存储结构和链式存储实现：

　　

package stack;

public interface IStack<E> {
    //1.判断空栈
    public boolean isEmpty();
    
    //2.判断栈满
    public boolean isMax();
    
    //3.入栈
    public boolean push(E e);
    
    //4.出栈
    public E pop();
    
    //5.返回栈顶
    public E peek();
    
    //6.返回元素在栈中的位置
    public int getIndex(E e);
    
    //7.返回栈的实际长度
    public int size();
    
    //8.返回栈容量
    public int getStackSize();
    
    //9.打印栈
    public void display();
    
    

}

//顺序栈

package stack;

//我的栈数据结构
public class MyStack<E> implements IStack<E>{
    private Object[] data = null; //数据域
    private int top = -1;           //栈顶指针初始化为-1
    private int maxSize = 0;      //栈最大容量
    
    //默认设置栈容量为10
    MyStack(){
        this(10);
    }
    
    public MyStack(int initialSize){
        if(initialSize >= 0){
            this.data = new Object[initialSize]; //初始化数组
            this.maxSize = initialSize; //设置栈最大容量
            this.top = -1;
        }
    }
    
    public boolean isEmpty() {
        return top == -1 ? true : false; //根据栈顶值判断,如果栈顶指针没有更新，则为空栈
    }

    public boolean isMax() {
        return top >= maxSize-1 ? true : false; //根据栈顶值判断，如果栈顶指针大于最大容量，则为满栈
    }

    public boolean push(E e) {
        if(isMax()){
            System.err.println("对不起,栈已满,无法入栈");
            return false;
        }
        top ++; //更新栈顶下标
        data[top] = e; //将元素添加到表中
//        System.out.println("添加" + e + "成功");
        return true;
    }

    @SuppressWarnings("unchecked")
    public E pop() {
        if(isEmpty()){
            System.err.println("对不起，目前是空栈，没有元素可以出栈");
            return null;
        }
        E e = (E) data[top]; //返回当前的栈顶元素
        top--; //更新栈顶
        return e;
    }

    @SuppressWarnings("unchecked")
    public E peek() {
        if(isEmpty()){
            System.err.println("对不起，目前是空栈，无法返回栈顶元素");
            return null;
        }
        return (E) data[top]; //返回栈顶元素
    }

    public int getIndex(E e) {
        //根据栈顶和栈底(-1)遍历栈
        while(top != -1){
            //peek()返回当前栈顶
            if(peek().equals(e)){
                return top;
            }
            top --;
        }
        
        return -1;
    }

    public int size() {
        return this.top+1; //栈顶值+1，为栈元素的实际个数
    }

    public int getStackSize() {
        return this.maxSize; //返回栈实际长度
    }

    public void display() {
        //根据栈顶和栈底(-1)遍历
        while(top != -1){
            System.out.println(top);
            top --;
        }
    }
    
    public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack<Integer>();
        //入栈
        for (int i = 0; i < 10; i++) {
            stack.push(i); 
        }
        //出栈
//        stack.pop();
        //返回栈顶
//        System.out.println(stack.peek());
        //求长
//        System.out.println(stack.size());
        
    }
    
}

//链栈

package stack;

//链栈是栈的链式存储结构，由多个节点组成。在链栈中的栈顶为头节点，节点由数据域和指针域组成
//对链栈的操作都是间接的通过栈顶(头节点)完成。
//顺序栈是一种特殊的顺序表
//链栈是一种特殊链表
public class LinkedStack{
    //定义节点类
    private class Node{
        public Object data = null; //数据域
        public Node next = null;   //指针域
        
        //构造函数初始化
        @SuppressWarnings("unused")
        public Node(){}
        
        public Node(Object data, Node next){
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node [data=" + data + ", next=" + next + "]";
        }
    }/*Node*/
    
    private Node top = null; //定义栈顶
    private int size = 0;    //定义栈节点数量
    
    //判断栈空
    public boolean isEmpty(){
        return size == 0 ? true : false;
    }
        
    //压栈
    public boolean push(Object obj){
        //更新头节点，让新节点指向原来的头节点
        System.out.println("压栈成功:" + obj + "指向->" + top);
        top = new Node(obj, top); //压栈是将节点插入到栈顶之前。也就是更新头节点。改变指针指向
        size ++; //栈长度++
        return true;
    }
    
    //出栈
    public Object pop(){
        if(isEmpty()){
            System.out.println("对不起，目前是空栈，不能出栈");
            return null;
        }
        Node temp = top;     //头节点引用
        top = top.next;        //更新头节点
        temp.next = null;     //释放引用,删除指针指向
        size-- ;             //栈节点数量-1
        return temp.data;   //出栈
    }
    
    //返回栈顶元素，但不弹出栈
    public Object peek(){
        return this.top.data; //直接返回栈顶元素
    }
    
    //遍历栈并打印
    public void display(){
        //从栈顶节点开始到栈底节点null遍历
        while(top != null){
            System.out.println(top.data);
            top = top.next;
        }
    }
    
    //返回元素在栈中的位置
    public int getIndex(Object obj){
        int i = 0;
        while(top != null){
            if(peek().equals(obj)){
                return i; 
            }
            top = top.next;
            i++;
        }
        return -1;
    }
    
    //返回栈的长度
    public int getSize(){
        return this.size;
    }
    
    public static void main(String[] args) {
        LinkedStack stack = new LinkedStack();
        for (int i = 0; i < 10; i++) {
            stack.push(i);
        }
//        stack.display();
        System.out.println(stack.getIndex(9));
    }
    
}

明天更新队列和树，然后是图的深度优先，广度优先，各种算法。