棧和佇列：

前面已經介紹完了線性表的順序和鏈式兩中實現，但如果再對線性表增加一些額外的限制和約束，例如，去除普通線性表中通過索引訪問資料元素的功能，去除普通線性表中查詢某個元素在表中的位置的功能。去除普通線性表中可以在任意位置隨意增加、刪除元素的功能，而是改為只允許線上性表的某端新增、刪除元素，這時候普通線性表就會變成另外兩種特殊的線性表：棧和佇列。

從邏輯上看，棧和佇列其實是由普通的線性表發展而來的，為普通線性表增加一些特殊的限制就可以得到棧和隊列了。從功能上來看，棧和佇列比普通線性表的功能相對弱一些，但在一些特殊的場合下，使用棧和佇列會更有利，例如，編譯器實現函式呼叫時需要使用棧來儲存斷點，實現遞迴演算法時也需要使用棧來儲存。當然我這裡最主要是因為考慮到後面會有樹的深度優先演算法和廣度優先演算法打下基礎。

棧是一種資料結構，他代表只能在某一端進行插入、刪除操作的特殊線性表，通常就是線上性表的尾端進行插入、刪除操作。
對於棧而言，允許進行插入、刪除操作的一端被稱為棧頂（top），另一端則被稱為棧底（bottom）。
如果一個棧不包含任何元素，那麼這個棧就被稱為空棧。
從棧頂插入一個元素被稱為進棧或者入棧或者壓棧，對應的英文說法為 push。
從棧頂刪除一個元素被稱為出棧或者退棧，對應的英文說法為 pop。
如下圖為棧的操作示意圖：

對於a0，a1，a2，……，an-1的棧，假設棧中元素按a0，a1，a2，……，an-1的次序進棧，那麼a0為棧的棧底元素，an-1為棧頂元素。出棧時
第一個彈出的元素為棧頂元素，也就是an-1、也就是說棧中的元素的修改是按後進先出（LIFO）的原則進行的。

歸納起來，可以再對棧下一個定義：棧是一種後進先出（LIFO）的線性表。

棧的常用操作：
棧是一種被限制的線性表，通常不應該提供線性表中的如下操作：
（1）、獲取指定索引處的元素。
（2）、按值查詢資料元素的位置。
（3）、向指定索引位置插入元素。
（4）、刪除指定索引位置處的元素。
從上面這些方法可以看出，棧不應提供從中間任意位置訪問元素的方法。也就是說，棧只允許從棧頂插入、刪除元素。

棧的常用操作如下：
（1）、初始化：通常是一個構造器，用於建立一個空棧。
（2）、返回棧的長度：該方法用於返回棧中資料元素的長度。
（3）、入棧

：向棧的棧頂插入一個數據元素，棧的長度 +1。
（4）、出棧：向棧的棧頂刪除一個數據元素，棧的長度 -1。返回被刪除的元素
（5）、訪問棧頂元素：返回棧頂的資料元素，但不刪除。
（6）、判斷棧是否為空棧：該方法判斷棧是否為空，如果為空則返回ture，否則則返回false。
（7）、清空棧：將棧清空。
對於棧而言，上面的加粗的部分就是他的標誌性方法。

順序儲存結構的棧簡稱為順序棧，它利用一組地址連續的儲存單元依次存放從棧底到棧頂的資料元素。棧底位置固定不變，他的棧頂元素可以直接通過順序棧底層陣列的陣列元素arr[size - 1]來訪問。順序棧的儲存結構示意圖如下：

1、進棧
對於順序棧的進棧操作而言，只需將新的元素存入棧內，然後讓記錄棧的元素個數的size + 1。程式即可再次通過arr[size - 1]重新訪問新的棧頂元素。進棧操作如下示意圖：

由於順序棧底層通常採用陣列來儲存資料元素，因此可能出現的情況是：當程式試圖讓一個數據元素進棧，底層陣列已滿，那麼就必須擴充底層陣列的長度來容納

新的進棧的資料元素。

