3、栈

1、栈的定义

   栈也叫堆栈，是一种限制只能在某一端进行插入和删除操作的线性表。

 

  栈的基本操作：

 

  进栈、出栈、查询、是否为空、长度。

2、顺序栈

2.1. 定义

       栈的顺序存储结构简称顺序栈。

   他是利用一组地址连续的储存单元存放自栈底到栈顶的数据元素，同时附设一个指针(Top)指示当前栈的位置。

2.2. 特点

1、数据元素存放在连续的存储地址中

2、栈底位置固定不变

3、栈顶位置随进栈、出栈操作而变化

2.3. 示例

ILinearList接口 详见 https://www.cnblogs.com/schangxiang/p/11434885.html  

 /// <summary>
    /// 栈接口
    /// </summary>
    interface IStack
    {
        void Push(object item);
        /// <summary>
        /// 清除栈顶，返回原栈顶元素
        /// </summary>
        /// <returns></returns>
        object Pop();
        /// <summary>
        /// 获取栈顶元素
        /// </summary>
        /// <returns></returns>
        object Peek();
        bool IsEmpty();
        int Size();
    }

 /// <summary>
    /// 顺序栈
    /// </summary>
    class SequenceStack : IStack
    {
        ILinearList stackList = null;

        public SequenceStack()
        {
            stackList = new SequenceList(100);
        }
        bool IStack.IsEmpty()
        {
            return stackList.IsEmpty();
        }

        object IStack.Peek()
        {
            CheckNull();
            return stackList.Get(stackList.Size() - 1);
        }

        object IStack.Pop()
        {
            CheckNull();
            return stackList.Remove(stackList.Size() - 1);
        }

        void IStack.Push(object item)
        {
            stackList.Add(stackList.Size(), item);
        }

        int IStack.Size()
        {
            return stackList.Size();
        }

        private void CheckNull()
        {
            IStack istack = this;
            if (istack.IsEmpty())
            {
                throw new Exception("队列为NULL");
            }
        }
    }

  IStack stack = new SequenceStack();

            stack.Push(100);
            stack.Push(200);
            stack.Push(300);
            stack.Push(400);

            while (!stack.IsEmpty())
            {
                Console.WriteLine(stack.Pop());//挨个出栈，并显示栈顶的元素
            }

2.4. 示例-判断符号是否匹配

  /// <summary>
        /// 判断符号是否匹配
        /// 即[] {} ()是否成对出现
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private static bool IsSymmetry(string args)
        {
            /*
             * 算法原理：出现左侧符号 [{( 就压入栈，出现右侧符号 ]}) 就出栈，并匹配出栈的元素是否是一对即可
             */
            IStack stack = new SequenceStack();
            for (int i = 0; i < args.Length; i++)
            {
                char a = args[i];
                switch (a)
                {
                    case '(':
                    case '[':
                    case '{':
                        stack.Push(a.ToString());//入栈
                        break;
                    case ')':
                        if (stack.Size() > 0)
                        {
                            //出栈
                            Console.WriteLine(a.ToString()+"配过成功:" + stack.Pop().Equals('('));
                        }
                        break;
                    case ']':
                        if (stack.Size() > 0)
                        {
                            //出栈
                            Console.WriteLine(a.ToString() + "配过成功:" + stack.Pop().Equals('['));
                        }
                        break;
                    case '}':
                        if (stack.Size() > 0)
                        {
                            //出栈
                            Console.WriteLine(a.ToString() + "配过成功:" + stack.Pop().Equals('{'));
                        }
                        break;
                }
            }
            return stack.Size() == 0;//最后如果栈为空，代表全部匹配，反之不匹配
        }

   //判断符号是否匹配
            //string aa = "{驴啊[(我是猪)]羊呢}";//成功匹配
            string aa = "{驴啊[(我是猪]羊呢}";//不成功匹配
            bool isOk = IsSymmetry(aa);
            Console.WriteLine(isOk?"符号对全部匹配": "符号对不匹配");
            Console.ReadKey();