【C#數據結構系列】棧和隊列

 一：棧

　　棧和隊列也是線性結構，線性表、棧和隊列這三種數據結構的數據元素以及數據元素間的邏輯關系完全相同，差別是線性表的操作不受限制，而棧和隊列的操作受到限制。棧的操作只能在表的一端進行，隊列的插入操作在表的一端進行而其它操作在表的另一端進行，所以，把棧和隊列稱為操作受限的線性表。

1:棧的定義及基本運算

　　棧(Stack)是操作限定在表的尾端進行的線性表。表尾由於要進行插入、刪除等操作，所以，它具有特殊的含義，把表尾稱為棧頂（Top），另一端是固定的，叫棧底（Bottom）。當棧中沒有數據元素時叫空棧(Empty Stack)。

　　棧通常記為：S= (a 1 ,a 2 ,…,a n )，S是英文單詞stack的第 1 個字母。a 1 為棧底元素，a n 為棧頂元素。這n個數據元素按照a 1 ,a 2 ,…,a n 的順序依次入棧，而出棧的次序相反，a n 第一個出棧，a 1 最后一個出棧。所以，棧的操作是按照后進先出(Last In First Out，簡稱LIFO)或先進后出(First In Last Out，簡稱FILO)的原則進行的，因此，棧又稱為LIFO表或FILO表。

　　

　　由於棧只能在棧頂進行操作，所以棧不能在棧的任意一個元素處插入或刪除元素。因此，棧的操作是線性表操作的一個子集。棧的操作主要包括在棧頂插入元素和刪除元素、取棧頂元素和判斷棧是否為空等。

　　棧的接口定義如下所示：

public interface IStack<T> 
{
    int GetLength(); //求棧的長度
    bool IsEmpty(); //判斷棧是否為空
    void Clear(); //清空操作
    void Push(T item); //入棧操作
    T Pop(); //出棧操作
    T GetTop(); //取棧頂元素
}

　　

2：棧的存儲和運算實現

1、順序棧：

　　用一片連續的存儲空間來存儲棧中的數據元素，這樣的棧稱為順序棧(Sequence Stack)。類似於順序表，用一維數組來存放順序棧中的數據元素。

　　順序棧類 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;
        }
        //清空順序棧
        public void Clear()
        {
            top = -1;
        }
        //判斷順序棧是否為空
        public bool IsEmpty()
        {
            if (top == -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //判斷順序棧是否為滿
        public bool IsFull()
        {
            if (top == maxsize - 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //入棧
        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];
        }
    }

 

2、鏈棧　　

　　棧的另外一種存儲方式是鏈式存儲，這樣的棧稱為鏈棧(Linked Stack)。鏈棧通常用單鏈表來表示，它的實現是單鏈表的簡化。所以，鏈棧結點的結構與單鏈表結點的結構一樣，如圖 3.3 所示。由於鏈棧的操作只是在一端進行，為了操作方便，把棧頂設在鏈表的頭部，並且不需要頭結點。

　　鏈棧結點類(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>的實現說明如下所示。

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;
        }
        //求鏈棧的長度
        public int GetLength()
        {
            return num;
        }
        //清空鏈棧
        public void Clear()
        {
            top = null;
            num = 0;
        }
        //判斷鏈棧是否為空
        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;
        }
        //出棧
        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;
        }
    }

　　

3：C#中的棧

　　C#2.0 以下版本只提供了非泛型的 Stack 類，該類繼承了 ICollection、IEnumerable 和 ICloneable 接口。C#2.0 提供了泛型的 Stack<T>類，該類繼承了 IEnumerable<T>、ICollection 和 IEnumerable 接口。

 

二：隊列

1：隊列的定義及基本運算

　　隊列(Queue)是插入操作限定在表的尾部而其它操作限定在表的頭部進行的線性表。把進行插入操作的表尾稱為隊尾(Rear)，把進行其它操作的頭部稱為隊頭(Front)。當對列中沒有數據元素時稱為空對列(Empty Queue)。

　　隊列通常記為：Q= (a 1 ,a 2 ,…,a n )，Q是英文單詞queue的第 1 個字母。a 1 為隊頭元素，a n 為隊尾元素。這n個元素是按照a 1 ,a 2 ,…,a n 的次序依次入隊的，出對的次序與入隊相同，a 1 第一個出隊，a n 最后一個出隊。所以，對列的操作是按照先進先出(First In First Out)或后進后出( Last In Last Out)的原則進行的，因此，隊列又稱為FIFO表或LILO表。隊列Q的操作如下圖。

　　

