コード例 #1
0
ファイル: StackAlgorithm.cs プロジェクト: blacop/DSCSR
        } //【例3-1】数制转换问题 //8进制转换//public void Conversion(int n)

        /* 【例3-2】括号匹配。
         * 括号匹配问题也是计算机程序设计中常见的问题。
         * 为简化问题,假设表达式中只允许有两种括号:圆括号和方括号。
         * 嵌套的顺序是任意的,([]())或[()[()][]]等都为正确的格式,
         * 而[(])或(([)])等都是不正确的格式。检验括号匹配的方法要用到栈。
         *
         * 算法思想:如果括号序列不为空,重复步骤1。
         * 步骤1:从括号序列中取出1个括号,分为三种情况:
         * a) 如果栈为空,则将括号入栈;
         * b) 如果括号与栈顶的括号匹配,则将栈顶括号出栈。
         * c) 如果括号与栈顶的括号不匹配,则将括号入栈。
         * 步骤2:如果括号序列为空并且栈为空则括号匹配,否则不匹配。
         * 算法如下,用顺序栈实现算法:
         */
        public bool MatchBracket(char[] charlist)   //匹配括号
        {
            SeqStack <char> s   = new SeqStack <char>(50);
            int             len = charlist.Length;

            #region                       //开始循环,循环完毕
            for (int i = 0; i < len; ++i) //开始循环
            {
                if (s.IsEmpty())          //空栈
                {
                    s.Push(charlist[i]);  //入栈
                }//if (s.IsEmpty())
                else if ((((s.GetTop() == '(') && (charlist[i] == ')'))) || (((s.GetTop() == '[') && (charlist[i] == ']'))))
                {
                    //成功匹配
                    s.Pop();//出栈
                }//else if
                else
                {
                    //不匹配
                    s.Push(charlist[i]);//入栈
                }//else
            }//for (int i = 0; i < len; ++i)
            #endregion
            if (s.IsEmpty())
            {
                //空栈
                return(true);
            }//(s.IsEmpty())
            else
            {
                //非空栈
                return(false);
            } //else
        }     //匹配括号//public bool MatchBracket(char[] charlist)
コード例 #2
0
 static void Main(string[] args)
 {
     IStack<string> stack = new SeqStack<string>(500);
     stack.Push("a1");
     stack.Push("a2");
     stack.Push("a3");
     while (stack.IsEmpty() == false)
     {
         Console.WriteLine(stack.StackTop);
         stack.Pop();
     }
 }
コード例 #3
0
        public void Plalindrome()
        {
            SeqStack <char>  s = new SeqStack <char>(50);
            CSeqQueue <char> q = new CSeqQueue <char>(50);

            Console.WriteLine("请输入回文:");
            string str = Console.ReadLine();

            // string str = "ABCDEDCBA";
            for (int i = 0; i < str.Length; ++i)
            {
                s.Push(str[i]);
                q.In(str[i]);
            }

            while (!s.IsEmpty() && !q.IsEmpty())
            {
                if (s.Pop() != q.Out())
                {
                    break;
                }
            }

            if (!s.IsEmpty() || !q.IsEmpty())
            {
                Console.WriteLine("这不是回文!");
            }
            else
            {
                Console.WriteLine("这是回文!");
            }
        }
コード例 #4
0
ファイル: QueueAlgorithm.cs プロジェクト: blacop/DSCSR
        /*
         * 【例3-4】编程判断一个字符串是否是回文。
         * 回文是指一个字符序列以中间字符为基准两边字符完全相同,
         * 如字符序列"ACBDEDBCA"是回文。
         * 算法思想:判断一个字符序列是否是回文,就是把第一个字符与最后一个字符相比较,
         * 第二个字符与倒数第二个字符比较,依次类推,第i个字符与第n-i个字符比较。
         * 如果每次比较都相等,则为回文,如果某次比较不相等,就不是回文。
         * 因此,可以把字符序列分别入队列和栈,
         * 然后逐个出队列和出栈并比较出队列的字符和出栈的字符是否相等,
         * 若全部相等则该字符序列就是回文,否则就不是回文。
         */
        public static void palindrome()
        {
            SeqStack <char> s   = new SeqStack <char>(50);
            SeqQueue <char> q   = new SeqQueue <char>(50);
            string          str = Console.ReadLine(); //手动输入字符串

            for (int i = 0; i < str.Length; ++i)      //循环入
            {
                s.Push(str[i]);
                q.In(str[i]);
            }
            while (!s.IsEmpty() && !q.IsEmpty())//循环出
            {
                if (s.Pop() != q.Out())
                {
                    break;
                }
            }
            if (!s.IsEmpty() || !q.IsEmpty())//非空
            {
                Console.WriteLine("这不是回文!");
            }
            else  //空
            {
                Console.WriteLine("这是回文!");
            }
        } //public static void Main()
