《算法与数据结构---C语言描述》里的求多项达式值

在栈的应用里，作者写了将多项式值 ，但是描述的不是很清楚，露了一个说明 。

1. 从左到右读取中缀表达式,依次一个操作项.
2. 如果是操作数直接进入输出队列.
3. 读到左括号时总是将它压入栈中.
4. 读到右括号, 将最近栈顶的第一个左括号上面的操作符全部依次弹出, 送至输出队列后, 再丢弃左括号.
5. 当读到操作符时,将栈中所有优先级高于或等于当前操作符的操作符弹出，送到输出队列中.
6. 中缀表达式全部读完后，若栈中仍然有运算符，将其送到输出队列中

少了5，6的说明，但是从例子中也能看出来。一定要注意，遇到优先级高于当前处理的操作符时，栈内高于或等于此优先级的操作符逐一出栈，直到遇到小于此操作符的。

 

我写了多项式求值的示例代码。为了处理方便，将char** 用string[]来处理了。

栈数据结构的代码

栈的实现

 1 #ifndef LINKSTACK_H
 2 #define LINKSTACK_H
 3 
 4 template<class T>
 5 class Node
 6 {
 7 public:
 8     T m_Data;
 9     Node* m_Link;
10 public:
11     Node(){
12         m_Link = NULL;
13     }
14 };
15 template<class T>
16 class LinkStack
17 {
18 public:
19     LinkStack(){
20         mTop = NULL;
21     }
22     ~LinkStack(){
23 
24     }
25     bool isEmptyStack_link(){
26         if (mTop == NULL)
27         {
28             return true;
29         }
30         return false;
31     }
32     bool push_link(T data){
33         Node<T>* newnode = new Node<T>();
34         newnode->m_Data = data;
35         if(!newnode){
36             return false;
37         }
38         newnode->m_Link = mTop;
39         mTop = newnode;
40 
41         return true;
42     }
43     T pop_link(){
44         if (!isEmptyStack_link())
45         {
46             T data = (mTop->m_Data);
47             Node<T>* p = mTop->m_Link;
48             if(mTop){
49                 delete mTop;
50             }
51             mTop = p;
52 
53             return data;
54         }
55     }
56     T top_link(){
57         if (!isEmptyStack_link())
58         {
59             T data = (mTop->m_Data);
60 
61             return data;
62         }
63     }
64 private:
65     Node<T>* mTop;
66 };
67 #endif

多项式求值的代码

