現實生活中的事情往往都能總結歸納成一定的資料結構，例如餐館中餐盤的堆疊和使用，羽毛球筒裡裝的羽毛球等都是典型的棧結構。而在.NET中，值型別線上程棧上進行分配，引用型別在託管堆上進行分配，本文所說的“棧”正是這種資料結構。棧和佇列都是常用的資料結構，它們的邏輯結構與線性表相通，不同之處則在於操作受某種特殊限制。因此，棧和佇列也被稱為操作受限的線性表。這裡，我們首先來了解一下棧。

一、棧的概念及操作

1.1 棧的基本特徵

棧（stack）是限定僅在表尾進行插入和刪除操作的線性表。其特點是：”後進先出“或”先進後出“。

1.2 棧的基本操作

　　（1）棧的插入操作，叫作進棧，也稱壓棧、入棧：

　　（2）棧的刪除操作，叫作出棧，也有的叫作彈棧：

二、棧的基本實現

　　既然棧屬於特殊的線性表，那麼其實現也會有兩種形式：順序儲存結構和鏈式儲存結構。首先，對於Stack，我們希望能夠提供以下幾個方法供呼叫：

2.1 棧的順序儲存實現

　　對於順序儲存，我們可以參照順序表的實現方式，藉助陣列來儲存各個資料元素，然後對這個陣列進行一定的封裝，提供指定的操作對資料元素進行插入和刪除即可。

　　（1）入棧操作實現

        /// <summary>
        /// 入棧
        /// </summary>
        /// <param name="node">節點元素</param>
        public void Push(T node)
        {
            if (index == nodes.Length)
            {
                
 
// 增大陣列容量
                ResizeCapacity(nodes.Length * 2);
            }

            nodes[index] = node;
            index++;
        }

　　藉助陣列來實現入棧操作，其關鍵之處就在於top指標的移動。這裡index初始值為0，每次入棧一個則將index加1，即指向下一個即將入棧的位置。由於這裡採用了動態擴容的機制，所以沒有判斷棧中元素個數是否達到了最大值。

　　（2）出棧操作實現

　　出棧操作需要先去的要出棧的元素，然後將index減1，即指向下一個即將出棧的元素的位置。

        /// <summary>
        /// 出棧
        /// </summary>
        /// <returns>出棧節點元素</returns>
        public T Pop()
        {
            if(index == 0)
            {
                return default(T);
            }

            T node = nodes[index - 1];
            index--;
            nodes[index] = default(T);

            if (index > 0 && index == nodes.Length / 4)
            {
                // 縮小陣列容量
                ResizeCapacity(nodes.Length / 2);
            }
            return node;
        }

　　這裡首先需要判斷index是否已經到達了最小值，出棧的元素位置需要置為預設值（如果是int陣列，那麼會重置為0），最後返回出棧的元素物件。這裡當元素個數小於陣列的四分之一時會進行容量收縮操作。

　　（3）完整的類實現

    /// <summary>
    /// 基於陣列的棧實現
    /// </summary>
    /// <typeparam name="T">型別</typeparam>
    public class MyArrayStack<T>
    {
        private T[] nodes;
        private int index;

        public MyArrayStack(int capacity)
        {
            this.nodes = new T[capacity];
            this.index = 0;
        }

        /// <summary>
        /// 入棧
        /// </summary>
        /// <param name="node">節點元素</param>
        public void Push(T node)
        {
            if (index == nodes.Length)
            {
                // 增大陣列容量
                ResizeCapacity(nodes.Length * 2);
            }

            nodes[index] = node;
            index++;
        }

        /// <summary>
        /// 出棧
        /// </summary>
        /// <returns>出棧節點元素</returns>
        public T Pop()
        {
            if(index == 0)
            {
                return default(T);
            }

            T node = nodes[index - 1];
            index--;
            nodes[index] = default(T);

            if (index > 0 && index == nodes.Length / 4)
            {
                // 縮小陣列容量
                ResizeCapacity(nodes.Length / 2);
            }
            return node;
        }

        /// <summary>
        /// 重置陣列大小
        /// </summary>
        /// <param name="newCapacity">新的容量</param>
        private void ResizeCapacity(int newCapacity)
        {
            T[] newNodes = new T[newCapacity];
            if(newCapacity > nodes.Length)
            {
                for (int i = 0; i < nodes.Length; i++)
                {
                    newNodes[i] = nodes[i];
                }
            }
            else
            {
                for (int i = 0; i < newCapacity; i++)
                {
                    newNodes[i] = nodes[i];
                }
            }

            nodes = newNodes;
        }

        /// <summary>
        /// 棧是否為空
        /// </summary>
        /// <returns>true/false</returns>
        public bool IsEmpty()
        {
            return this.index == 0;
        }

        /// <summary>
        /// 棧中節點個數
        /// </summary>
        public int Size
        {
            get
            {
                return this.index;
            }
        }
    }

