棧（Stack） --- C# 自定義和微軟官方的區別

最近在學習演算法基礎，本篇文章作為一個記錄，也算是一次實踐和總結。（順便也深入C#執行時學習一下）

 

目錄

1. 棧是什麼

2. Stack 自定義實現

3. Stack C#官方實現

4. 區別

5. 總結

 

1. 棧是什麼

　　棧是一種特殊的線性表（資料邏輯結構中的一種，定義是其組成元素之間具有線性關係的一種線性結構），其插入和刪除操作只能在一端進行。

個人理解：
是一種最基本的資料結構，資料結構方面必須夯實的基礎知識

 特徵（也可以說是應用場景）：

　　後進先出（佇列則為先進先出）

2. Stack 自定義實現

Github： https://github.com/HadesKing/DataStructureAndAlgorithms

程式碼路徑：BasicDataStructure\src\LD.BasicDataStructures\Stacks

Stack實現方式有兩種：順序儲存和鏈式儲存（順序棧和鏈式棧）

為了便於使用，我對棧進行了抽象，形成了一個介面IStack

// Copyright (c) 劉迪. All rights reserved.
//
// Author: 劉迪
// Create Time: 2021-04-30
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
// 
// 
//

using System;

namespace LD.BasicDataStructures.Stacks
{
    /// <summary>
    /// 棧的介面 
    /// </summary>
    /// <typeparam name="T">type of data element</typeparam>
    /// <remarks>
    /// 主要用於定義棧的公共操作
    /// </remarks>
    public interface IStack<T>
    {
        /// <summary>
        /// Gets the number of elements contained in the Stack.
        /// </summary>
        Int32 Count { get; }

        /// <summary>
        /// Verify that it is empty.
        /// </summary>
        /// <returns>
        /// <c>true</c> Is empty.
        /// <c>false</c> Not is empty.
        /// </returns>
        bool IsEmpty();

        /// <summary>
        /// Add a data element to the stack.
        /// </summary>
        /// <param name="element">value of data element</param>
        /// <returns>
        /// <c>true</c> The operation was successful.
        /// <c>false</c> The operation failed.
        /// </returns>
        bool Push(T element);

        /// <summary>
        /// Pop up a data element from the stack.If there is no data element in the stack, it returns null.
        /// </summary>
        /// <returns>
        /// Data element being popped.If there is no data element in the stack, it returns null.
        /// </returns>
        T Pop();

        /// <summary>
        /// Get a data element from the stack.If the stack is empty, return null.
        /// </summary>
        /// <returns>
        /// Data element.If the stack is empty, return null
        /// </returns>
        T Get();

    }
}

順序棧的實現

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Copyright (c) 劉迪. All rights reserved.
//
// Author: 劉迪
// Create Time: 2021-05-01 
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
// 
// 
//

namespace LD.BasicDataStructures.Stacks
{
    /// <summary>
    /// Implementation of sequential stack
    /// </summary>
    /// <typeparam name="T">Type of data</typeparam>
    public sealed class SequentialStack<T> : IStack<SequentialNode<T>>
    {
        private SequentialNode<T>[] m_sequentialNodes = null;
        private Int32 m_dataElementNumber = 0;

        /// <summary>
        /// 建構函式
        /// </summary>
        public SequentialStack() : this(10)
        {
        }

        /// <summary>
        /// 建構函式
        /// </summary>
        /// <param name="capacity">Stack capacity</param>
        public SequentialStack(UInt32 capacity)
        {
            m_sequentialNodes = new SequentialNode<T>[capacity];
        }

        /// <summary>
        /// Gets the number of elements contained in the Stack.
        /// </summary>
        public Int32 Count => m_dataElementNumber;

        /// <summary>
        /// Verify that it is empty.
        /// </summary>
        /// <returns>
        /// <c>true</c> Is empty.
        /// <c>false</c> Not is empty.
        /// </returns>
        public bool IsEmpty()
        {
            return m_dataElementNumber == 0;
        }

