Java編程思想-Stack的三種實現（數組，容器，鏈表）

雖是讀書筆記，可是如轉載請註明出處http://segmentfault.com/blog/exploring/
..拒絕伸手複製黨
想更一進步的支持我，請掃描下方的二維碼，你懂的~

Stack

棧（Stack）是限制僅在表的一端進行插入和刪除運算的線性表。
java 沒有棧這樣的數據結構，若是想利用先進後出（FILO）這樣的數據結構，就必須本身實現。

要實現Stack，至少應該包括：
1. pop() 出棧操做，彈出棧頂元素。
2. push(E e) 入棧操做
3. peek() 查看棧頂元素
4. isEmpty() 棧爲空

另外，實現一個棧，還應該考慮到幾個問題：
1. 棧的初始大小以及棧滿之後如何新增棧空間
2. 對棧進行更新時須要進行同步

---

有三種實現的方式，數組，容器，以及鏈表的方法。

數據：

javapackage gsm;
import java.util.*;

public class StackArray{
    private int[] array;//用數組實現
    private int top; //棧頂指針
    private final static int size = 100;
    public StackArray(){
        array = new int[size];
        top = -1; //棧空的時候 
    }
    //壓棧
    public void push(int element){
        if(top == size-1){
            throw new StackOverflowError();
        }
        else 
            array[++top] = element;
    }
    //彈棧
    public int pop(){
        if(top == -1){
            throw new EmptyStackException();
        }
        return array[top--];
    }
    //判斷是否爲空
    public boolean isEmpty(){
        return top == -1;
    }
    //返回棧頂元素
    public Integer peek(){
        if(top == -1){
            throw new EmptyStackException();
        }
        return array[top];
    }
}

容器

javapackage gsm;

public interface Stack<T> {
    public T pop();
    public void push(T element);
    public boolean isEmpty();
    public T peek();
}

package gsm;
import java.util.*;

public class StackList<T> implements Stack<T> {
    private List<T> list ; //用容器實現
    StackList(){
        list = new ArrayList<T>();
    }
    //彈棧
    public T pop(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }

        return list.remove(list.size()-1);
    }
    //壓棧
    public void push(T element){
        list.add(element);
    }
    //判斷是否爲空
    public boolean isEmpty(){
        return list.size() == 0;
    }
    //返回棧頂元素
    public T peek(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }
        return list.get(list.size()-1);
    }
}

鏈表

javapackage gsm;

import java.util.EmptyStackException;

public class LinkedStack<T> implements Stack<T>{
    //不用容器或者數組等數據結構存儲節點
    //Node定義一個節點類
    private static class Node<U>{
        private U item; //存儲的data
        private Node<U> next; //相似指針
        Node(){
            this.item = null;
            this.next = null;
        }
        Node(U item, Node<U> next){
            this.item = item;
            this.next = next;
        }
        boolean end(){
            return item == null && next == null;
        }
    } 

    private Node<T> top ; //棧頂指針
    LinkedStack(){
        top = new Node<T>();
    }


    //彈棧
    public T pop(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }
        T result = top.item;
        if(!top.end())
        {
            top = top.next;
        }
        return result;
    }
    //壓棧
    public void push(T element){
        top = new Node<T>(element, top);
    }
    //判斷是否爲空
    public boolean isEmpty(){
        return  top.end();
    }
    //返回棧頂元素
    public T peek(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }
        T result = top.item;
        return result;
    }   
}

能夠發現容器果真是java的一個利器，方便高效。