用栈实现队列

　　最近补习了一些简单的算法，从头开始学习了数据结构。

　　有被人问到一个有意思的题目。就是提供一个有Count属性，Pop 和 Push 方法的Stack类，如何用它完成一个Queue的结构。

　　第一次写的时候并不够完美，后来修改成下面的代码并记录下来，希望有大侠能帮忙指出其中不足之处。

　　

　　欢迎大家前来讨论。

 

 

代码

using  System;


namespace  TestQueueWithStack
{
     public   class  TestStack < T >
    {
         private   int  _count;  // 栈的总容量

         private  T[] _data;  // 数组，用于存储栈中的数据元素

         private   int  point;  // 栈的指针

         // 栈的总容量
         public   int  Count
        {
             get  {  return  _count; }
        }
         // 已经装入的个数
         public   int  Length
        {
             get
            {
                 return  point  +   1 ;
            }
        }

         // 构造函数
         public  TestStack( int  count)
        {
            _data  =   new  T[count];
            _count  =  count;
            point  =   - 1 ;
        }

         // 入栈 Push
         public   void  Push(T item)
        {
             if  (point.Equals(_count  -   1 ))
            {
                Console.WriteLine( " Stack is full " );
                 return ;
            }
            _data[ ++ point]  =  item;
        }

         // 出栈
         public  T Pop()
        {
            T temp  =   default (T);
             if  (point.Equals( - 1 ))
            {
                Console.WriteLine( " Stack is empty " );
                 return  temp;  //  超出报错
            }
            temp  =  _data[point];
             -- point;
             return  temp;
        }
    }


     ///   <summary>
     ///  Queue
     ///   </summary>
     ///   <typeparam name="T"></typeparam>
     public   class  TestQueue < T >
    {
         private  TestStack < T >  _data;  // 主数组，用于存储栈中的数据元素

         private  TestStack < T >  _aideData;  // 辅助数组，用于暂时存储栈中的数据

         public   int  Length
        {
             get
            {
                 return  _data.Length + _aideData.Length;
            }
        }
         // 构造函数
         public  TestQueue( int  count)
        {
            _data  =   new  TestStack < T > (count);
            _aideData  =   new  TestStack < T > (count);
        }

         // 入队列 Push
         public   void  Push(T item)
        {
             if  (Length  <  _data.Count)
            {
                _data.Push(item);
            }
             else
            {
                Console.WriteLine( " Queue is full " );
            }
        }

         // 出队列 Pop
         public  T Pop()
        {            
             if  (_aideData.Length  ==   0 ) // 如果辅助存贮数据的Data为空
            {
                 if (_data.Length == 0 )
                {
                    T temp  =   default (T);
                    Console.WriteLine( " Queue is empty " );
                     return  temp;
                }
                 else
                {
                     while  (_data.Length  >   0 )
                    {
                        _aideData.Push(_data.Pop());
                    }
                     return  _aideData.Pop();
                }                
            }
             else
            {
                 return  _aideData.Pop();
            }
        }
    }
     class  Program
    {
         static   void  Main( string [] args)
        {
            
             /* ------------------ 为了说明 TestStack 的Push 和 Pop 方法 ----------------------- */
             // TestStack<int> stack = new TestStack<int>(10);

             // int i = 0;
             // while (i++ < 10)
             // {
             //     stack.Push(i);
             // }

             // while (stack.Length.CompareTo(0) > 0)
             // {
             //     Console.WriteLine(stack.Pop());
             // }

             // Console.Read();
             /* ------------------------------------- End ------------------------------------ */

            TestQueue < int >  queue  =   new  TestQueue < int > ( 10 );

            queue.Pop(); // 空

             int  i  =   0 ;
             while  (i ++   <   11 ) // 故意多放入一个
            {
                queue.Push(i);
            }

             // 只取出其中一个 理论为 1 2
            Console.WriteLine(queue.Pop());
            Console.WriteLine(queue.Pop());

             // 压入数字 11 12
            queue.Push( 11 );
            queue.Push( 12 );

             while  (queue.Length.CompareTo( 0 )  >   0 )
            {
                Console.WriteLine(queue.Pop());
            }

            Console.Read();
        }
    }
}

另外还有一个问题，想遗留在这，看看大家是否有完美的解决方案

从一个有N个数字的数组中取出 i个最大或最小的数字，唯一条件 N 远大于 i

 

转载于:https://www.cnblogs.com/Zane_Yao/archive/2009/12/24/BuildQueueClassWithStack.html