1、栈是一种先进后出的结构，如图：

 我们用代码，简单实现一下：

public class StackTest<T>
    {
        private T[] stack { get; set; }
        public int length { get; set; }
        public StackTest()
        {
            length = 0;
            stack = new T[length];
        }
        public void push(T item)
        {
            if (length == stack.Length)
            {
                T[] temp = new T[length + 1];
                Array.Copy(stack, 0, temp, 0, length);
                stack = temp;
            }
            stack[length++] = item;
        }
        public void size()
        {
            for (int i = 0; i < stack.Length; i++)
            {
                Console.WriteLine("输出   " + stack[i]);
            }
        }
    }

我们先实现压入栈顶的操作

 运行后：

说明我们代码没问题，继续写弹出栈顶的操作

public T pop()
        {
            T temp1 = default;
            if (length != 0)
            {
                T[] temp = new T[length - 1];
                temp1 = stack[length - 1];
                Array.Copy(stack, 0, temp, 0, length - 1);
                stack = temp;
                length--;
            }
            return temp1;
        }

 调用一下：

 运行后：

压出栈顶元素的操作，我们也完成了 

栈的实现并不难，调用push，就把数组往后加一位或者*4位，把数组扩展，然后再拷贝临时的数组，这个就是栈的工作原理

2、list的简单实现

list和栈基本类似，这里只写Add和Remove，其他的也都简单

public class ListTest<T>
    {
        public T[] list { get; set; }
        public int Count { get; set; }
        public ListTest()
        {
            Count = 0;
            list = new T[0];
        }
        public T this[int item]
        {
            get
            {
                if (item<Count)
                {
                    return list[item];
                }
                return default;
            }
            set
            {
                list[item] = value;
            }
        }
        public void Add(T item)
        {
            if (list.Length == Count)
            {
                T[] temp = new T[Count + 1];
                Array.Copy(list, 0, temp, 0, Count);
                list = temp;
                list[Count++] = item;
            }
        }
        public bool Remove(int item)
        {
            int index = Array.IndexOf(list, item);
            if (index>0)
            {
                T[] temp = new T[list.Length-1];
                Array.Copy(list,0,temp,0, Count-1);
                list = temp;
            }
            Count--;
            return true;
        }
    }

list比栈多了个public T this[int item]，所以list可以通过下标访问元素，如果你想用下标访问栈的话，我不是很建议这样操作，因为栈用下标访问元素，那跟list没区别，为什么不直接用list，对吧

最后再给你们一个监测代码运行时间的方法：

System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
            watch.Start();  //开始监视代码运行时间
//需要监测的代码
 watch.Stop();  //停止监视
            TimeSpan timespan = watch.Elapsed;  //获取当前实例测量得出的总时间
            Console.WriteLine("打开窗口代码执行时间：{0}(毫秒) ", timespan.TotalMilliseconds); //总毫秒数

 

这样就能监测代码跑完用时多久，对性能优化或许有一点小小的帮助吧