　　隊列的操作是線性表操作的一個子集。隊列的操作主要包括在隊尾插入元素、在隊頭刪除元素、取隊頭元素和判斷隊列是否為空等。與棧一樣，隊列的運算是定義在邏輯結構層次上的，而運算的具體實現是建立在物理存儲結構層次上的。因此，把隊列的操作作為邏輯結構的一部分，每個操作的具體實現只有在確定了隊列的存儲結構之后才能完成。隊列的基本運算不是它的全部運算，而是一些常用的基本運算。

　　隊列接口 IQueue<T>的定義如下所示。

public interface IQueue<T>
    {
        int GetLength(); //求隊列的長度
        bool IsEmpty(); //判斷對列是否為空
        void Clear(); //清空隊列
        void In(T item); //入隊
        T Out(); //出隊
        T GetFront(); //取對頭元素
    }

 

2：隊列的存儲和運算實現

1、順序隊列　　

　　用一片連續的存儲空間來存儲隊列中的數據元素，這樣的隊列稱為順序隊列(Sequence Queue)。

 　  類似於順序棧，用一維數組來存放順序隊列中的數據元素。隊頭位置設在數組下標為 0 的端，用 front 表示；隊尾位置設在數組的另一端，用 rear 表示。front 和 rear 隨着插入和刪除而變化。當隊列為空時，front=rear=-1。下圖是順序隊列的兩個指示器與隊列中數據元素的關系圖。

　　當有數據元素入隊時，隊尾指示器 rear 加 1，當有數據元素出隊時，隊頭指示器 front 加 1。當 front=rear 時，表示隊列為空，隊尾指示器 rear 到達數組的上限處而 front 為-1 時，隊列為滿，如圖(c)所示。隊尾指示器 rear 的值大於隊頭指示器 front 的值，隊列中元素的個數可以由 rear-front 求得。

　　由圖 (d)可知，如果再有一個數據元素入隊就會出現溢出。但事實上隊列中並未滿，還有空閑空間，把這種現象稱為“假溢出”。這是由於隊列“隊尾入隊頭出”的操作原則造成的。解決假溢出的方法是將順序隊列看成是首尾相接的循環結構，頭尾指示器的關系不變，這種隊列叫循環順序隊列( Circular sequenceQueue )。循環隊列如下圖。

 

　　當隊尾指示器 rear 到達數組的上限時，如果還有數據元素入隊並且數組的第0 個空間空閑時，隊尾指示器 rear 指向數組的 0 端。所以，隊尾指示器的加 1 操作修改為：

　　　　　　　　　　rear = (rear + 1) % maxsize　　

　　隊頭指示器的操作也是如此。當隊頭指示器 front 到達數組的上限時，如果還有數據元素出隊，隊頭指示器 front 指向數組的 0 端。所以，隊頭指示器的加1 操作修改為：

　　　　　　　　　　front = (front + 1) % maxsize

 2：循環順序隊列操作示意圖如下

　　

　　由圖可知，隊尾指示器 rear 的值不一定大於隊頭指示器 front 的值，並且隊滿和隊空時都有 rear=front。也就是說，隊滿和隊空的條件都是相同的。解決這個問題的方法一般是少用一個空間，如圖 (d)所示，把這種情況視為隊滿。所以，判斷隊空的條件是：rear==front，判斷隊滿的條件是：(rear + 1)% maxsize==front。求循環隊列中數據元素的個數可由(rear-front+maxsize)%maxsize公式求得。

public class CSeqQueue<T> : IQueue<T>
    {
        private int maxsize; //循環順序隊列的容量
        private T[] data; //數組，用於存儲循環順序隊列中的數據元素
        private int front; //指示循環順序隊列的隊頭
        private int rear; //指示循環順序隊列的隊尾
        //索引器
        public T this[int index]
        {
            get
            {
                return data[index];
            }
            set
            {
                data[index] = value;
            }
        }
        //容量屬性
        public int Maxsize
        {
            get
            {
                return maxsize;
            }
            set
            {
                maxsize = value;
            }
        }
        //隊頭屬性
        public int Front
        {
            get
            {
                return front;
            }
            set
            {
                front = value;
            }
        }
        //隊尾屬性
        public int Rear
        {
            get
            {
                return rear;
            }
            set
            {
                rear = value;
            }

        }
        //構造器
        public CSeqQueue(int size)
        {
            data = new T[size];
            maxsize = size;
            front = rear = -1;
        }
        //求循環順序隊列的長度
        public int GetLength()
        {
            return (rear - front + maxsize) % maxsize;
        }
        //清空循環順序隊列
        public void Clear()
        {
            front = rear = -1;
        }
        //判斷循環順序隊列是否為空
        public bool IsEmpty()
        {
            if (front == rear)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //判斷循環順序隊列是否為滿
        public bool IsFull()
        {
            if ((rear + 1) % maxsize == front)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //入隊
        public void In(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("Queue is full");
                return;
            }
            data[++rear] = item;
        }
        //出隊
        public T Out()
        {
            T tmp = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty");
                return tmp;
            }
            tmp = data[++front];
            return tmp;
        }
        //獲取隊頭數據元素
        public T GetFront()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty!");
                return default(T);
            }
            return data[front + 1];
        }
    }

　　

 3：鏈隊列

