zoukankan html css js c++ java

数据结构实验3：C++实现顺序栈类与链栈类

实验3
3.1 实验目的

熟练掌握栈的顺序存储结构和链式存储结构。

熟练掌握栈的有关算法设计，并在顺序栈和链栈上实现。

根据具体给定的需求，合理设计并实现相关结构和算法。
3.2实验要求
3.2.1 顺序栈的实验要求

顺序栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；

实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；

程序有适当的注释。
3.2.2 链栈实验要求

本次实验中的链栈结构指带头结点的单链表；

链栈结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；

实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；

程序有适当的注释。
3.3 实验任务
3.3.1 顺序栈实验任务

设计并实现一个顺序栈，编写算法实现下列问题的求解。

<1>利用顺序栈实现将10进制数转换为16进制数。

第一组数据：4 / 4

第二组数据：11 / B

第三组数据：254 / FE

第四组数据：1357 / 54D

<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
3.3.2 链栈实验任务

以带头结点的单链表表示链栈，编写算法实现下列问题的求解。

<1>利用顺序栈实现将10进制数转换为16进制数。

第一组数据：4

第二组数据：11

第三组数据：254

第四组数据：1357

<2>对一个合法的数学表达式来说，其中的各大小括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。设计算法对以字符串形式读入的表达式S，判断其中的各括号是否是匹配的。
3.4 选做题

非必做内容，有兴趣的同学选做。自行选择栈的存储结构。

<1>假设栈的输入序列为1、2、3、...、n，设计算法实现对给定的一个序列，判定其是否是此栈合法的输出序列。

<2>假设栈的输入序列为1、2、3、...、n，设计算法求出所有可能的出栈序列。

<3>利用栈求解算术表达式的值。
3.5 运行结果截图及说明

图1 顺序栈实现十进制转十六进制

图2 顺序栈解决表达式括号匹配问题（局部）

图3 顺序栈解决表达式括号匹配问题（局部）

图4 顺序栈解决表达式括号匹配问题（局部）

图5 顺序栈解决表达式括号匹配问题（局部）

图6 链栈实现十进制转十六进制

图7 链栈解决表达式括号匹配问题（局部）

图8 链栈解决表达式括号匹配问题（局部）

图9 链栈解决表达式括号匹配问题（局部）

图10 链栈解决表达式括号匹配问题（局部）

图11 链栈判断1、2、3、4排列中合法出栈序列的问题

图12 链栈解决输出1、2、3、4、5、6、7全排列中合法出栈序列的问题（放大可清晰观看）

图13 链栈中缀表达式求值问题

3.6 附源代码

顺序栈代码：

 1 // stdafx.h : include file for standard system include files,
 2 //  or project specific include files that are used frequently, but
 3 //      are changed infrequently
 4 //
 5 
 6 #if !defined(AFX_STDAFX_H__F1CE48FC_1D41_45D9_B60D_6D065D91DB10__INCLUDED_)
 7 #define AFX_STDAFX_H__F1CE48FC_1D41_45D9_B60D_6D065D91DB10__INCLUDED_
 8 
 9 #if _MSC_VER > 1000
10 #pragma once
11 #endif // _MSC_VER > 1000
12 
13 #include <stdc++.h>
14 
15 using namespace std;
16 
17 //typedef int elementType;
18 typedef double elementType;
19 typedef char elementType1;
20 const int maxLength = 1000 + 3;
21 
22 // TODO: reference additional headers your program requires here
23 
24 //{{AFX_INSERT_LOCATION}}
25 // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
26 
27 #endif // !defined(AFX_STDAFX_H__F1CE48FC_1D41_45D9_B60D_6D065D91DB10__INCLUDED_)

 1 // SeqStack1.h: interface for the SeqStack class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX_SEQSTACK1_H__55EE245C_A5F8_47D4_9510_B3BA6C85FF63__INCLUDED_)
 6 #define AFX_SEQSTACK1_H__55EE245C_A5F8_47D4_9510_B3BA6C85FF63__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 #include "charSeqStack.h"
