如何使用栈实现一个队列。

你所说的栈是说的数据结构里面那先进后出队列吗？
可以封装一个类，类内部定义一个数组（在构造函数中确定栈的最大空间），或者是可变长度的List对象，再就是封装两个方法了：出栈和入栈

1. class Stack<T>
   
2.     {
   
3.         private int point;
   
4.         private T[] arr;
   
5. 
   
6.         public Stack(int maxLength)
   
7.         {
   
8.             arr = new T[maxLength];
   
9.             point = -1;
   
10.         }
    
11. 
    
12.         //出栈
    
13.         public T Pop()
    
14.         {
    
15.             if (point < 0)//出栈判断下限
    
16.             {
    
17.                 throw new Exception("堆栈空，不能再做弹出操作！");
    
18.             }
    
19.             return arr[point--];
    
20.         }
    
21. 
    
22.         //入栈
    
23.         public bool Push(T node)
    
24.         {
    
25.             if (point >= arr.Length)//入栈判断上限
    
26.             {
    
27.                 return false;
    
28.             }
    
29. 
    
30.             int PreLength = point;
    
31.             arr[++point] = node;
    
32.             if (point - PreLength == 1)
    
33.             {
    
34.                 return true;
    
35.             }
    
36.             else
    
37.             {
    
38.                 return false;
    
39.             }
    
40.         }
    
41. 
    
42.         //取栈顶元素
    
43.         public T Top()
    
44.         {
    
45.             if (point < 0)//出栈判断下限
    
46.             {
    
47.                 throw new Exception("堆栈空，不能读栈顶！");
    
48.             }
    
49.             return arr[point];
    
50.         }
    
51. 
    
52.         //元素总数
    
53.         public int Count
    
54.         {
    
55.             get{return point+1;}
    
56.         }
    
57.     }

复制代码

这是我刚才写的，不知道是不是你想要的...

有个思路你看看，是否对你有用吧

1，使用两个栈a b ，假定a是负责push操作，使用一个变量back_elem来存储最后的元素。2，实现队列的push操作，每次添加操作，都有相应的对栈a进行添加元素，并且对back_elem赋值，实现队列pop操作，每次进行删除操作因为b负责pop操作：首先判断栈a是否为空？如果b为空，则判断a是否为空？ 如果a也为空， 则输出错误信息，此时队列为空。如果a不为空， 则将栈a中的所有数据存储到b中。执行b.push(a.top()),   b.pop().     然后在对栈b执行，b.pop()操作，将队列的头元素删除如果b不为空， 则直接对b执行 b.pop()操作。（4）实现队列的front()操作，方法如pop操作相同，只是在最后一步使用b.top()返回值。（5）实现队列的back()操作，因为我们变量back_elem保存着最后一个输入的数据，故直接将其返回。（6）实现队列的size（）操作，和empty()操作，就是对a b分别执行操作。

                  

/// <summary>
    /// 栈实现队列
    /// </summary>
    class StackAndQueue
    {
        #region ==== 私有字段 ====

        private Stack stack = new Stack();

        private Stack queue = new Stack();

        #endregion

        #region ==== 构造函数 ====

        public StackAndQueue()
        {
            
        }

        #endregion

        #region ==== 公共方法 ====

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="context"></param>
        public void Push(string context)
        {
            if (!string.IsNullOrEmpty(context))
            {
                stack.Push(context);
            }
        }

        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns></returns>
        public string Pop()
        {
            if (stack.Count!=0)
            {
                queue.Clear();

                foreach (var item in stack)
                {
                    queue.Push(item);
                }

                stack.Clear();
            }

            if (queue.Count!=0)
            {
                return queue.Pop() as string;
            }

            return string.Empty;
        }

        #endregion
    }