　　（4）簡單的功能測試

　　首先，順序入棧10個隨機數，輸出其元素個數與是否為空；然後依次出棧，輸出每個資料元素；最後，再入棧15個隨機數並出棧輸出。

        /// <summary>
        /// 基於陣列的棧的測試
        /// </summary>
        static void StackWithArrayTest()
        {
            MyArrayStack<int> stack = new MyArrayStack<int>(10);
            Console.WriteLine(stack.IsEmpty());

            Random rand = new Random();
            for (int i = 0; i < 10; i++)
            {
                stack.Push(rand.Next(1, 10));
            }
            Console.WriteLine("IsEmpty:{0}",stack.IsEmpty());
            Console.WriteLine("Size:{0}", stack.Size);
            Console.WriteLine("-------------------------------");

            for (int i = 0; i < 10; i++)
            {
                int node = stack.Pop();
                Console.Write(node + " ");
            }
            Console.WriteLine();
            Console.WriteLine("IsEmpty:{0}", stack.IsEmpty());
            Console.WriteLine("Size:{0}", stack.Size);
            Console.WriteLine("-------------------------------");

            for (int i = 0; i < 15; i++)
            {
                stack.Push(rand.Next(1, 15));
            }
            for (int i = 0; i < 15; i++)
            {
                int node = stack.Pop();
                Console.Write(node + " ");
            }
            Console.WriteLine();
        }

　　執行結果如下所示：

2.2 棧的鏈式儲存實現

　　對棧的鏈式儲存結構，我們可以參照單鏈表，為其設定一個頭結點。這裡，我們先來看看節點的定義：

　　（1）節點的定義實現

    /// <summary>
    /// 基於連結串列的棧節點
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Node<T>
    {
        public T Item { get; set; }
        public Node<T> Next { get; set; }

        public Node(T item)
        {
            this.Item = item;
        }

        public Node()
        { }
    }

　　（2）入棧操作的實現

　　實現Push方法，即向棧頂壓入一個元素，首先儲存原先的位於棧頂的元素，然後新建一個新的棧頂元素，然後將該元素的下一個指向原先的棧頂元素。

    /// <summary>
    /// 入棧
    /// </summary>
    /// <param name="item">新節點</param>
    public void Push(T item)
    {
         Node<T> oldNode = first;
         first = new Node<T>();
         first.Item = item;
         first.Next = oldNode;

         index++;
     }

　　（3）出棧操作的實現

　　實現Pop方法，首先儲存棧頂元素的值，然後將棧頂元素設定為下一個元素：

    /// <summary>
    /// 出棧
    /// </summary>
    /// <returns>出棧元素</returns>
    public T Pop()
    {
        T item = first.Item;
        first = first.Next;
        index--;

        return item;
    }

　　這裡還可以考慮將出棧元素的例項物件進行釋放資源操作。