13 
14 //using elementType = double;
15 typedef double elementType;
16 class SeqStack  
17 {
18 public:
19     SeqStack();
20     virtual ~SeqStack();
21     bool stackEmpty();
22     bool stackFull();
23     bool getTop( elementType& value );
24     bool push( elementType value );
25     bool pop();
26     int length();
27     void displayStack();
28     int isp( elementType1 _operator );//栈内优先级
29     int icp( elementType1 _operator );//栈外优先级
30     charSeqStack css;
31     double doOperator( elementType value1, elementType value2, elementType1 _operator );
32     void calculate( charSeqStack& css1, charSeqStack& css2 );
33     friend ostream &operator<< (ostream &os, const SeqStack &a)
34     {
35         for (int i = 0; i < a.top + 1; i++)
36         {
37             if (a.top == -1)
38                 return os;
39             os << a.data[i];
40         }
41 
42         return os;
43     }
44 
45 private:
46     elementType data[maxLength];
47     int top;
48 };
49 
50 #endif // !defined(AFX_SEQSTACK1_H__55EE245C_A5F8_47D4_9510_B3BA6C85FF63__INCLUDED_)

  1 // SeqStack1.cpp: implementation of the SeqStack class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "SeqStack1.h"
  7 #include <iostream>
  8 #include <iomanip>
  9 
 10 //////////////////////////////////////////////////////////////////////
 11 // Construction/Destruction
 12 //////////////////////////////////////////////////////////////////////
 13 using namespace std;
 14 SeqStack::SeqStack()
 15 {
 16     top = -1;
 17 }
 18 
 19 SeqStack::~SeqStack()
 20 {    
 21 }
 22 
 23 bool SeqStack::stackEmpty()
 24 {
 25     return top == -1;
 26 }
 27 
 28 bool SeqStack::stackFull()
 29 {
 30     return top == maxLength - 1;
 31 }
 32 
 33 bool SeqStack::getTop( elementType& value )
 34 {
 35     if( stackEmpty() )
 36     {
 37         cout << "???ив????????ив" << endl;
 38         return false;
 39     }
 40     value = data[top];
 41     return true;
 42 }
 43 
 44 bool SeqStack::push( elementType value )
 45 {
 46     if( stackFull() )
 47     {
 48         cout << "?и▓ив????ив" << endl;
 49         return false;
 50     }
 51     top ++;
 52     data[top] = value;
 53     return true;
 54 }
 55 
 56 bool SeqStack::pop()
 57 {
 58     if( stackEmpty() )
 59     {
 60         cout << "??ив????ив" << endl;
 61         return false;
 62     }
 63     top --;
 64     return true;
 65 }
 66 
 67 int SeqStack::length()
 68 {
 69     if( stackEmpty() )
 70     {
 71         cout << "??ив" << endl;
 72         return -1;
 73     }
 74     return top + 1;
 75 }
 76 
 77 void SeqStack::displayStack()
 78 {
 79     if( stackEmpty() )
 80     {
 81         cout << "??ив????ив" << endl;
 82         return;
 83     }
 84     int column = 0;
 85     for( int i = 0; i <= top; i ++ )
 86     {
 87         cout << setw(6) << setiosflags( ios::left ) << data[i];
 88         column ++;
 89         if( column % 10 == 0 )
 90             cout << endl;
 91     }
 92 }
 93 
 94 int SeqStack::isp( char _operator )
 95 {
 96     switch(_operator)
 97     {
 98     case '#' :
 99         return 0;
100         break;
101     case '(':
102         return 6;
103         break;
104     case '*':
105         return 5;
106         break;
107     case '/':
108         return 5;
109         break;
110     case '+':
111         return 3;
112         break;
113     case '-':
114         return 3;
115         break;
116     case ')':
117         return 1;
118         break;
119     }
120 
121     cerr << "Error in SeqStack::isp" << endl;
122     return -1;
123 }
124 
125 int SeqStack::icp( char _operator )
126 {
127     switch(_operator)
128     {
129     case '#' :
130         return 0;
131         break;
132     case '(':
133         return 1;
134         break;
135     case '*':
136         return 4;
137         break;
138     case '/':
139         return 4;
140         break;
141     case '+':
142         return 2;
143         break;
144     case '-':
145         return 2;
146         break;
147     case ')':
148         return 6;
149         break;
150     }
151 
152     cerr << "Error in SeqStack::icp" << endl;
153     return -1;
154 }
155 
156 double SeqStack::doOperator( elementType value1, elementType value2, elementType1 _operator )
157 {
158     switch(_operator)
159     {
160     case '+':
161         return value1 + value2;
162         break;
163     case '-':
164         return value1 - value2;
165         break;
166     case '*':
167         return value1 * value2;
168         break;
169     case '/':
170         if( fabs(value2) < 0.0001 )
171         {
172             cout << "Divided by 0!" << endl;
173             return -1000000;
174         }
175         else
176             return value1 / value2;
177         break;
178     }
179 
180     cerr << "Error in SeqStack::doOperator" << endl;
181     return -1;
182 }
183 
184 void SeqStack::calculate( charSeqStack& css1, charSeqStack& css2 )//?????? css2 ?им????????? css1 ?
185 {
186     char ch, ch1;
187     int i = 0, j = 0;
188     double a, b;
189     css2.pop();
190     css2.getTop(ch);
191     css2.pop();
192     
193     // when the top of css2 is not '#' or the top of css is not empty.
194     while( css1.topValue() != -1 || ch != '#' )
195     {
196         // when the top of css2 is a number, put it into ss1
197         if( isdigit(ch) )
198         {
199             push( (int)( ch - '0' ) );
200             css2.getTop(ch);
201             css2.pop();
202         }
203 
204         // when the top of css2 is not a number,
205         else
206         {
207             css1.getTop(ch1);
208             if (ch1 == ')' && ch == '(')
209             {
210                 css1.pop();
211                 css2.getTop(ch);
212                 css2.pop();
213                 continue;
214             }
215             if( isp(ch1) < icp(ch) )
216             {
217                 css1.push(ch);
218                 css2.getTop(ch);
219                 css2.pop();
220             }
221             else if( isp(ch1) >= icp(ch) )
222             {
223                 getTop(a);
224                 pop();
225                 getTop(b);
226                 pop();
227                 push( doOperator( a, b, ch1 ) );
228                 css1.pop();
229             }            
230         }
231 
232     }
233      
234 }

 1 // charSeqStack.h: interface for the charSeqStack class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX_CHARSEQSTACK_H__A9958AD3_333A_41B4_B399_B6895C7AA8C5__INCLUDED_)
 6 #define AFX_CHARSEQSTACK_H__A9958AD3_333A_41B4_B399_B6895C7AA8C5__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 #include <iostream>
