Java栈实现

栈数组实现一：优点：入栈和出栈速度快，缺点：长度有限(有时候这也不能算是个缺点)

public class Stack {
    private int top = -1;
    private Object[] objs;

    public Stack(int capacity) throws Exception{
        if(capacity < 0)
            throw new Exception("Illegal capacity:"+capacity);
        objs = new Object[capacity];
    }

    public void push(Object obj) throws Exception{
        if(top == objs.length - 1)
            throw new Exception("Stack is full!");
        objs[++top] = obj;
    }

    public Object pop() throws Exception{
        if(top == -1)
            throw new Exception("Stack is empty!");
        return objs[top--];
    }

    public void dispaly(){
        System.out.print("bottom -> top: | ");
        for(int i = 0 ; i <= top ; i++){
            System.out.print(objs[i]+" | ");
        }
        System.out.print("\n");
    }

    public static void main(String[] args) throws Exception{
        Stack s = new Stack(2);
        s.push(1);
        s.push(2);
        s.dispaly();
        System.out.println(s.pop());
        s.dispaly();
        s.push(99);
        s.dispaly();
        s.push(99);
    }
}

bottom -> top: | 1 | 2 |
2
bottom -> top: | 1 |
bottom -> top: | 1 | 99 |
Exception in thread "main" java.lang.Exception: Stack is full!
    at Stack.push(Stack.java:17)
    at Stack.main(Stack.java:44)

数据项入栈和出栈的时间复杂度都为常数O(1)

栈数组实现二：优点：无长度限制，缺点：入栈慢

import java.util.Arrays;

public class UnboundedStack {
    private int top = -1;
    private Object[] objs;

    public UnboundedStack() throws Exception{
        this(10);
    }

    public UnboundedStack(int capacity) throws Exception{
        if(capacity < 0)
            throw new Exception("Illegal capacity:"+capacity);
        objs = new Object[capacity];
    }

    public void push(Object obj){
        if(top == objs.length - 1){
            this.enlarge();
        }
        objs[++top] = obj;
    }

    public Object pop() throws Exception{
        if(top == -1)
            throw new Exception("Stack is empty!");
        return objs[top--];
    }

    private void enlarge(){
        int num = objs.length/3;
        if(num == 0)
            num = 1;
        objs = Arrays.copyOf(objs, objs.length + num);
    }

    public void dispaly(){
        System.out.print("bottom -> top: | ");
        for(int i = 0 ; i <= top ; i++){
            System.out.print(objs[i]+" | ");
        }
        System.out.print("\n");
    }

    public static void main(String[] args) throws Exception{
        UnboundedStack us = new UnboundedStack(2);
        us.push(1);
        us.push(2);
        us.dispaly();
        System.out.println(us.pop());
        us.dispaly();
        us.push(99);
        us.dispaly();
        us.push(99);
        us.dispaly();
    }
}

bottom -> top: | 1 | 2 |
2
bottom -> top: | 1 |
bottom -> top: | 1 | 99 |
bottom -> top: | 1 | 99 | 99 |

由于该栈是由数组实现的，数组的长度是固定的，当栈空间不足时，必须将原数组数据复制到一个更长的数组中，考虑到入栈时或许需要进行数组复制，平均需要复制N/2个数据项，故入栈的时间复杂度为O(N)，出栈的时间复杂度依然为O(1)

栈单链表实现：没有长度限制，并且出栈和入栈速度都很快

public class LinkedList {
    private class Data{
        private Object obj;
        private Data next = null;

        Data(Object obj){
            this.obj = obj;
        }
    }

    private Data first = null;

    public void insertFirst(Object obj){
        Data data = new Data(obj);
        data.next = first;
        first = data;
    }

    public Object deleteFirst() throws Exception{
        if(first == null)
            throw new Exception("empty!");
        Data temp = first;
        first = first.next;
        return temp.obj;
    }

    public void display(){
        if(first == null)
            System.out.println("empty");
        System.out.print("top -> bottom : | ");
        Data cur = first;
        while(cur != null){
            System.out.print(cur.obj.toString() + " | ");
            cur = cur.next;
        }
        System.out.print("\n");
    }
}

public class LinkedListStack {
    private LinkedList ll = new LinkedList();

    public void push(Object obj){
        ll.insertFirst(obj);
    }

    public Object pop() throws Exception{
        return ll.deleteFirst();
    }

    public void display(){
        ll.display();
    }

    public static void main(String[] args) throws Exception{
        LinkedListStack lls = new LinkedListStack();
        lls.push(1);
        lls.push(2);
        lls.push(3);
        lls.display();
        System.out.println(lls.pop());
        lls.display();
    }
}

top -> bottom : | 3 | 2 | 1 |
3
top -> bottom : | 2 | 1 |

数据项入栈和出栈的时间复杂度都为常数O(1)