　　（4）完整的程式碼實現

    /// <summary>
    /// 基於連結串列的棧節點
    /// </summary>
    /// <typeparam name="T">元素型別</typeparam>
    public class Node<T>
    {
        public T Item { get; set; }
        public Node<T> Next { get; set; }

        public Node(T item)
        {
            this.Item = item;
        }

        public Node()
        { }
    }

    /// <summary>
    /// 基於連結串列的棧實現
    /// </summary>
    /// <typeparam name="T">型別</typeparam>
    public class MyLinkStack<T>
    {
        private Node<T> first;
        private int index;

        public MyLinkStack()
        {
            this.first = null;
            this.index = 0;
        }

        /// <summary>
        /// 入棧
        /// </summary>
        /// <param name="item">新節點</param>
        public void Push(T item)
        {
            Node<T> oldNode = first;
            first = new Node<T>();
            first.Item = item;
            first.Next = oldNode;

            index++;
        }

        /// <summary>
        /// 出棧
        /// </summary>
        /// <returns>出棧元素</returns>
        public T Pop()
        {
            T item = first.Item;
            first = first.Next;
            index--;

            return item;
        }

        /// <summary>
        /// 是否為空棧
        /// </summary>
        /// <returns>true/false</returns>
        public bool IsEmpty()
        {
            return this.index == 0;
        }

        /// <summary>
        /// 棧中節點個數
        /// </summary>
        public int Size
        {
            get
            {
                return this.index;
            }
        }
    }

　　（5）簡單的功能測試

　　這裡跟順序儲存結構的測試程式碼一致，就不再貼出來，直接看執行結果吧：

三、棧的基本應用

　　棧的應用場景很多，最常見的莫過於遞迴操作了，另外在運算表示式的求值上也有應用。這裡看一個最經典的應用場景，進位制轉換問題。講一個非負的十進位制整數N轉換成其他D進位制數是計算機計算的一個基本問題，如(135)10進位制=(207)8進位制。最簡單的解決辦法就是連續取模%和整除/，例如將10進位制的50轉換為2進位制數的過程如下圖所示：

　　由上圖的計算過程可知，D進位制各位數的產生順序是從低位到高位，而輸出順序卻是從高位到低位，剛好和計算過程是相反的，因此可以利用棧進行逆序輸出。

        private static string DecConvert(int num, int dec)
        {
            if (dec < 2 || dec > 16)
            {
                throw new ArgumentOutOfRangeException("dec", "只支援將十進位制數轉換為二進位制到十六進位制數");
            }

            MyLinkStack<char> stack = new MyLinkStack<char>();
            int residue;
            // 餘數入棧
            while (num != 0)
            {
                residue = num % dec;
                if (residue >= 10)
                {
                    // 如果是轉換為16進位制且餘數大於10則需要轉換為ABCDEF
                    residue = residue + 55;
                }
                else
                {
                    // 轉換為ASCII碼中的數字型字元1~9
                    residue = residue + 48;
                }
                stack.Push((char)residue);
                num = num / dec;
            }
            // 反序出棧
            string result = string.Empty;
            while (stack.Size > 0)
            {
                result += stack.Pop();
            }

            return result;
        }

　　這裡考慮到輸出，所以使用了char型別作為節點資料型別，因此需要考慮ASCII碼中的數字型字元與字母型字元。執行結果如下圖所示：

　　①10進位制數：350=>8進位制數：536

　　②10進位制數：72=>16進位制數：48

　　③10進位制數：38=>2進位制數：100110

四、.NET中的Stack<T>

　　在.NET中，微軟已經為我們提供了一個強大的棧型別：Stack<T>，這裡我們使用Reflector工具檢視其具體實現，具體看看Push和Pop兩個方法，其他的各位園友可以自己去檢視。

　　（1）Push方法原始碼

public void Push(T item)
{
    if (this._size == this._array.Length)
    {
        T[] destinationArray = new T[(this._array.Length == 0) ? 4 : (2 * this._array.Length)];
        Array.Copy(this._array, 0, destinationArray, 0, this._size);
        this._array = destinationArray;
    }
    this._array[this._size++] = item;
    this._version++;
}

　　（2）Pop方法原始碼

public T Pop()
{
    if (this._size == 0)
    {
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyStack);
    }
    this._version++;
    T local = this._array[--this._size];
    this._array[this._size] = default(T);
    return local;
}

　　可以看出，在.NET中Stack的實現是基於陣列來實現的，在初始化時為其設定了一個預設的陣列大小，在Push方法中當元素個數達到陣列長度時，擴充2倍容量，然後將原陣列拷貝到新的陣列中。Pop方法中則跟我們剛剛實現的程式碼基本相同。

參考資料

（1）程傑，《大話資料結構》

（2）陳廣，《資料結構（C#語言描述）》

（3）段恩澤，《資料結構（C#語言版）》

作者：周旭龍

本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連結。