13 using namespace std;
14 //using elementType1 = char;
15 typedef char elementType1;
16 //const int maxLength = 1000;
17 
18 class charSeqStack  
19 {
20 public:
21     charSeqStack();
22     virtual ~charSeqStack();
23     bool stackEmpty();
24     bool stackFull();
25     bool getTop( elementType1& value );
26     bool push( elementType1 value );
27     bool pop();
28     int length();
29     int topValue();
30     void displayStack();
31     friend ostream &operator<< (ostream &os, const charSeqStack &a)
32     {
33         for (int i = 0; i < a.top+2; i++)
34         {
35             if (a.top == -1)
36                 return os;
37             os << a.data[i];
38         }
39 
40         return os;
41     }
42 
43 private:
44     elementType1 data[maxLength];
45     int top;
46 };
47 
48 
49 #endif // !defined(AFX_CHARSEQSTACK_H__A9958AD3_333A_41B4_B399_B6895C7AA8C5__INCLUDED_)

  1 // charSeqStack.cpp: implementation of the charSeqStack class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "charSeqStack.h"
  7 #include <iostream>
  8 #include <iomanip>
  9 
 10 using namespace std;
 11 //////////////////////////////////////////////////////////////////////
 12 // Construction/Destruction
 13 //////////////////////////////////////////////////////////////////////
 14 
 15 charSeqStack::charSeqStack()
 16 {
 17     top = -1;
 18 }
 19 
 20 charSeqStack::~charSeqStack()
 21 {
 22 
 23 }
 24 
 25 bool charSeqStack::stackEmpty()
 26 {
 27     return top == -1;
 28 }
 29 
 30 bool charSeqStack::stackFull()
 31 {
 32     return top == maxLength - 1;
 33 }
 34 
 35 bool charSeqStack::getTop( elementType1& value )
 36 {
 37     if( stackEmpty() )
 38     {
 39         value = '#';
 40         cout << "???ив????????ив" << endl;
 41         return false;
 42     }
 43     value = data[top];
 44     return true;
 45 }
 46 
 47 bool charSeqStack::push( elementType1 value )
 48 {
 49     if( stackFull() )
 50     {
 51         cout << "?и▓ив????ив" << endl;
 52         return false;
 53     }
 54     top ++;
 55     data[top] = value;
 56     return true;
 57 }
 58 
 59 bool charSeqStack::pop()
 60 {
 61     if( stackEmpty() )
 62     {
 63         cout << "??ив????ив" << endl;
 64         return false;
 65     }
 66     top --;
 67     return true;
 68 }
 69 
 70 int charSeqStack::length()
 71 {
 72     if( stackEmpty() )
 73     {
 74         cout << "??ив" << endl;
 75         return -1;
 76     }
 77     return top + 1;
 78 }
 79 
 80 void charSeqStack::displayStack()
 81 {
 82     if( stackEmpty() )
 83     {
 84         cout << "??ив????ив" << endl;
 85         return;
 86     }
 87     int column = 0;
 88     for( int i = 0; i <= top; i ++ )
 89     {
 90         cout << setw(6) << setiosflags( ios::left ) << data[i];
 91         column ++;
 92         if( column % 10 == 0 )
 93             cout << endl;
 94     }
 95 }
 96 
 97 int charSeqStack::topValue()
 98 {
 99     return top;
100 }

 1 // SeqStack.cpp : Defines the entry point for the console application.
 2 //
 3 
 4 #include "stdafx.h"
 5 #include "SeqStack1.h"
 6 #include <iostream>
 7 
 8 using namespace std;
 9 int main(int argc, char* argv[])
10 {
11     SeqStack ss1;
12     ss1.push(0);
13     charSeqStack css1, css2;
14     char Str[] = "#2+5*(2+3)*6/2-4#";
15     //12+5*（2+3）*6/2-4
16     //char Str[] = "#(1+(5-3)*2+9)/2#";
17     //char Str[] = "#(1+2)*3#";
18     //char Str[] = "#(1)#";
19     //char Str[] = "#1*2+3#";
20     //char Str[] = "#1+1#";
21     //char Str[] = "#1#";
22     for( int i = 0; Str[i] != ''; i ++ )
23         css2.push( Str[i] );
24 
25     cout << "Start Calculation." << endl;
26     cout << "expression:" << css2 << endl;
27     ss1.calculate( css1, css2 );
28     cout << "Calculation Done!" << endl;
29 
30     double x;
31     if( ss1.getTop(x) )
32         cout << x << endl;
33     cin.get();
34     return 0;
35 }

链栈代码：

 1 // stdafx.h : include file for standard system include files,
 2 //  or project specific include files that are used frequently, but
 3 //      are changed infrequently
 4 //
 5 
 6 #if !defined(AFX_STDAFX_H__2FE69ABE_CC01_4962_8147_FD6E39302FE4__INCLUDED_)
 7 #define AFX_STDAFX_H__2FE69ABE_CC01_4962_8147_FD6E39302FE4__INCLUDED_
 8 
 9 #if _MSC_VER > 1000
10 #pragma once
11 #endif // _MSC_VER > 1000
12 
13 #include <stdc++.h>
14 
15 using namespace std;
16 
17 typedef double elementType;
18 typedef char elementType1;
19 
20 typedef struct node
21 {
22     elementType data;
23     struct node *link;
24 }LStack, *PStack;
25 
26 typedef struct Node
27 {
28     elementType1 data;
29     struct Node *link;
30 }CLStack, *CPStack;
31 
32 typedef long ll;
33 
34 // TODO: reference additional headers your program requires here
35 
36 //{{AFX_INSERT_LOCATION}}
37 // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
38 
39 #endif // !defined(AFX_STDAFX_H__2FE69ABE_CC01_4962_8147_FD6E39302FE4__INCLUDED_)

 1 // linkedStack.h: interface for the linkedStack class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX_LINKEDSTACK_H__54B665DE_2CE8_4329_AED9_95FEAAAAE128__INCLUDED_)
 6 #define AFX_LINKEDSTACK_H__54B665DE_2CE8_4329_AED9_95FEAAAAE128__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 #include "charLinkedStack.h"