        /// <summary>
        /// Add a data element to the stack.
        /// </summary>
        /// <param name="element">value of data element</param>
        /// <returns>
        /// <c>true</c> The operation was successful.
        /// <c>false</c> The operation failed.
        /// </returns>
        public bool Push(SequentialNode<T> element)
        {
            bool result = false;
            if (null != element)
            {
                if (m_dataElementNumber != m_sequentialNodes.Length)
                {
                    m_sequentialNodes[m_dataElementNumber] = element;
                    m_dataElementNumber++;
                    result = true;
                }
                else
                {
                    //擴容
                    var tmp = m_sequentialNodes;
                    m_sequentialNodes = new SequentialNode<T>[2 * m_dataElementNumber];
                    tmp.CopyTo(m_sequentialNodes, 0);
                    result = Push(element);
                }
            }

            return result;
        }

        /// <summary>
        /// Pop up a data element from the stack.
        /// If there is no data element in the stack, it returns null.
        /// </summary>
        /// <returns>
        /// Data element being popped.If there is no data element in the stack, it returns null.
        /// </returns>
        public SequentialNode<T> Pop()
        {
            if (0 != m_dataElementNumber)
            {
                m_dataElementNumber--;
                return m_sequentialNodes[m_dataElementNumber];
            }

            return null;
        }

        /// <summary>
        /// Get a data element from the stack.If the stack is empty, return null.
        /// </summary>
        /// <returns>
        /// Data element.If the stack is empty, return null
        /// </returns>
        public SequentialNode<T> Get()
        {
            if (0 != m_dataElementNumber)
            {
                return m_sequentialNodes[m_dataElementNumber - 1];
            }

            return null;
        }

    }
}

鏈式棧的實現

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Copyright (c) 劉迪. All rights reserved.
//
// Author: 劉迪
// Create Time: 2021-05-01 
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
//
// Modifier: xxx
// Modifier time: xxx
// Description: xxx
// 
// 
//

namespace LD.BasicDataStructures.Stacks
{
    /// <summary>
    /// Implementation of chain storage stack
    /// </summary>
    /// <typeparam name="T">Type of data</typeparam>
    public sealed class LinkedStack<T> : IStack<SinglyLinkedNode<T>>
    {

        private SinglyLinkedNode<T> m_topNode = null;
        private Int32 m_count = 0;

        /// <summary>
        /// Gets the number of elements contained in the Stack.
        /// </summary>
        public Int32 Count => m_count;

        public LinkedStack()
        {

        }

        /// <summary>
        /// Verify that it is empty.
        /// </summary>
        /// <returns>
        /// <c>true</c> Is empty.
        /// <c>false</c> Not is empty.
        /// </returns>
        public bool IsEmpty()
        {
            return null == m_topNode;
        }

        /// <summary>
        /// Add a data element to the stack.
        /// </summary>
        /// <param name="element">value of data element</param>
        /// <returns>
        /// <c>true</c> The operation was successful.
        /// <c>false</c> The operation failed.
        /// </returns>
        public bool Push(SinglyLinkedNode<T> element)
        {
            bool result = false;
            if (null != element)
            {
                if (null == m_topNode)
                {
                    m_topNode = element;
                }
                else
                {
                    var tmpNode = m_topNode;
                    element.Next = tmpNode;
                    m_topNode = element;
                }

                m_count++;
                result = true;
            }

            return result;
        }

        /// <summary>
        /// Pop up a data element from the stack.If there is no data element in the stack, it returns null.
        /// </summary>
        /// <returns>
        /// Data element being popped.If there is no data element in the stack, it returns null.
        /// </returns>
        public SinglyLinkedNode<T> Pop()
        {
            SinglyLinkedNode<T> returnNode = null;
            if (null != m_topNode)
            {
                returnNode = m_topNode;
                m_topNode = returnNode.Next;
                m_count--;
            }

            return returnNode;
        }