コード例 #5
0
ファイル: StackAlgorithm.cs プロジェクト: blacop/DSCSR
        }     //匹配括号//public bool MatchBracket(char[] charlist)

        /*【例3-3】表达式求值
         * 为实现算法,使用两个栈,一个存放算符,叫OPTR,
         * 一个存放操作数和运算的结果数,叫OPND。算法思想如下:
         * (1) 首先置OPND为空,将‘#’入OPTR;
         * (2) 依次读入表达式中的每个字符,若是操作数则将该字符入OPND,
         * 若是算符,则和OPTR栈顶字符比较优先级,若OPTR栈顶字符优先级高,
         * 则将OPND栈中的两个操作数和OPTR栈顶算符出栈,
         * 然后将操作结果入OPND;若OPTR栈顶字符优先级低,
         * 则将该字符入OPTR;
         * 若二者优先级相等,则将OPTR栈顶字符出栈并读入下一个字符。
         */
        public int EvaluateExpression()                     //表达式求值 //算符和操作数都从外部传入,读入之前的分离前置后置操作都没写
        {
            SeqStack <char> optr = new SeqStack <char>(20); //存放算符,叫OPTR
            SeqStack <int>  opnd = new SeqStack <int>(20);  //存放操作数和运算的结果数,叫OPND

            optr.Push('#');                                 //首发入栈#
            char c     = (char)Console.Read();              //读入算符,简化写法,手动输入算符1次
            char theta = (char)0;                           //表达式的算符
            int  a     = 0;                                 //操作数
            int  b     = 0;                                 //操作数

            while (c != '#')                                //循环终止条件:不是结束符#
            {
                #region                                     //是算符
                if ((c != '+') && (c != '-') && (c != '*') && (c != '/') && (c != '(') && (c != ')'))
                {
                    //是算符
                    optr.Push(c);//入栈
                }
                #endregion
                #region//不是算符
                else//不是算符
                {
                    switch (Precede(optr.GetTop(), c))//
                    {
                    case '<':
                        optr.Push(c);             //入栈1个算符
                        c = (char)Console.Read(); //手动输入算符1次
                        break;

                    case '=':
                        optr.Pop();               //出栈1个算符
                        c = (char)Console.Read(); //手动输入算符1次
                        break;

                    case '>':
                        theta = optr.Pop();              //出栈1个算符
                        a     = opnd.Pop();              //出栈2个操作数
                        b     = opnd.Pop();
                        opnd.Push(Operate(a, theta, b)); //入栈1个结果数(调用Operate()))
                        break;
                    }//switch (Precede(optr.GetTop(), c))
                } //else
                #endregion
            }     //while (c != '#')
            return(opnd.GetTop());//拿到栈顶结果数
        }         //表达式求值//public int EvaluateExpression()
コード例 #6
0
        protected SeqStack <T> GenericStackFactory(int count)
        {
            var stack = new SeqStack <T>(count);
            var seed  = count * 34;

            for (var i = 0; i < count; i++)
            {
                stack.Push(CreateT(seed++));
            }
            return(stack);
        }
コード例 #7
0
    void Start()
    {
        SeqStack <int> seqStack = new SeqStack <int>();

        for (int i = 0; i < 3; i++)
        {
            seqStack.Push(i);
        }
        print("展示栈顶元素:" + seqStack.Peek());
        print("栈数量:" + seqStack.GetLength());
        for (int i = 0; i < 3; i++)
        {
            print(seqStack.Pop());
        }
    }
コード例 #8
0
        static void Main(string[] args)
        {
            #region 顺序循环队列
            //CSeqQueue<int> queue1=new CSeqQueue<int>(5);
            //queue1.In(1);
            //queue1.In(2);
            //queue1.In(3);

            //queue1.Out();
            //queue1.Out();
            //queue1.Out();

            //queue1.In(0);
            //queue1.In(1);
            //queue1.In(2);

            //queue1.Out();
            //queue1.Out();
            //queue1.Out();

            //queue1.In(3);
            //queue1.In(1);
            //queue1.In(2);

            //Console.WriteLine("头元素:"+queue1.GetFront());
            //Console.WriteLine("队头:"+queue1.Front);
            //Console.WriteLine("队尾:"+queue1.Rear);
            //Console.WriteLine("队列长度:"+queue1.GetLength());

            //Console.ReadKey();
            #endregion

            #region 链队列

            SeqStack <char>  s = new SeqStack <char>(50);
            CSeqQueue <char> q = new CSeqQueue <char>(50);
            Console.WriteLine("请输入字符串用于判断您输入的字符串是否是回文字符!(按回车键结束)");
            string str = Console.ReadLine();

            for (int i = 0; i < str.Length; i++)
            {
                s.Push(str[i]);
                q.In(str[i]);
            }

            while (!s.IsEmpty() && !q.IsEmpty())
            {
                if (s.Pop() != q.Out())
                {
                    break;
                }
            }

            if (!s.IsEmpty() || !q.IsEmpty())
            {
                Console.WriteLine("这不是回文!");
            }
            else
            {
                Console.WriteLine("这是回文!");
            }

            Console.ReadKey();


            #endregion
        }