多项式求值

  1 // stack.cpp : 定义控制台应用程序的入口点。
  2 //
  3 
  4 #include "stdafx.h"
  5 #include "string.h"
  6 #include <stdlib.h>
  7 #include "seqstack.h"
  8 #include "linkstack.h"
  9 #include <string>
 10 #include <iostream>
 11 using namespace std;
 12 /*
 13 * 前缀表达式转后缀表达式 
 14 */
 15 int  fixpost(char* src,string& ret,int len);
 16 bool isOp(const char* var);                    //是否是操作符
 17 int  result(string* des,int len);            //求后缀表达式的值（参数为已经转成后缀表达式的字符串）
 18 int getPriority(const char* s);                //求某操作符对应的优先级
 19 char g_op[]= {'+','-','*','/','(',')'};        //存储表达式
 20 int  g_priority[]={1,1,2,2,3,3};            //各个表达式的优先级
 21 int divtoken(const char* src,string* ret);    //将表达式以空格分隔
 22 int _tmain(int argc, _TCHAR* argv[])
 23 {
 24     LinkStack<int> stack;
 25 
 26     //     for (int i = 0 ; i < 10 ; i++)
 27 //     {
 28 //         stack.push_link(i);
 29 //     }
 30 //     for (int i = 0 ; i < 10 ; i++)
 31 //     {
 32 //         printf("%d\n",stack.pop_link());
 33 //     }
 34     char* src = "31 * ( 5 - 22 ) + 70";
 35     string ret ;
 36     fixpost(src,ret,strlen(src));
 37     cout<<ret<<endl;
 38     string ss[10];
 39     int n = divtoken(ret.c_str(),ss);
 40     cout<<result(ss,n)<<endl;
 41     system("pause");
 42     return 0;
 43 }
 44 bool isOp(const char* var)
 45 {
 46 
 47     if (strstr(g_op,var) == 0)
 48     {
 49         return false;
 50     }
 51     return true;
 52 }
 53 int divtoken(const char* src,string* ret)
 54 {
 55     int len = strlen(src);
 56     if( src[len-1] == ''){
 57         len --;
 58     }
 59     int j = 0;
 60     for (int i = 0 ; i < len; i++)
 61     {
 62         char a = src[i];
 63         if(src[i] == ''){
 64             j++;
 65             continue;
 66         }
 67         ret[j] += src[i]; 
 68     }
 69 
 70     return j+1;
 71 }
 72 int fixpost(char* src,string& ret ,int len)
 73 {
 74     if( len <= 0 ){
 75         return 0;
 76     }
 77 
 78     string str[30];
 79     int l = divtoken(src,str);
 80 
 81     LinkStack<string> stack;
 82     int j = 0;
 83 
 84     string temp = "";
 85     for (int i = 0; i < l; i++)
 86     {
 87         if (!isOp(str[i].c_str()))
 88         {
 89             ret += str[i];
 90             ret+="";
 91         }
 92         else{
 93             if (str[i] ==")")
 94             {
 95                 while (!stack.isEmptyStack_link() && stack.top_link() != "(")
 96                 {
 97                 
 98                     temp = stack.pop_link();
 99                     if(temp!= "("){
100                         ret += temp;
101                         ret+="";
102                     }
103                 
104                 }
105                 stack.pop_link();
106             }
107             else{
108                 int pri = getPriority(str[i].c_str());
109                 while (!stack.isEmptyStack_link() && 
110                     stack.top_link() != "(" && 
111                     stack.top_link() != ")" &&
112                     str[i] != "("
113                     )
114                 {
115                     if ( getPriority(stack.top_link().c_str()) >= pri )
116                     {
117                         temp = stack.pop_link();
118                             ret += temp;
119                             ret+="";
120                     }
121                 }
122                 stack.push_link(str[i]);
123             }
124         }
125     }
126     while (!stack.isEmptyStack_link())
127     {
128         ret += stack.pop_link();
129         ret+="";
130     }
131     
132     return 0;
133 }
134 int getPriority(const char* s)
135 {
136     int index = -1;
137     int i = 0;
138     for (;i < sizeof(g_op)/sizeof(char);i++)
139     {
140         if(g_op[i] == *s){
141             index = i;
142             break;
143         }
144     }
145     if(index == -1){
146         return -1;
147     }
148     return g_priority[i];
149 }
150 int  result(string* des,int len)
151 {
152     
153     LinkStack<int> stack;
154     int res = 0;
155     for (int i = 0; i < len; i++)
156     {
157         if (isOp(des[i].c_str()))
158         {
159             int num1 = 0;
160             int num2 = 0; 
161             if (!stack.isEmptyStack_link())
162             {
163                 num2 = stack.pop_link();
164                 num1 = stack.pop_link();
165             }
166             int res = 0;
167             //如果有反射就好了
168             if(des[i] == "+"){
169                 res = num1+num2;
170             }
171             if(des[i] == "-"){
172                 res = num1-num2;
173             }
174             if(des[i] == "*"){
175                 res = num1*num2;
176             }
177             if(des[i] == "/"){
178                 if( num2 == 0 ){res = 0;}
179                 else
180                 res = num1/num2;
181             }
182             stack.push_link(res);
183         }
184         else{
185             stack.push_link(atoi(des[i].c_str()));
186         }
187     }
188     res = stack.pop_link();
189     return res;
190 }