13 
14 class linkedStack  
15 {
16 public:
17     linkedStack();
18     virtual ~linkedStack();
19     bool stackEmpty();
20     //bool stackFull();
21     bool getTop( elementType& value );
22     bool push( elementType value );
23     bool pop();
24     int length();
25     void displayStack();
26     int isp( char  _operator );//栈内优先级
27     int icp( char _operator );//栈外优先级
28     double doOperator( elementType value1, elementType value2, char _operator );
29     void calculate( char* Str );
30     charLinkedStack cls;
31     bool isPopOrder();
32     bool judge(const elementType *sour, int s1, const elementType *dest, int s2 );
33     void linkedStack::printValidPopStackSequence( int n, elementType *A, int cur );
34     friend ostream &operator<< ( ostream &os, const linkedStack &a )
35     {
36         //for ( int i = 0; i < a.top + 1; i ++ )
37         //{
38         //    if (a.top == -1)
39         //        return os;
40         //    os << a.data[i];
41         //}
42         LStack *tmp = a.top;
43         int column = 0;
44         while( tmp->link )
45         {
46             //cout << tmp->data << " ";
47             if( tmp->link == NULL )
48                 return os;
49                 //break;
50             //os << tmp->data << " ";
51             os << setw(7) << setiosflags(ios::left) << tmp->data << " ";
52             column ++;
53             if( column % 10 == 0 )
54                 os << setw(7) << setiosflags(ios::left) << endl;
55             tmp = tmp->link;
56         }
57         os << endl;
58 
59         return os;
60     }
61 private:
62     LStack *top;
63     int len;
64 };
65 
66 #endif // !defined(AFX_LINKEDSTACK_H__54B665DE_2CE8_4329_AED9_95FEAAAAE128__INCLUDED_)

  1 // linkedStack.cpp: implementation of the linkedStack class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "linkedStack.h"
  7 
  8 //////////////////////////////////////////////////////////////////////
  9 // Construction/Destruction
 10 //////////////////////////////////////////////////////////////////////
 11 
 12 linkedStack::linkedStack()
 13 {
 14     top = new LStack;
 15     if( !top )
 16     {
 17         cerr << "Space allocating falied!Error in linkedStack::linkedStack()!" << endl;
 18     }
 19     top->link = NULL;
 20     //top = NULL;
 21     len = 0;
 22 }
 23 
 24 linkedStack::~linkedStack()
 25 {
 26     /*
 27     LStack *tmp = top;
 28     while( tmp->link )
 29     {
 30         LStack *q = tmp;
 31 
 32         tmp = tmp->link;
 33         delete q;
 34         
 35         len --;
 36     }    
 37     tmp->link = NULL;
 38     */
 39     while(top)
 40     {
 41         LStack *q = top;
 42         top = top->link;
 43         delete q;
 44     }
 45     top = NULL;
 46 }
 47 
 48 bool linkedStack::stackEmpty()
 49 {
 50     //follow style is not suitable for the code
 51     //return top == NULL;
 52     return top->link == NULL;
 53 }
 54 
 55 bool linkedStack::getTop( elementType& value )
 56 {
 57     if( stackEmpty() )
 58     {
 59         cerr << "Stack is Empty!Error in linkedStack::getTop!" << endl;
 60         //value = -1;
 61         return false;
 62     }
 63     value = top->data;
 64     return false;
 65 }
 66 
 67 bool linkedStack::push( elementType value )
 68 {
 69     LStack *newNode = new LStack;
 70     if( !newNode )
 71     {
 72         cerr << "Space allocating falied!" << endl;
 73         return false;
 74     }
 75     newNode->data = value;
 76     newNode->link = top;
 77     top = newNode;
 78     len ++;
 79     return true;
 80 }
 81 
 82 bool linkedStack::pop()
 83 {
 84     if( stackEmpty() )
 85     {
 86         cerr << "Stack is empty!Error in linkedStack::pop()!" << endl;
 87         return false;
 88     }
 89     LStack *tmp = top;
 90     
 91     top = top->link;
 92     delete tmp;
 93     len --;
 94     return true;
 95 }
 96 
 97 int linkedStack::length()
 98 {
 99     if( stackEmpty() )
100     {
101         cerr << "Stack is empty!Error in linkedStack::length()" << endl;
102         return -1;
103     }
104     int cnt = 0;
105     LStack *tmp = top;
106     while( tmp->link )
107     {
108         tmp = tmp->link;
109         cnt ++;
110     }
111     return cnt;
112 }
113 
114 void linkedStack::displayStack()
115 {
116     if( stackEmpty() )
117     {
118         cerr << "Stack is empty!Error in linkedStack::displayStack()" << endl;
119         return;
120     }
121     LStack *tmp = top;
122     int column = 0;
123     while( tmp->link )
124     {
125         cout << setw(7) << setiosflags(ios::left) << tmp->data << " ";
126         //cout << tmp->data << " ";
127         column ++;
128         if( column % 10 == 0 )
129             cout << setw(7) << setiosflags(ios::left) << endl;
130         tmp = tmp->link;
131     }
132     cout << endl;
133 }
134 
135 int linkedStack::isp( char _operator )
136 {
137     switch(_operator)
138     {
139     case '#' :
140         return 0;
141         break;
142     case '(':
143         return 6;
144         break;
145     case '*':
146         return 5;
147         break;
148     case '/':
149         return 5;
150         break;
151     case '%':
152         return 5;
153         break;
154     case '+':
155         return 3;
156         break;
157     case '-':
158         return 3;
159         break;
160     case ')':
161         return 1;
162         break;
163     }
164 
165     cerr << "Error in SeqStack::isp" << endl;
166     return -1;
167 }
168 
169 int linkedStack::icp( char _operator )
170 {
171     switch(_operator)
172     {
173     case '#' :
174         return 0;
175         break;
176     case '(':
177         return 1;
178         break;
179     case '*':
180         return 4;
181         break;
182     case '/':
183         return 4;
184         break;
185     case '%':
186         return 4;
187         break;
188     case '+':
189         return 2;
190         break;
191     case '-':
192         return 2;
193         break;
194     case ')':
195         return 6;
196         break;
197     }
198 
199     cerr << "Error in SeqStack::icp" << endl;
200     return -1;
201 }
202 
203 double linkedStack::doOperator( elementType value1, elementType value2, char _operator )
204 {
205     switch(_operator)
206     {
207     case '+':
208         return value1 + value2;
209         break;
210     case '-':
211         return value1 - value2;
212         break;
213     case '*':
214         return value1 * value2;
215         break;
216     case '/':
217         if( fabs(value2) < 0.0001 )
218         {
219             cout << "Divided by 0!" << endl;
220             return -1000000;
221         }
222         else
223             return value1 / value2;
224         break;
225     case '%':
226         if( fabs(value2) < 0.0001 )
227         {
228             cout << "Divided by 0!" << endl;
229             return -1000000;
230         }
231         else
232             return (int)value1 % (int)value2;
233         break;
234         
235     }
236 
237     cerr << "Error in SeqStack::doOperator" << endl;
238     return -1;
239 }
240 
241 void linkedStack::calculate( char* Str )
242 {
243     charLinkedStack css1;
244     char ch1;
245     int i = 0;
246     double a, b;
247     
248     int level = 0;
249     int temp = 0;
250  
251     while ( Str[i] != '' )
252     {
253         i ++;
254     }
255     i = i - 2;
256     while( css1.topValue() != NULL || Str[i] != '#' )
257     {
258         char ch = Str[i];
259         if ( isdigit(ch) )
260         {
261             temp = temp + pow( 10, level ) * int( ch - '0' );
262             level ++;
263             i --;
264         }
265         else
266         {
267             if (level)
268             {
269                 push(temp);
270                 temp = 0;
271                 level = 0;
272             }
273             css1.getTop(ch1);
274             if ( ch1 == ')' && ch == '(' )
275             {
276                 css1.pop();
277                 i --;
278                 continue;
279             }
280             if ( isp(ch1) < icp(ch) )
281             {
282                 css1.push(ch);
283                 i --;
284             }
285             else if (isp(ch1) >= icp(ch))
286             {
287                 getTop(a);
288                 pop();
289                 getTop(b);
290                 pop();
291                 push( doOperator( a, b, ch1 ) );
292                 css1.pop();
293             }
294         }
295     }
296 
297     if (level)
298     {
299         push(temp);
300     }
301      
302 }
303 
304 bool linkedStack::isPopOrder()
305 {
306     /*
307     当序列递增时，ok
308     当序列递减时，且相差为1 ，ok
309     当序列递减时，且相差大于1，但后续序列都递减时，ok
310     当序列递减时，且相差大于1，但后续序列非严格递减时，no
311 
312     直到序列递减大于1时，如果后续序列严格递减，则ok，否则no。其他情况都ok。
313     */
314     if( stackEmpty() )
315     {
316         return true;
317     }
318     bool decrease = true, increase = true, D_valueThanOne = false, D_valueEqualOne = true;
319     elementType value1, value2;
320 
321     getTop(value1);
322     pop();
323     while( !stackEmpty() )//原序列递增，弹栈序列递减；原序列递减，弹栈序列递增
324     {
325         
326         getTop(value2);
327         //pop();
328         //if( value2 > value1 && value2 - value1 > 1 )
329         if( value1 > value2 && fabs( value2 - value1 ) > 1 )
330         {    
331             while( !stackEmpty() )
332             {
333                 if( value1 >= value2 )
334                 {
335                     cout << fabs( value2 - value1 ) << endl;
336                     value1 = value2;
337                     pop();
338                 }
339                 else
340                     return false;
341             }
342         }
343         else
344             pop();
345     }
346     return true;
347 
348 }
349  
350 bool linkedStack::judge(const elementType *sour, int s1, const elementType *dest, int s2 )        //不比更改两个序列的内容，所以可加const修饰限定符
351 {
352      assert(sour);//断言可防止NULL指针的传入(避免传入指针引起程序崩溃的问题)
353      assert(dest);
354     //stack<char> ss;//借助库函数创建一个栈
355     linkedStack ss;
356     if (s1 != s2) //如果两个序列不一样长，自然是非法的序列
357         return false;
358  
359     ss.push(*sour++); //将首元素压栈
360     while (*dest != 0)  
361     {
362  
363         if (ss.stackEmpty() && *sour != 0) //如果栈为空且入栈序列未结束，则不断压入元素
364             ss.push(*sour++);
365         double x;
366         ss.getTop(x);
367         while (*dest != x && *sour != 0) 
368         {
369             ss.push(*sour++);//如果出栈元素和栈顶元素不匹配则继续压入元素
370             ss.getTop(x);
371         }
372         ss.getTop(x);
373         if (*dest == x )  //如果两者相等，将该元素弹出，且指针指向出栈序列的下一位置上
374         {
375             dest++;
376             ss.pop();
377             continue;
378         }
379         ss.getTop(x);
380         if (*sour == 0&& x != *dest)  //如果一直不相等，知道入栈序列结束仍为匹配上，说明出栈序列非法
381         {
382             return false;
383         }
384     }
385     return true;//否则序列合法
386 }
387 
388 void linkedStack::printValidPopStackSequence( int n, elementType *A, int cur )
389 {
390     ios::sync_with_stdio(false);
391     double B[8];
392     for( int i = 0; i < n; i ++ )
393         B[i] = i + 1;
394     B[n] =  0;
395     
396     if( cur == n )
397     {
398         A[n] = 0;
399         if( judge( B, n + 1, A, n + 1 ) )
400         {
401             for( int i = 0; i < n; i ++ )
402             {
403                 cout << A[i] << " ";
404             }
405             cout << endl;
406         }
407     }
408     else
409     {
410         for( int j = 1; j <= n; j ++ )
411         {
412             bool ok = true;
413         for( int k = 0; k < cur; k ++ )
414         {
415             if( A[k] == j )
416                 ok = false;
417         }
418         if(ok)
419         {
420             A[cur] = j;
421             printValidPopStackSequence( n, A, cur + 1 );
422         }
423    }
424     }
425 }

 1 // charLinkedStack.h: interface for the charLinkedStack class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX_CHARLINKEDSTACK_H__CBB1096F_5E0D_4725_8583_A16EF4EA8502__INCLUDED_)
 6 #define AFX_CHARLINKEDSTACK_H__CBB1096F_5E0D_4725_8583_A16EF4EA8502__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 class charLinkedStack  
