這節我們討論了兩種好玩的數據結構，棧和隊列。
老樣子，什么是棧， 所謂的棧是棧(Stack)是操作限定在表的尾端進行的線性表。表尾由於要進行插入、刪除等操作，所以，它具有特殊的含義，把表尾稱為棧頂（Top） ，另一端是固定的，叫棧底（Bottom） 。當棧中沒有數據元素時叫空棧(Empty Stack)。這個類似於送飯的飯盒子，上層放的是紅燒肉，中層放的水煮魚，下層放的雞腿。你要把這些菜取出來，這就引出來了棧的特點先進后出（First in last out）。 具體敘述，加下圖。
棧通常記為：S= (a1,a2,…,an)，S是英文單詞stack的第 1 個字母。a1為棧底元素，an為棧頂元素。這n個數據元素按照a1,a2,…,an的順序依次入棧，而出棧的次序相反，an第一個出棧，a1最后一個出棧。所以，棧的操作是按照后進先出(Last In First Out，簡稱LIFO)或先進后出(First In Last Out，簡稱FILO)的原則進行的， 因此， 棧又稱為LIFO表或FILO表。 棧的操作示意圖如圖所示。
棧的形式化定義為：棧(Stack)簡記為 S，是一個二元組，顧定義為S = (D, R)
其中：D 是數據元素的有限集合；
R 是數據元素之間關系的有限集合。
棧的一些基本操作的概述：由於棧只能在棧頂進行操作， 所以棧不能在棧的任意一個元素處插入或刪除元素。因此，棧的操作是線性表操作的一個子集。棧的操作主要包括在棧頂插入元素和刪除元素、取棧頂元素和判斷棧是否為空等等方面的操作。
同樣，我們以 C#語言的泛型接口來表示棧，接口中的方法成員表示基本操作。為表示的方便與簡潔，把泛型棧接口取名為 IStack（實際上，在 C#中沒有泛型接口 IStack<T>， 泛型棧是從 IEnumerable<T>和 ICollection 等接口繼承而來，這一點與線性表有着本質的區別） 。
棧的接口定義源代碼如下所示。
public interface IStack<T> {
//初始條件：棧存在；操作結果：返回棧中數據元素的個數。
int GetLength(); //求棧的長度 偽代碼 index++
//初始條件：棧存在； 操作結果：如果棧為空返回 true，否則返回 false。偽代碼 if(top==null) return true;else return false;
bool IsEmpty(); //判斷棧是否為空
//初始條件：棧存在； 操作結果：使棧為空。偽代碼 top=null;
void Clear(); //清空操作
//初始條件：棧存在； 操作結果：將值為 item 的新的數據元素添加到棧頂，棧發生變化。偽代碼 top=item;index++;
void Push(T item); //入棧操作
//初始條件：棧存在且不為空； 操作結果：將棧頂元素從棧中取出，棧發生變化 偽代碼：return top;index--;
T Pop(); //出棧操作
//初始條件：棧表存在且不為空； 操作結果：返回棧頂元素的值，棧不發生變化。偽代碼 get top;
T GetTop(); //取棧頂元素
}
棧也分為兩種的形式，一種是順序棧，一種是鏈棧。
第一種 順序棧(Sequence Stack)：
用一片連續的存儲空間來存儲棧中的數據元素，這樣的棧稱為順序棧(Sequence Stack)。類似於順序表，用一維數組來存放順序棧中的數據元素。棧頂指示器 top 設在數組下標為 0 的端，top 隨着插入和刪除而變化，當棧為空時，top=-1。下圖是順序棧的棧頂指示器 top與棧中數據元素的關系圖。
順序棧類 SeqStack<T>源代碼的實現如下所示。
public class SeqStack<T> : IStack<T> {
private int maxsize; //順序棧的容量 最大的存儲空間
private T[] data; //數組，用於存儲順序棧中的數據元素 存儲數據的多少
private int top; //指示順序棧的棧頂 棧頂指針
//索引器
public T this[int index]
{
get
{
return data[index];
}
set
{
data[index] = value;
}
}
//容量屬性
public int Maxsize
{
get
{
return maxsize;
}
set
{
maxsize = value;
}
}
//棧頂屬性
public int Top
{
get
{
return top;
}
}
//構造器 進行相應初始化的工作 進行賦值
public SeqStack(int size)
{
data = new T[size];
maxsize = size;
top = -1;
}
//求棧的長度 用頭指針來加一
public int GetLength()
{
return top+1;
}
如圖所示：
//判斷順序棧是否為空
//就是判斷頭指針是否為-1 為就為空 不為就為假
public bool IsEmpty()
{
if (top == -1)
{
return true;
}
else
{
return false;
}
}
具體如下圖所示：
//判斷順序棧是否為滿 或最大尺寸相比較 相等 返回真 不相等返回假
public bool IsFull()
{
if (top == maxsize-1)
{
return true;
}
else
{
return false;
}
}
相應情況，一切盡在圖例中。
//入棧 將其放入頂部 top 加加
public void Push(T item)
{
//如果滿了 就不進行添加
if(IsFull())
{
Console.WriteLine("Stack is full");
return;
}
//進行加入到頂部
data[++top] = item;
}
具體情況，一切盡在圖例中
//出棧 進行出棧后 頭指針減減
public T Pop()
{
T tmp = default(T);
if (IsEmpty())
{
Console.WriteLine("Stack is empty");
return tmp;
}
tmp = data[top];
--top;
return tmp;
具體情況，一切盡在圖例中。
//獲取棧頂數據元素 把頭指針指向的元素進行彈出的操作
public T GetTop()
{
//如果是空 就返回一個默認值
if (IsEmpty())
{
Console.WriteLine("Stack is empty!");
return default(T);
}
return data[top];
具體情況，一切盡在圖例中：
}
}
}
這就是對順序棧的相應的介紹。
下面，我們就來到了另一種棧——鏈棧的介紹
什么是鏈棧了，所謂鏈棧是棧的另外一種存儲方式是鏈式存儲，這樣的棧稱為鏈棧(Linked Stack)。鏈棧通常用單鏈表來表示，它的實現是單鏈表的簡化。所以，鏈棧結點的結構與單鏈表結點的結構一樣，如圖所示。由於鏈棧的操作只是在一端進行，為了操作方便，把棧頂設在鏈表的頭部，並且不需要頭結點。
鏈棧結點類(Node<T>)源代碼的實現如下：
public class Node<T>
{
private T data; //數據域
private Node<T> next; //引用域
//構造器
public Node(T val, Node<T> p)
{
data = val;
next = p;
}
//構造器
public Node(Node<T> p)
{
next = p;
}
//構造器
public Node(T val)
{
data = val;
next = null;
}
//構造器
public Node()
{
data = default(T);
next = null;
}
//數據域屬性
public T Data
{
get
{
return data;
}
set
{
data = value;
}
}
//引用域屬性
public Node<T> Next
{
get
{
return next;
}
set
{
next = value;
}
}
}
下圖是鏈棧示意圖。
把鏈棧看作一個泛型類，類名為 LinkStack<T>。LinkStack<T>類中有一個字段 top表示棧頂指示器。由於棧只能訪問棧頂的數據元素，而鏈棧的棧頂指示器又不能指示棧的數據元素的個數。所以，求鏈棧的長度時，必須把棧中的數據元素一個個出棧， 每出棧一個數據元素， 計數器就增加 1， 但這樣會破壞棧的結構。為保留棧中的數據元素， 需把出棧的數據元素先壓入另外一個棧， 計算完長度后，再把數據元素壓入原來的棧。但這種算法的空間復雜度和時間復雜度都很高，所以， 以上兩種算法都不是理想的解決方法。 理想的解決方法是 LinkStack<T>類增設一個字段 num表示鏈棧中結點的個數。
鏈棧類 LinkStack<T>的實現說明如下所示。
public class LinkStack<T> : IStack<T> {
private Node<T> top; //棧頂指示器
private int num; //棧中結點的個數
//棧頂指示器屬性
public Node<T> Top
{
get
{
return top;
}
set
{
top = value;
}
}
//元素個數屬性 進行了計數
public int Num
{
get
{
return num;
}
set
{
num = value;
}
}
//構造器 進行了函數的初始化
public LinkStack()
{
top = null;
num = 0;
}
//求鏈棧的長度 返回計算的復雜度 此算法的復雜度是O(1)
public int GetLength()
{
return num;
}
//清空鏈棧 進行清空的操作 此算法的復雜度是O(1)
public void Clear()
{
top = null;
num = 0;
}
//判斷鏈棧是否為空 判斷 計數的變量和頭指針是否是空 返回為真 否則 為假 此算法的復雜度是O(n)
public bool IsEmpty()
{
if ((top == null) && (num == 0))
{
return true;
}
else
{
return false;
}
}
//入棧 進行棧內 入棧的操作
public void Push(T item)
{
Node<T> q = new Node<T>(item);
if (top == null)
{
top = q;
}
else
{
q.Next = top;
top = q;
}
++num;
}
//出棧 進行出棧的操作 頭指針相減。此算法的復雜度為1
public T Pop()
{
if (IsEmpty())
{
Console.WriteLine("Stack is empty!");
return default(T);
}
Node<T> p = top;
top = top.Next;
--num;
return p.Data;
}
//獲取棧頂結點的值 返回頭指針的值 此算法的復雜度為一。
public T GetTop()
{
if (IsEmpty())
{
Console.WriteLine("Stack is empty!");
return default(T);
}
return top.Data;
}
}
這就是鏈棧的介紹的。還介紹一個棧的明顯的應用，這就是簡易萬能計算器的應用。
我們都知道在使用算符優先文法時必須使用兩個基本棧，數棧(operand stack)和運算符棧(operator stack)，來完成計算工作，然而單單使用這兩個棧有一定的局限性，因此在設計時，我引入了第三個棧(op stack)，下面我們就來分析一下。
在使用兩個棧時，如果遇到表達式 2-3*/6#，會發生什么呢？
|
步驟號
|
數字棧
|
運算符棧
|
當前輸入
|
剩余字符串
|
說明
|
|
1
|
空
|
#
|
|
2-3*/6#
|
|
|
2
|
空
|
#
|
2
|
-3*/6#
|
|
|
3
|
2
|
#
|
-
|
3*/6#
|
|
|
4
|
2
|
# -
|
3
|
*/6#
|
|
|
5
|
2 3
|
# -
|
*
|
/6#
|
|
|
6
|
2 3
|
# - *
|
/
|
6#
|
*>/，運算2*3，-</，push(/)
|
|
7
|
6
|
# - /
|
6
|
#
|
|
|
8
|
6 6
|
# - /
|
#
|
|
/>#，運算6/6，
->#，試圖運算，由於缺少數符，報錯，錯誤定位在減號
|
|
9
|
空
|
# -
|
|
|
|
此時，錯誤信息為：在minus附近可能存在錯誤。但實際上問題出在*或/號附近，這種報錯的定位結果是不能令人滿意的。
於是讓我們看看如果引入第三個棧作符號棧會如何？符號棧的功能是保存所有分析過程中的符號，包括數符和運算符兩種。
|
步驟號
|
數字棧
|
運算符棧
|
符號棧
|
當前輸入
|
剩余字符串
|
說明
|
|
1
|
空
|
#
|
#
|
|
2-3*/6#
|
|
|
2
|
空
|
#
|
#
|
2
|
-3*/6#
|
|
|
3
|
2
|
#
|
# 2
|
-
|
3*/6#
|
|
|
4
|
2
|
# -
|
# 2 -
|
3
|
*/6#
|
|
|
5
|
2 3
|
# -
|
# 2 – 3
|
*
|
/6#
|
|
|
6
|
2 3
|
# - *
|
# 2 – 3 *
|
/
|
6#
|
*>/，運算2*3，-</，push(/)
|
|
7
|
6
|
# - /
|
# 2 6 /
|
6
|
#
|
|
|
8
|
6 6
|
# - /
|
# 2 6 / 6
|
#
|
|
/>#, 拋出6后，先對/和棧中的6做絕對鄰近檢查，再對6和2做絕對鄰近檢查，但卻發現6和2不能相鄰，所以報錯，此時錯誤定位於除號
|
錯誤定位在/號，錯誤信息為：在divide附近存在錯誤。這樣將使用戶更有可能找到表達式中的問題所在。我們通過每次運算時(對應於SemanticAnalyzer.FakeCalculate()方法)，利用了絕對相鄰優先級表對符號棧的彈出符號進行相鄰性檢查，只要發現棧頂的兩個符號不能相鄰，則馬上報錯。具體情況，如圖所示：
什么是隊列，所謂的隊列是隊列(Queue)是插入操作限定在表的尾部而其它操作限定在表的頭部進行的,線性表。把進行插入操作的表尾稱為隊尾(Rear)，把進行其它操作的頭部稱為隊頭(Front)。當對列中沒有數據元素時稱為空對列(Empty Queue)。隊列通常記為：Q= (a1,a2,…,an)，Q是英文單詞queue的第 1 個字母。a1為隊頭元素，an為隊尾元素。這n個元素是按照a1,a2,…,an的次序依次入隊的，出對的次序與入隊相同，a1第一個出隊，an最后一個出隊。所以，對列的操作是按照先進先出(First In First Out)或后進后出( Last In Last Out)的原則進行的，這就像 排隊買票 ，買完就做。因此，隊列又稱為FIFO表或LILO表。隊列Q的操作示意圖如圖所示。具體情況，如圖所示：
隊列的形式化定義為：隊列(Queue)簡記為 Q，是一個二元組， Q = (D, R) 其中：D 是數據元素的有限集合； 是數據元素之間關系的有限集合。 在實際生活中有許多類似於隊列的例子。比如，排隊取錢，先來的先取，后來的排在隊尾。
同樣，我們以 C#語言的泛型接口來表示隊列，接口中的方法成員表示基本操作。為了表示的方便與簡潔，把泛型隊列接口取名為 IQueue<T>（實際上，在C#中泛型隊列類是從 IEnumerable<T>、 ICollection 和 IEnumerable 接口繼承而來，沒有 IQueue<T>泛型接口） 。隊列接口 IQueue<T>源代碼的定義如下所示。
public interface IQueue<T> {
int GetLength(); //求隊列的長度；初始條件：隊列存在； 操作結果：返回隊列中數據元素的個數。一切開始，如圖所示：
bool IsEmpty(); //判斷對列是否為空；初始條件：隊列存在； 操作結果：如果隊列為空返回 true，否則返回 false。 一切情況，如圖所示：
void Clear(); //清空隊列；初始條件：隊列存在； 操作結果：使隊列為空。
void In(T item); //入隊 初始條件：隊列存在;操作結果：將值為 item 的新數據元素添加到隊尾，隊列發生變化.
T Out(); //出隊 進行出隊的操作 返回頭結點 具體情況 如圖所示
此算法復雜度是O(1)
T GetFront(); //取對頭元素 取頭元素 具體情況 如圖所示
此算法的復雜度是O(1)
此算法復雜度是O(1)
}
這就是隊列是 基本介紹。
下面我介紹了的隊列的應用，我就是在五子棋，用與保存棋譜，悔棋的操作。這就很好的利用了隊列先進特點保存了，當你悔棋了，就把棋子的位置拉出來。
這就是隊列和棧的介紹。