【Weiss】【第03章】练习3.21：单数组模拟双栈

【练习3.21】

编写仅用一个数组而实现两个栈的例程。除非数组的每一个单元都被使用，否则栈例程不能有溢出声明。

Answer:

很简单，一个栈从数组头起，一个栈从数组尾起，分别保留左右栈头索引。

如left=5则表示array[0]~array[4]为左栈元素，right=7则表示array[8]~array[size-1]为右栈元素。

当左右索引交叉时(left=right+1)，0~left-1为左栈，left~size-1为右栈，刚好用完每一个单元。

测试代码：

 #include <iostream>
 #include "stack.h"
 using namespace std;
 using namespace stack;
 template class Stack<int>;
 int main(void)
 {
     Simu_Double_Stack<int> test();
     //测试插入
     test.leftpush();
     test.leftpush();
     test.leftpush();
     test.leftpush();
     test.leftpush();
     test.rightpush();
     test.rightpush();
     test.rightpush();
     test.rightpush();
     test.rightpush();
     test.rightpush();
     //测试打印
     test.leftprint();
     test.rightprint();
     cout << endl;
     //测试拷贝
     Simu_Double_Stack<int> test2;
     test2 = test;
     test2.leftprint();
     test2.rightprint();
     cout << endl;
     //证明拷贝为深拷贝
     test.leftpush();
     test2.leftprint();
     cout << endl;
     test.leftprint();
     cout << endl;
     //测试栈满报错
     test.leftpush();
     test.rightpush();
     //测试出栈
     test.leftpop();
     test.leftpop();
     test.rightpop();
     test.rightpop();
     test.leftprint();
     test.rightprint();
     //测试栈元素清空
     test.leftclear();
     test.rightclear();
     test.leftprint();
     test.rightprint();

     system("pause");
 }

实现代码：

 //练习3.21新增，单数组模拟双栈
 template <typename T> class Simu_Double_Stack
 {
 public:
     Simu_Double_Stack() :head(nullptr), left(), right(), size(){}
     Simu_Double_Stack(unsigned int _size)
     {
         head = new T[_size];
         size = _size;
         left = ;
         right = _size - ;
     }
     Simu_Double_Stack(const Simu_Double_Stack& another)
     {
         size = another.size;
         head = new T[size];
         left = another.left;
         right = another.right;
         for (int i = ; i < size; ++i)
             head[i] = another.head[i];
     }
     ~Simu_Double_Stack(){ destory(); }
     Simu_Double_Stack& operator=(const Simu_Double_Stack& another)
     {
         if (&another != this)
         {
             destory();
             size = another.size;
             left = another.left;
             right = another.right;
             head = new T[size];
             for (unsigned int i = ; i < size; ++i)
                 head[i] = another.head[i];
         }
         return *this;
     }
 public:
     //入栈
     bool leftpush(const T& item)
     {
         if (left <= right)
         {
             head[left++] = item;
             return true;
         }
         else
         {
             cout << "Overflow" << endl;
             return false;
         }
     }
     bool rightpush(const T& item)
     {
         if (right >= left)
         {
             head[right--] = item;
             return true;
         }
         else
         {
             cout << "Overflow" << endl;
             return false;
         }

     }
     //出栈
     bool leftpop()
     {
         if (left > )
         {
             --left;
             return true;
         }
         else
         {
             cout << "Stack empty" << endl;
             return false;
         }
     }
     bool rightpop()
     {
         if (right < size - )
         {
             ++right;
             return true;
         }
         else
         {
             cout << "Stack empty" << endl;
             return false;
         }
     }
     //获取长度信息
     unsigned int leftsize()const{ return left; }
     unsigned int rightsize()const{ return size - right - ; }
     unsigned int getsize()const{ return size; }
     unsigned int getused()const{ return left + size - right - ; }
     //打印
     void leftprint() const
     {
         for (unsigned int i = left - ; i != -; --i)
             cout << " " << head[i] << flush;
     }
     void rightprint() const
     {
         for (unsigned int i = right + ; i != size; ++i)
             cout << " " << head[i] << flush;
     }
     //清空
     void leftclear(){ left = ; }
     void rightclear(){ right = size - ; }
 private:
     //释放内存
     void destory()
     {
         left = right = size = ;
         delete[] head;
         head = nullptr;
     }
     T* head = nullptr;
     unsigned int left;
     unsigned int right;
     unsigned int size;
 };