13 {
14 public:
15     charLinkedStack();
16     virtual ~charLinkedStack();
17     bool stackEmpty();
18     //bool stackFull();
19     bool getTop( elementType1& value );
20     bool push( elementType1 value );
21     bool pop();
22     int length();
23     void displayStack();
24     CPStack topValue();
25     void decToHex( long value );
26     bool brancheMatch( char *Str );
27     bool charLinkedStack::judge(const char *sour, const char *dest);
28     friend ostream &operator<< ( ostream &os, const charLinkedStack &a )
29     {
30         //for ( int i = 0; i < a.top + 1; i ++ )
31         //{
32         //    if (a.top == -1)
33         //        return os;
34         //    os << a.data[i];
35         //}
36         CLStack *tmp = a.top;
37         int column = 0;
38         while( tmp->link )
39         {
40             //cout << tmp->data << " ";
41             if( tmp->link == NULL )
42                 return os;
43                 //break;
44             os << tmp->data;
45             //os << setw(7) << setiosflags(ios::left) << tmp->data << " ";
46             //column ++;
47             //if( column % 10 == 0 )
48                 //os << setw(7) << setiosflags(ios::left) << endl;
49             tmp = tmp->link;
50         }
51         os << endl;
52 
53         return os;
54     }
55 private:
56     CLStack *top;
57     int len;
58 
59 };
60 
61 #endif // !defined(AFX_CHARLINKEDSTACK_H__CBB1096F_5E0D_4725_8583_A16EF4EA8502__INCLUDED_)

  1 // charLinkedStack.cpp: implementation of the charLinkedStack class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "charLinkedStack.h"
  7 
  8 //////////////////////////////////////////////////////////////////////
  9 // Construction/Destruction
 10 //////////////////////////////////////////////////////////////////////
 11 
 12 charLinkedStack::charLinkedStack()
 13 {
 14     top = new CLStack;
 15     if( !top )
 16     {
 17         cerr << "Space allocating falied!Error in linkedStack::linkedStack()!" << endl;
 18     }
 19     top->link = NULL;
 20     //top = NULL;
 21     len = 0;
 22 }
 23 
 24 charLinkedStack::~charLinkedStack()
 25 {
 26     while(top)
 27     {
 28         CLStack *q = top;
 29         top = top->link;
 30         delete q;
 31     }
 32     top = NULL;
 33 }
 34 
 35 bool charLinkedStack::stackEmpty()
 36 {
 37     //follow style is not suitable for the code
 38     //return top == NULL;
 39     return top->link == NULL;
 40 }
 41 
 42 bool charLinkedStack::getTop( elementType1& value )
 43 {
 44     if( stackEmpty() )
 45     {
 46         //cerr << "Stack is Empty!Error in linkedStack::getTop!" << endl;
 47         value = '#';
 48         return false;
 49     }
 50     value = top->data;
 51     return false;
 52 }
 53 
 54 bool charLinkedStack::push( elementType1 value )
 55 {
 56     CLStack *newNode = new CLStack;
 57     if( !newNode )
 58     {
 59         cerr << "Space allocating falied!" << endl;
 60         return false;
 61     }
 62     newNode->data = value;
 63     newNode->link = top;
 64     top = newNode;
 65     len ++;
 66     return true;
 67 }
 68 
 69 bool charLinkedStack::pop()
 70 {
 71     if( stackEmpty() )
 72     {
 73         cerr << "Stack is empty!Error in linkedStack::pop()!" << endl;
 74         return false;
 75     }
 76     CLStack *tmp = top;
 77     
 78     top = top->link;
 79     delete tmp;
 80     len --;
 81     return true;
 82 }
 83 
 84 int charLinkedStack::length()
 85 {
 86     if( stackEmpty() )
 87     {
 88         cerr << "Stack is empty!Error in linkedStack::length()" << endl;
 89         return -1;
 90     }
 91     int cnt = 0;
 92     CLStack *tmp = top;
 93     while( tmp->link )
 94     {
 95         tmp = tmp->link;
 96         cnt ++;
 97     }
 98     return cnt;
 99 }