　　隊列的另外一種存儲方式是鏈式存儲，這樣的隊列稱為鏈隊列(LinkedQueue)。同鏈棧一樣，鏈隊列通常用單鏈表來表示，它的實現是單鏈表的簡化。所以，鏈隊列的結點的結構與單鏈表一樣，由於鏈隊列的操作只是在一端進行，為了操作方便，把隊頭設在鏈表的頭部，並且不需要頭結點。

節點示意圖：

　　　　　　　　

 

 

鏈隊列示意圖：

 

　　　　　　　　　　

　　把鏈隊列看作一個泛型類，類名為 LinkQueue<T>。LinkQueue<T>類中有兩個字段 front 和 rear，表示隊頭指示器和隊尾指示器。由於隊列只能訪問隊頭的數據元素，而鏈隊列的隊頭指示器和隊尾指示器又不能指示隊列的元素個數，所以，與鏈棧一樣，在 LinkQueue<T>類增設一個字段 num 表示鏈隊列中結點的個數。鏈隊列類 LinkQueue<T>的實現說明如下所示。

　　

public class LinkQueue<T> : IQueue<T>
    {
        private Node<T> front; //隊列頭指示器
        private Node<T> rear; //隊列尾指示器
        private int num; //隊列結點個數
        //隊頭屬性
        public Node<T> Front
        {
            get
            {
                return front;
            }
            set
            {
                front = value;
            }
        }
        //隊尾屬性
        public Node<T> Rear
        {
            get
            {
                return rear;
            }
            set
            {
                rear = value;
            }
        }
        //隊列結點個數屬性
        public int Num
        {
            get
            {
                return num;
            }
            set
            {
                num = value;
            }
        }
        //構造器
        public LinkQueue()
        {
            front = rear = null;
            num = 0;
        }
        //求鏈隊列的長度
        public int GetLength()
        {
            return num;
        }
        //清空鏈隊列
        public void Clear()
        {
            front = rear = null;
            num = 0;
        }
        //判斷鏈隊列是否為空
        public bool IsEmpty()
        {
            if ((front == rear) && (num == 0))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //入隊
        public void In(T item)
        {
            Node<T> q = new Node<T>(item);
            if (rear == null)
            {
                rear = q;
            }
            else
            {
                rear.Next = q;
                rear = q;
            }
            ++num;
        }
        //出隊
        public T Out()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty!");
                return default(T);
            }
            Node<T> p = front;
            front = front.Next;
            if (front == null)
            {
                rear = null;
            }
            --num;
            return p.Data;
        }
        //獲取鏈隊列頭結點的值
        public T GetFront()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is empty!");
                return default(T);
            }
            return front.Data;
        }
    }

 

　　3.1：C# 中的隊列

　　C#2.0 以下版本只提供了非泛型的 Queue 類，該類繼承了 ICollection、IEnumerable 和 ICloneable 接口。C#2.0 提供了泛型的 Queue<T>類，該類繼承了 IEnumerable<T>、ICollection 和 IEnumerable 接口。以下程序說明了泛型Queue<T>類的主要方法，並對在我們自定義的隊列類中沒有出現的成員方法進行了注釋，關於泛型 Queue<T>類的更具體的信息，讀者可參考.NET Framework的有關書籍。　　

 

三 ： 小結

　　棧和隊列是計算機中常用的兩種數據結構，是操作受限的線性表。棧的插入和刪除等操作都在棧頂進行，它是先進后出的線性表。隊列的刪除操作在隊頭進行，而插入、查找等操作在隊尾進行，它是先進先出的線性表。與線性表一樣，棧和隊列有兩種存儲結構，順序存儲的棧稱為順序棧，鏈式存儲的棧稱為鏈棧。順序存儲的隊列稱為順序對列，鏈式存儲的隊列稱為鏈隊列。

　　為解決順序隊列中的假溢出問題，采用循環順序隊列，但出現隊空和隊滿的判斷條件相同的問題，判斷條件都是：front==rear。采用少用一個存儲單元來解決該問題。此時，隊滿的判斷條件是：(rear+1)%maxsize==front，判斷隊空的條件是：rear==front。

　　棧適合於具有先進后出特性的問題，如括號匹配、表達式求值等問題；隊列適合於具有先進先出特性的問題，如排隊等問題。