        /// <summary>
        /// Get a data element from the stack.If the stack is empty, return null.
        /// </summary>
        /// <returns>
        /// Data element.If the stack is empty, return null
        /// </returns>
        public SinglyLinkedNode<T> Get()
        {
            return m_topNode;
        }

    }
}

 

3. Stack C# 官方實現

Github： https://github.com/dotnet/runtime

Stack 檔案路徑：src\libraries\System.Collections\src\System\Collections\Generic\Stack.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

/*=============================================================================
**
**
** Purpose: An array implementation of a generic stack.
**
**
=============================================================================*/

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;

namespace System.Collections.Generic
{
    // A simple stack of objects.  Internally it is implemented as an array,
    // so Push can be O(n).  Pop is O(1).

    [DebuggerTypeProxy(typeof(StackDebugView<>))]
    [DebuggerDisplay("Count = {Count}")]
    [Serializable]
    [System.Runtime.CompilerServices.TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
    public class Stack<T> : IEnumerable<T>,
        System.Collections.ICollection,
        IReadOnlyCollection<T>
    {
        private T[] _array; // Storage for stack elements. Do not rename (binary serialization)
        private int _size; // Number of items in the stack. Do not rename (binary serialization)
        private int _version; // Used to keep enumerator in sync w/ collection. Do not rename (binary serialization)

        private const int DefaultCapacity = 4;

        public Stack()
        {
            _array = Array.Empty<T>();
        }

        // Create a stack with a specific initial capacity.  The initial capacity
        // must be a non-negative number.
        public Stack(int capacity)
        {
            if (capacity < 0)
                throw new ArgumentOutOfRangeException(nameof(capacity), capacity, SR.ArgumentOutOfRange_NeedNonNegNum);
            _array = new T[capacity];
        }

        // Fills a Stack with the contents of a particular collection.  The items are
        // pushed onto the stack in the same order they are read by the enumerator.
        public Stack(IEnumerable<T> collection)
        {
            if (collection == null)
                throw new ArgumentNullException(nameof(collection));
            _array = EnumerableHelpers.ToArray(collection, out _size);
        }

        public int Count
        {
            get { return _size; }
        }

        bool ICollection.IsSynchronized
        {
            get { return false; }
        }

        object ICollection.SyncRoot => this;

        // Removes all Objects from the Stack.
        public void Clear()
        {
            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
            {
                Array.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
            }
            _size = 0;
            _version++;
        }

        public bool Contains(T item)
        {
            // Compare items using the default equality comparer

            // PERF: Internally Array.LastIndexOf calls
            // EqualityComparer<T>.Default.LastIndexOf, which
            // is specialized for different types. This
            // boosts performance since instead of making a
            // virtual method call each iteration of the loop,
            // via EqualityComparer<T>.Default.Equals, we
            // only make one virtual call to EqualityComparer.LastIndexOf.

            return _size != 0 && Array.LastIndexOf(_array, item, _size - 1) != -1;
        }

        // Copies the stack into an array.
        public void CopyTo(T[] array, int arrayIndex)
        {
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }

            if (arrayIndex < 0 || arrayIndex > array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(arrayIndex), arrayIndex, SR.ArgumentOutOfRange_Index);
            }

            if (array.Length - arrayIndex < _size)
            {
                throw new ArgumentException(SR.Argument_InvalidOffLen);
            }

            Debug.Assert(array != _array);
            int srcIndex = 0;
            int dstIndex = arrayIndex + _size;
            while (srcIndex < _size)
            {
                array[--dstIndex] = _array[srcIndex++];
            }
        }

        void ICollection.CopyTo(Array array, int arrayIndex)
        {
            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }

            if (array.Rank != 1)
            {
                throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, nameof(array));
            }

            if (array.GetLowerBound(0) != 0)
            {
                throw new ArgumentException(SR.Arg_NonZeroLowerBound, nameof(array));
            }

            if (arrayIndex < 0 || arrayIndex > array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(arrayIndex), arrayIndex, SR.ArgumentOutOfRange_Index);
            }

            if (array.Length - arrayIndex < _size)
            {
                throw new ArgumentException(SR.Argument_InvalidOffLen);
            }

            try
            {
                Array.Copy(_array, 0, array, arrayIndex, _size);
                Array.Reverse(array, arrayIndex, _size);
            }
            catch (ArrayTypeMismatchException)
            {
                throw new ArgumentException(SR.Argument_InvalidArrayType, nameof(array));
            }
        }

        // Returns an IEnumerator for this Stack.
        public Enumerator GetEnumerator()
        {
            return new Enumerator(this);
        }

        /// <internalonly/>
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new Enumerator(this);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator(this);
        }

        public void TrimExcess()
        {
            int threshold = (int)(_array.Length * 0.9);
            if (_size < threshold)
            {
                Array.Resize(ref _array, _size);
                _version++;
            }
        }

        // Returns the top object on the stack without removing it.  If the stack
        // is empty, Peek throws an InvalidOperationException.
        public T Peek()
        {
            int size = _size - 1;
            T[] array = _array;

            if ((uint)size >= (uint)array.Length)
            {
                ThrowForEmptyStack();
            }

            return array[size];
        }

        public bool TryPeek([MaybeNullWhen(false)] out T result)
        {
            int size = _size - 1;
            T[] array = _array;

            if ((uint)size >= (uint)array.Length)
            {
                result = default!;
                return false;
            }
            result = array[size];
            return true;
        }

        // Pops an item from the top of the stack.  If the stack is empty, Pop
        // throws an InvalidOperationException.
        public T Pop()
        {
            int size = _size - 1;
            T[] array = _array;

            // if (_size == 0) is equivalent to if (size == -1), and this case
            // is covered with (uint)size, thus allowing bounds check elimination
            // https://github.com/dotnet/coreclr/pull/9773
            if ((uint)size >= (uint)array.Length)
            {
                ThrowForEmptyStack();
            }

            _version++;
            _size = size;
            T item = array[size];
            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
            {
                array[size] = default!;     // Free memory quicker.
            }
            return item;
        }

        public bool TryPop([MaybeNullWhen(false)] out T result)
        {
            int size = _size - 1;
            T[] array = _array;

            if ((uint)size >= (uint)array.Length)
            {
                result = default!;
                return false;
            }

            _version++;
            _size = size;
            result = array[size];
            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
            {
                array[size] = default!;
            }
            return true;
        }

        // Pushes an item to the top of the stack.
        public void Push(T item)
        {
            int size = _size;
            T[] array = _array;

            if ((uint)size < (uint)array.Length)
            {
                array[size] = item;
                _version++;
                _size = size + 1;
            }
            else
            {
                PushWithResize(item);
            }
        }

        // Non-inline from Stack.Push to improve its code quality as uncommon path
        [MethodImpl(MethodImplOptions.NoInlining)]
        private void PushWithResize(T item)
        {
            Debug.Assert(_size == _array.Length);
            Grow(_size + 1);
            _array[_size] = item;
            _version++;
            _size++;
        }

        /// <summary>
        /// Ensures that the capacity of this Stack is at least the specified <paramref name="capacity"/>.
        /// If the current capacity of the Stack is less than specified <paramref name="capacity"/>,
        /// the capacity is increased by continuously twice current capacity until it is at least the specified <paramref name="capacity"/>.
        /// </summary>
        /// <param name="capacity">The minimum capacity to ensure.</param>
        public int EnsureCapacity(int capacity)
        {
            if (capacity < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(capacity), capacity, SR.ArgumentOutOfRange_NeedNonNegNum);
            }

            if (_array.Length < capacity)
            {
                Grow(capacity);
                _version++;
            }

            return _array.Length;
        }

        private void Grow(int capacity)
        {
            Debug.Assert(_array.Length < capacity);

            int newcapacity = _array.Length == 0 ? DefaultCapacity : 2 * _array.Length;

            // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow.
            // Note that this check works even when _items.Length overflowed thanks to the (uint) cast.
            if ((uint)newcapacity > Array.MaxLength) newcapacity = Array.MaxLength;

            // If computed capacity is still less than specified, set to the original argument.
            // Capacities exceeding Array.MaxLength will be surfaced as OutOfMemoryException by Array.Resize.
            if (newcapacity < capacity) newcapacity = capacity;

            Array.Resize(ref _array, newcapacity);
        }

        // Copies the Stack to an array, in the same order Pop would return the items.
        public T[] ToArray()
        {
            if (_size == 0)
                return Array.Empty<T>();

            T[] objArray = new T[_size];
            int i = 0;
            while (i < _size)
            {
                objArray[i] = _array[_size - i - 1];
                i++;
            }
            return objArray;
        }

        private void ThrowForEmptyStack()
        {
            Debug.Assert(_size == 0);
            throw new InvalidOperationException(SR.InvalidOperation_EmptyStack);
        }

        public struct Enumerator : IEnumerator<T>, System.Collections.IEnumerator
        {
            private readonly Stack<T> _stack;
            private readonly int _version;
            private int _index;
            private T? _currentElement;

            internal Enumerator(Stack<T> stack)
            {
                _stack = stack;
                _version = stack._version;
                _index = -2;
                _currentElement = default;
            }

            public void Dispose()
            {
                _index = -1;
            }

            public bool MoveNext()
            {
                bool retval;
                if (_version != _stack._version) throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
                if (_index == -2)
                {  // First call to enumerator.
                    _index = _stack._size - 1;
                    retval = (_index >= 0);
                    if (retval)
                        _currentElement = _stack._array[_index];
                    return retval;
                }
                if (_index == -1)
                {  // End of enumeration.
                    return false;
                }

                retval = (--_index >= 0);
                if (retval)
                    _currentElement = _stack._array[_index];
                else
                    _currentElement = default;
                return retval;
            }

            public T Current
            {
                get
                {
                    if (_index < 0)
                        ThrowEnumerationNotStartedOrEnded();
                    return _currentElement!;
                }
            }

            private void ThrowEnumerationNotStartedOrEnded()
            {
                Debug.Assert(_index == -1 || _index == -2);
                throw new InvalidOperationException(_index == -2 ? SR.InvalidOperation_EnumNotStarted : SR.InvalidOperation_EnumEnded);
            }

            object? System.Collections.IEnumerator.Current
            {
                get { return Current; }
            }

            void IEnumerator.Reset()
            {
                if (_version != _stack._version) throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
                _index = -2;
                _currentElement = default;
            }
        }
    }
}

 PS：

　　深入瞭解了一下，CopyTo和Resize都會呼叫Buffer.Memmove方法

4. 區別

	優點	缺點	適用場景
自定義實現	小而美 1. 實現了棧的基本功能 2. 面向介面程式設計 3. 對資料元素做了進一步的封裝	1. 引數場景考慮不全面（例如：容量沒有進行校驗，使用UInt32型別的原因） 2. 當容量不足時，進行當前容量2倍的擴充，很容易造成浪費	知曉大概容量的少量資料操作
官方實現	大而全 1. 功能全面，並且根據不同場景做了很多定製化的功能（為了保證其通用性） 2. 資料元素完全泛型實現	無法自定義一些操作

 

PS：

　　自定義的實現本質是一個實驗性專案，這裡做對比，主要目的是感受和官方實現之間的差距（為了學習）

 

5. 總結

• 實現：場景考慮不夠全面（對於資料的理解和校驗明顯不足）
• 技術：對於C#理解不夠深入（runtime原始碼需要進一步深入學習和檢視）

 

---------------------------------- 人生格言 ---------------------------------------------------------------

輸入決定輸出，沒有輸入就沒有輸出。