1 #include "doublestack.h"
  2 #include <iostream>
  3 #include <cstdlib>
  4 DoubleStack NewDoubleStack(int max_size)
  5 {
  6     DoubleStack dstk;
  7 
  8     dstk.a = new int[max_size];
  9     dstk.N = max_size;
 10     dstk.top_left = -1;
 11     dstk.top_right = dstk.N;
 12 
 13     return dstk;
 14 }
 15 
 16 void PushLeft(DoubleStack& dstk, int val)
 17 {
 18     // For you to do.
 19 // std::cout << "current left stack " << dstk.top_left << std::endl;
 20    if (dstk.top_left == (dstk.N - 1) ){
 21       std::cerr << "Overflow Error: " << __LINE__ << std::endl;
 22       return;
 23    }
 24    dstk.top_left++;
 25    dstk.a[dstk.top_left] = val;
 26    return;
 27 }
 28 
 29 void PushRight(DoubleStack& dstk, int val)
 30 {
 31     // For you to do.
 32 // std::cout << "current right stack " << dstk.top_right << std::endl;
 33    if (dstk.top_right <= 0){
 34       std::cerr << "Overflow Error " << __LINE__ << std::endl;
 35       return;
 36    }
 37    dstk.top_right--;
 38    dstk.a[dstk.top_right] = val;
 39    return;
 40 }
 41 
 42 int PopLeft(DoubleStack& dstk)
 43 {
 44     // For you to do.
 45     int ret;
 46     if(dstk.top_left == -1){
 47        std::cerr << "Emtpy Array, can not pop" << std::endl;
 48        exit (EXIT_FAILURE);
 49     }
 50     ret = dstk.a[dstk.top_left--];
 51     return ret;
 52 }
 53 
 54 
 55 
 56 int PopRight(DoubleStack& dstk)
 57 {
 58     // For you to do.
 59        int ret;
 60        if(dstk.top_right >= dstk.N ){
 61        std::cerr << "Emtpy Array, can not pop" << std::endl;
 62        exit (EXIT_FAILURE);
 63     }
 64     ret = dstk.a[dstk.top_right++];
 65     return ret;
 66 
 67 }
 68 
 69 int TopLeft(DoubleStack& dstk)
 70 {
 71     // For you to do
 72 
 73     if(dstk.top_left <= -1){
 74        std::cerr << "Emtpy Array, can not peep" << std::endl;
 75        exit (EXIT_FAILURE);
 76     }
 77 
 78     return dstk.a[dstk.top_left];
 79 }
 80 
 81 int TopRight(DoubleStack& dstk)
 82 {
 83     // For you to do
 84     if(dstk.top_right >= dstk.N){
 85        std::cerr << "Emtpy Array, can not peep" << std::endl;
 86        exit (EXIT_FAILURE);
 87     }
 88 
 89     return dstk.a[dstk.top_right];
 90 }
 91 
 92 bool IsLeftEmpty(DoubleStack& dstk)
 93 {
 94    // For you to do.
 95    // std::cout << "What is up ==> " << dstk.top_left << std::endl;
 96    if(dstk.top_left <= -1){
 97       return true;
 98    }else{
 99       return false;
100    }
101 }
102 
103 bool IsRightEmpty(DoubleStack& dstk)
104 {
105     // For you to do.
106     if(dstk.top_right >= dstk.N){
107        return true;
108     }else{
109        return false;
110     }
111 
112 }
113 
114 bool IsFull(DoubleStack& dstk)
115 {
116     // For you to do.
117     if (dstk.top_left == (dstk.top_right + 1) ){
118        return true;
119     }else{
120        return false;
121     }
122 }
123 
124 void printleft(DoubleStack& dstk)
125 {
126    int i = 0;
127    if( IsLeftEmpty(dstk) ){
128       std::cout << "Left Stack Empty " << std::endl;
129       return;
130    }
131 
132    for(i = 0; i <=  dstk.top_left; i++){
133       std::cout << dstk.a[i] << " ";
134    }
135    std::cout << std::endl;
136    return;
137 }
138 
139 
140 void printright(DoubleStack& dstk)
141 {
142    int i = 0;
143    if( IsRightEmpty(dstk) ){
144       std::cout << "Right Stack Empty " << std::endl;
145       return;
146    }
147 // std::cout << "where is the start? ==> " << dstk.N << std::endl;
148 // std::cout << "where is the top ? ==> " << dstk.top_right << std::endl;
149    for(i = (dstk.N - 1); i >=  dstk.top_right; i--){
150       std::cout << dstk.a[i]  << " ";
151    }
152    std::cout << std::endl;
153    return;
154 }

 1 #ifndef DOUBLESTACK_H_INCLUDED
 2 #define DOUBLESTACK_H_INCLUDED
 3 
 4 struct DoubleStack {
 5     int *a;
 6     int top_left;
 7     int top_right;
 8     int N;
 9 };
10 
11 DoubleStack NewDoubleStack(int max_size);
12 void PushLeft(DoubleStack& dstk, int val);
13 void PushRight(DoubleStack& dstk, int val);
14 int PopLeft(DoubleStack& dstk);
15 int PopRight(DoubleStack& dstk);
16 int TopLeft(DoubleStack& dstk);
17 int TopRight(DoubleStack& dstk);
18 bool IsLeftEmpty(DoubleStack& dstk);
19 bool IsRightEmpty(DoubleStack& dstk);
20 bool IsFull(DoubleStack& dstk);
21 void printleft(DoubleStack& dstk);
22 void printright(DoubleStack& dstk);
23 #endif // DOUBLESTACK_H_INCLUDED^M

 1 #include <iostream>
 2 #include <cstdlib>
 3 #include "doublestack.h"
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     int buff;
 9     DoubleStack stack = NewDoubleStack(20);
10     printleft(stack);
11 
12     // Write code to test your double stack:
13     // Ask user to enter integers. Push them onto the left stack, until user enters CTL-D.
14     std::cout << "Enter Integers ==> Press CTL D to stop" << endl;
15     while(std::cin >>  buff){
16        if(! IsFull(stack) ){
17           PushLeft(stack, buff);
18        }else{
19           std::cout << "We are FULL" << std::endl;
20        }
21     }
22 
23     printleft(stack);
24 
25     // Then: As long as left stack is not empty, push top of left stack onto the right stack,
26     // and pop left stack.
27     while(! IsLeftEmpty(stack) ){
28        buff = PopLeft(stack);
29       PushRight(stack, buff);
30     }
31     std::cout << "Right Stack ==> ";
32     printright(stack);
33     std::cout << endl << "Left Stack ==> ";
34     printleft(stack);
35     std::cout << std::endl << "done" <<  std::endl;
36 
37     // Then: As long as right stack is not empty, write top of right stack to cout, and pop
38     // right stack.
39 
40 
41     while( ! IsRightEmpty(stack) ) {
42        std::cout << "***POP*** " << PopRight(stack) << " ***POP***" << std::endl;
43     }
44 
45 
46 
47 
48 
49 
50 
51     return EXIT_SUCCESS;
52 }