C#数据结构-栈

栈的定义不需要多说，相信大家都非常熟悉，但是，在实际应用中栈的应用我们很少想到会去用栈结构，先上代码看下用法：

　Stack st = new Stack();
  st.Push('A');
  st.Push(BCD);
  foreach (char c in st)
  {
      Console.Write(c + " ");
  }
  Console.WriteLine();
  st.Push(E);
  }
  Console.WriteLine();
  st.Pop();
  st.Pop();
  st.Pop();
  );
  }
  Console.ReadLine();

 

 

 现在我们自己实现一个栈结构：

 

　　/// <summary>
    /// 栈
    /// </summary>
    public class MyStack
    {
        <summary>
         栈的实现还是使用数组的方式存储
        </summary>
        public Object[] content { get; set; }
         栈深度
        int size {  默认开始深度
        int defaultSize { set; } = 10;
         初始化 默认深度
        public MyStack()
        {
            content = new object[defaultSize];
            size = 0;
        }
         压栈
        </summary>
        <param name="obj"></param>
        virtual void Push(Object obj)
        {
            //如果数组满了，则扩容（翻倍扩容）
            if (size == content.Length)
            {
                扩容次数为2的指数级
                Object[] newArray = new Object[2 * content.Length];
                将原内容拷贝到新的数组中 （扩容次数 2的指数级扩容，减少拷贝带来的时间消耗）
                Array.copy(content,0,newArray,1)">,size);
                content = newArray;
            }
            写入数组
            content[size++] = obj;
        }
         取下一个出栈值，但不删除 （偷看下~）
        <returns></returns>
        virtual Object Peek()
        {
            if (size == )
                throw new InvalidOperationException("空栈);
            return content[size - 1];
        }
         出栈
         Object Pop()
        {
            );
            Object obj = content[--size];
            content[size] = null;
            return obj;
        }
        实现该方法是为了 暂不实现 ICollection -
         ShowAll()
        {

            for (int i=size-1;i>=0;i--)
            {
                Console.Write($ {content[i]});
            }
            Console.WriteLine();
        }
    }
     异步栈
     MySyncStack : MyStack
    {
        private MyStack myStack;

         Object lookObj;

        override  Push(Object value)
        {
            lock (lookObj)
            {
                myStack.Push(value);
            }
        }

        override (lookObj)
            {
                 myStack.Pop();
            }
        }

         myStack.Peek();
            }
        }
    }

可以看出，其实栈还是用数组结构来实现的，异步栈在栈的基础上增加了锁。

 

测试下：

MyStack st =  MyStack();
st.Push();
st.Push();
st.ShowAll();
st.Push();
st.ShowAll();
st.Pop();
st.Pop();
st.Pop();
st.ShowAll();
Console.ReadLine();