栈（Stack） --- C# 自定义和微软官方的区别

最近在学习算法基础，本篇文章作为一个记录，也算是一次实践和总结。（顺便也深入C#运行时学习一下）

目录

1. 栈是什么

2. Stack 自定义实现

3. Stack C#官方实现

4. 区别

5. 总结

1. 栈是什么

　　栈是一种特殊的线性表（数据逻辑结构中的一种，定义是其组成元素之间具有线性关系的一种线性结构），其插入和删除操作只能在一端进行。

个人理解：
是一种最基本的数据结构，数据结构方面必须夯实的基础知识

 特征（也可以说是应用场景）：

　　后进先出（队列则为先进先出）

2. Stack 自定义实现

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

代码路径：BasicDataStructuresrcLD.BasicDataStructuresStacks

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 文件路径：srclibrariesSystem.CollectionssrcSystemCollectionsGenericStack.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源码需要进一步深入学习和查看）

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

输入决定输出，没有输入就没有输出。