2、出棧
對於順序棧的出棧操作而言，需要將棧頂的元素彈出，程式要做兩件事：
（1）讓記錄棧內元素個數的變數size-1。
（2）釋放陣列對棧頂元素的引用。
出棧操作示意圖如下：

對於刪除操作而言，只要讓記錄棧內元素個數的size - 1，程式即可通過arr[size - 1]訪問到新的棧的棧頂元素。但不要忘記釋放原來棧頂元素的陣列索引。
否則會引起記憶體洩漏。

下面是程式碼實現：

import java.util.Arrays;

public class SequenceStack<T> {
	private final int DEFAULT_SIZE = 10;
	//棧的容量
	private int capacity;
	//底層存放資料元素的陣列
	private Object[] elementData;
	//當前棧所存放的元素個數
	private int size = 0;
	
	//預設陣列擴容向左移一位
	private int capacityIncrementInt = 1;
	//初始化1
	public SequenceStack(){
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	//初始化2
	public SequenceStack(T element){
		/*capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];*/
		this();
		elementData[0] = element;
		size ++;
	}
	//初始化3
	public SequenceStack(T element, int initCapacity){
		capacity = initCapacity;
		elementData = new Object[capacity];
		elementData[0] = element;
		size ++;
	}
	//初始化4
	public SequenceStack(T element, int initCapacity, int initCapacityIncrementInt){
		this(element, initCapacity);
		capacityIncrementInt = initCapacityIncrementInt;
	}
	//返回元素個數
	public int length(){
		return size;
	}
	//是否為空棧
	public boolean isEmpty(){
		return size == 0;
	}
	
	//位運算擴容,很麻煩，而且效能差
	private void expendCapacity(int minCapacity){
		while(capacity < minCapacity){
			capacity <<= capacityIncrementInt;
		}
		elementData = Arrays.copyOf(elementData, capacity);
	}
	
	//入棧
	public void push(T element){
		expendCapacity(size + 1);
		elementData[size] = element;
		size ++;
	}
	
	//出棧
	@SuppressWarnings("unchecked")
	public T pop(){
		T t = (T) elementData[size - 1];
		elementData[size - 1] = null;
		size --;
		return t;
	}
	
	//返回棧頂元素，但不刪除
	@SuppressWarnings("unchecked")
	public T peek(){
		return (T) elementData[size - 1];
	}
	
	//清空棧
	public void clear(){
		if(size > 0){
			/*for(int i = 0; i < size; i ++){
				elementData[i] = null;
			}*/
			Arrays.fill(elementData, null);
			size = 0;
		}
	}
	
	//toString方法
	public String toString(){
		if(size == 0){
			return "[]";
		}else{
			StringBuffer sb = new StringBuffer("[");
			for(int i = 0; i < size; i ++){
				sb.append(elementData[i].toString() + ",");
			}
			return sb.toString().substring(0, sb.length() - 1) + "]";
		}
		
	}
}

從上面的程式可以看出，當採用基於陣列的方式來實現順序棧時，程式比普通線性表更簡單。這符合前面的介紹：從功能上來看，棧比普通線性表的功能更弱；棧是一種被限制過得線性表，只能從棧頂插入、刪除元素。

測試類如下：

import com.yc.list.SequenceStack;

public class SequenceStackTest {
	public static void main(String[] args) {
		SequenceStack<Student> stack = new SequenceStack<Student>();
		stack.push(new Student("WB", "湖工", 20));
		stack.push(new Student("LS", "湖工", 22));
		stack.push(new Student("QYB", "湖工", 21));
		System.out.println( "PUSh後的棧為：  " + stack.toString());
		
		Student speek = stack.peek();
		System.out.println("peek的資料元素：  "+speek.toString());
		System.out.println("peek後的棧為：  "+stack.toString());
		
		Student spop1 = stack.pop();
		System.out.println( "pop的資料元素：   "+spop1);
		System.out.println( "pop後的棧為：   "+stack.toString());
		
		Student spop2 = stack.pop();
		System.out.println( "pop的資料元素：   "+spop2);
		System.out.println( "pop後的棧為：   "+stack.toString());
	}
}

輸出結果：