100 
101 void charLinkedStack::displayStack()
102 {
103     if( stackEmpty() )
104     {
105         cerr << "Stack is empty!Error in linkedStack::displayStack()" << endl;
106         return;
107     }
108     CLStack *tmp = top;
109     int column = 0;
110     while( tmp->link )
111     {
112         cout << setw(7) << setiosflags(ios::left) << tmp->data << " ";
113         //cout << tmp->data << " ";
114         column ++;
115         if( column % 10 == 0 )
116             cout << setw(7) << setiosflags(ios::left) << endl;
117         tmp = tmp->link;
118     }
119     cout << endl;
120 }
121 
122 CPStack charLinkedStack::topValue()
123 {
124     return top->link;//write as "return top;" is not available
125 }
126 
127 void charLinkedStack::decToHex( ll value )
128 {
129     ll tmp = value;
130     while(tmp)
131     {
132         ll mod = tmp % 16;
133         if( mod <= 9 )
134         {
135             push( (char) ( mod + '0' ) );
136         }
137         else
138         {
139             switch(mod)
140             {
141             case 10:
142                 push('A');
143                 break;
144             case 11:
145                 push('B');
146                 break;
147             case 12:
148                 push('C');
149                 break;
150             case 13:
151                 push('D');
152                 break;
153             case 14:
154                 push('E');
155                 break;
156             case 15:
157                 push('F');
158                 break;
159             default:
160                 cerr << "Error in void charSeqStack::transfor()" << endl;
161                 break;
162             }
163         }
164         tmp /= 16;
165     }
166 }
167 
168 bool charLinkedStack::brancheMatch( char *Str )
169 {
170     
171     int i = 0;
172     char ch = Str[i];
173     elementType1 ch1 = NULL;
174     while( ch != '' )
175     {
176         if( ch == '(' || ch == '[' || ch == '{' )
177         {
178             push(ch);
179             
180         }
181         else if( ch == ')' || ch == ']' || ch == '}' )
182         {
183             //ch1 = NULL;
184             if( !stackEmpty() )
185             {
186                 //ch1 = NULL;
187                 getTop(ch1);
188                 //把下面这句话放到下面这个if判断里面结果就正确了
189                 //pop();
190                 //cout << (*this) << endl;
191                 if( ( ch == ')' && ch1 == '(' ) || 
192                     ( ch == ']' && ch1 == '[' ) || ( ch == '}' && ch1 == '{' ) )
193                 {
194                     //ch = NULL;
195                     //ch1 = NULL;
196                     pop();
197                     //continue;
198                 }    //ch = Str[ ++ i ];
199                 
200                 else if( ( ch == ')' && ch1 != '(' ) || 
201                     ( ch == ']' && ch1 != '[' ) || ( ch == '}' && ch1 != '{' ) )
202                     return false;
203             }
204             
205             else //if( stackEmpty() && !ch1 )
206                 return false;
207         }
208         
209         ch = Str[ ++ i ];
210     }
211     if( stackEmpty() )
212     {
213         return true;
214     }
215     
216     while( !stackEmpty() )
217     {
218         pop();
219         
220     }
221     
222     return false;
223 }
224  
225 bool charLinkedStack::judge(const char *sour, const char *dest)        //不比更改两个序列的内容，所以可加const修饰限定符
226 {
227      assert(sour);//断言可防止NULL指针的传入(避免传入指针引起程序崩溃的问题)
228      assert(dest);
229     //stack<char> ss;//借助库函数创建一个栈
230     charLinkedStack ss;
231     if (strlen(sour) != strlen(dest)) //如果两个序列不一样长，自然是非法的序列
232         return false;
233  
234     ss.push(*sour++); //将首元素压栈
235     while (*dest != '')  
236     {
237  
238         if (ss.stackEmpty() && *sour != '') //如果栈为空且入栈序列未结束，则不断压入元素
239             ss.push(*sour++);
240         char x;
241         ss.getTop(x);
242         while (*dest != x && *sour != '') 
243         {
244             ss.push(*sour++);//如果出栈元素和栈顶元素不匹配则继续压入元素
245             ss.getTop(x);
246         }
247         ss.getTop(x);
248         if (*dest == x )  //如果两者相等，将该元素弹出，且指针指向出栈序列的下一位置上
249         {
250             dest++;
251             ss.pop();
252             continue;
253         }
254         ss.getTop(x);
255         if (*sour == ''&& x != *dest)  //如果一直不相等，知道入栈序列结束仍为匹配上，说明出栈序列非法
256         {
257             return false;
258         }
259     }
260     return true;//否则序列合法
261 }

  1 // _LinkedStack.cpp : Defines the entry point for the console application.
  2 //
  3 
  4 #include "stdafx.h"
  5 #include "linkedStack.h"
  6 
  7 /*
  8 void test()
  9 {
 10     ios::sync_with_stdio(false);
 11     //freopen( "x1.in", "r", stdin );
 12     FILE *fp = fopen( "x1.in", "r" );
 13     //cout << "werfe" << endl;
 14     linkedStack LS1;
 15     charLinkedStack CLS1, CLS2;
 16     for( int i = 1; i <= 113; i ++ )
 17     {
 18         //LS1.push(i);
 19     }
 20     //cout << LS1 << endl;
 21     //LS1.displayStack();
 22 
 23     for( int j = 0; j <= 26; j ++ )
 24     {
 25         //CLS1.push( (char)( 'A' + j ) );
 26     }
 27     /*
 28     char Str[] = "#12+5*(2+3)*6/2-4#";
 29     LS1.calculate(Str);
 30     cout << LS1;
 31     ll n;
 32     //while( cin >> n )
 33     {
 34         cin >> n;
 35         CLS1.decToHex(n);
 36         cout << CLS1;
 37         //CLS1.~charLinkedStack();
 38     }
 39     
 40     char Str2[1000];
 41     while(1)
 42     {
 43         gets(Str2);
 44         if(CLS2.brancheMatch(Str2) )
 45             cout << "YES!" << endl;
 46         else
 47             cout << "NO!" << endl;
 48     }
 49     //cout << CLS1;
 50     //cout << LS1.length() << endl;
 51     //int x;
 52     //LS1.getTop(x);
 53     //cout << x << endl;
 54     //LS1.pop();
 55     //LS1.getTop(x);
 56     //cout << endl;
 57     cin.get();
 58 }
 59 */
 60 
 61 int main(int argc, char* argv[])
 62 {
 63     /*
 64     while(1)
 65     {
 66         test();
 67     }
 68     
 69     ios::sync_with_stdio(false);
 70     //freopen( "x1.in", "r", stdin );
 71     
 72     //freopen( "x1.out", "w", stdout );
 73     */
 74     //FILE *fp = fopen( "x1.in", "r" );
 75     /*
 76     //cout << "werfe" << endl;
 77     linkedStack LS1;
 78     charLinkedStack CLS1, CLS2;
 79     //for( int i = 1; i <= 113; i ++ )
 80     //{
 81         //LS1.push(i);
 82     //}
 83     //cout << LS1 << endl;
 84     //LS1.displayStack();
 85 
 86     //for( int j = 0; j <= 26; j ++ )
 87 //    {
 88         //CLS1.push( (char)( 'A' + j ) );
 89 //    }
 90     
 91     linkedStack LS1;
 92     char Str[] = "#12+5*(2+3)*6/2-4#", Str2[] = "#34456%3+100*5+3-100#";
 93     LS1.calculate(Str);
 94     for( int i = 1;  Str[i] != '#' && i < strlen(Str); i++ )
 95         cout << Str[i];
 96     cout << " = " << LS1;
 97     LS1.pop();
 98     LS1.calculate(Str2);
 99     for( i = 1;  Str2[i] != '#' && i < strlen(Str2); i++ )
100         cout << Str2[i];
101     cout << " = " << LS1;
102     
103     charLinkedStack CLS1;
104     ll n;
105     while( cin >> n )
106     {
107         //cin >> n;
108         CLS1.decToHex(n);
109         cout << CLS1;
110         while( !CLS1.stackEmpty() )
111             CLS1.pop();
112         //CLS1.~charLinkedStack();
113     }
114     
115     charLinkedStack CLS2;
116     char Str2[1000];
117     while( fgets( Str2, 1000, fp ) != NULL )
118     {
119         //gets(Str2);
120         if( CLS2.brancheMatch(Str2) )
121             cout << Str2 << " ---> legal!" << endl;
122         else
123             cout << Str2 << " ---> illegal!" << endl;
124     }
125     
126     linkedStack LS2;
127     
128     for( int i = 1; i <= 10; i ++ )
129     {
130         LS2.push(i);
131     }
132     
133     LS2.push(1.0);
134     LS2.push(4.0);
135     LS2.push(2.0);
136     LS2.push(3.0);
137     
138     cout << LS2 << endl;
139     if( LS2.isPopOrder() )
140         cout << " --- legal" <<endl;
141     else
142         cout << " --- illegal" << endl;
143     
144     linkedStack LS3;
145     elementType Arr1[] = { 1, 2, 3, 4 }, Arr2[5];//, Arr2[] = { 1, 4, 2, 3 };
146     //elementType Arr1[100], Arr2[100];
147 
148     int cnt = 0;
149     
150     while( cnt ++ < 24 )
151     {
152         //if( LS3.judgeIsLegal( Arr1, Arr2 ) )
153         for( int i = 0; i < 5; i ++ )
154             cin >> Arr2[i];
155         if( LS3.judge( Arr1, 5, Arr2, 5 ) )
156         {
157             cout << setw(2) << cnt << " : ";
158             for( int j = 0; j < 4; j ++ )
159                 cout << Arr2[j] << " ";
160             cout << " ---> legal!" << endl;
161         }
162         else
163         {
164             //cout << cnt << " ---> NO!" << endl;
165             cout << setw(2) << cnt << " : ";
166             for( int j = 0; j < 4; j ++ )
167                 cout << Arr2[j] << " ";
168             cout << " ---> illegal!" << endl;
169         }
170     }
171 
172     */
173     linkedStack  LS5;
174     elementType A[8];
175     cout << "The valid out-of-stack sequences of 1 to 7 are:" << endl;
176     LS5.printValidPopStackSequence( 7, A, 0 );
177 
178     /*
179     
180     charLinkedStack ss;
181     char Str[4];
182     int cnt = 0;
183     while( cnt ++ < 24 )
184     {
185         gets(Str);
186         cout << cnt << " : " << Str << " --- " << ss.judge( "abcd",Str ) << endl;
187     }
188     */
189     cin.get();
190     return 0;
191 }

查看全文

相关阅读:
PHP之数据库操作(一)
PHP之字符串操作
 Subline使用方法
 POST和GET的区别（面试回答）
面试题（1）
http协议
 JS 闭包（内存溢出与内存泄漏）（垃圾回收机制）
JS----事件机制事件冒泡事件捕获事件委托
 js的数据类型、判断对象类型 js对象
 JS----DOM节点操作：创建，插入，删除，复制，查找节点

原文地址：https://www.cnblogs.com/25th-engineer/p/9940191.html