栈数据结构的应用：中序表达式后续表达式和前序表达式的计算，中序表达式转换为后续表达式，做回溯控制

1中序表达式求值

 

  1 //计算中序四则表达式的值，输入的表达式内的每一个字符
  2 //代表一个操作数或运算符，而且中间不可有空格，换句话
  3 //说，操作数的范围只有数字0到9
  4 #include <stdlib.h>
  5 #include <stdio.h>
  6 
  7 struct stack_node
  8 {
  9     int data;
 10     struct stack_node * next;
 11 };
 12 
 13 typedef struct stack_node stack_list;
 14 typedef stack_list * link;
 15 
 16 link operator = NULL;
 17 link operand = NULL;
 18 
 19 link push(link stack,int value)
 20 {
 21     link new_node;
 22     
 23     new_node = (link)malloc(sizeof(stack_list));
 24     if(!new_node)
 25     {
 26         printf("内存分配失败！ \n");
 27         return NULL;
 28     }
 29     new_node->data = value;
 30     new_node->next = stack;
 31     stack = new_node;
 32     return stack;
 33 }
 34 
 35 
 36 link pop(link stack,int *value)
 37 {
 38     link top;
 39     
 40     if(stack != NULL)
 41     {
 42         top = stack;
 43         stack = stack->next;
 44         *value = top->data;
 45         free(top);
 46         return stack;
 47     }
 48     else
 49         *value = -1;
 50 }
 51 
 52 
 53 int empty(link stack)
 54 {
 55     if(stack == NULL)
 56         return 1;
 57     else
 58         return 0;
 59 }
 60 
 61 
 62 int isoperator(char op)
 63 {
 64     switch(op)
 65     {
 66         case '+':
 67         case '-':
 68         case '*':
 69         case '/': return 1;
 70         default: return 0;
 71     }
 72 }
 73 
 74 
 75 int priority(char op)
 76 {
 77     switch(op)
 78     {
 79         case '*':
 80         case '/': return 2;
 81         case '+':
 82         case '-': return 1;
 83         default: return 0;
 84     }
 85 }
 86 
 87 
 88 int get_value(int op,int operand1,int operand2)
 89 {
 90     switch((char)op)
 91     {
 92         case '*': return (operand2 * operand1);
 93         case '/': return (operand2 / operand1);
 94         case '+': return (operand2 + operand1);
 95         case '-': return (operand2 - operand1);
 96     }
 97 }
 98 
 99 
100 int main()
101 {
102     char exp[100];
103     int op = 0;
104     int operand1 = 0;
105     int operand2 = 0;
106     int result = 0;
107     int pos = 0;
108     
109     printf("请输入中序表达式 ==> ");
110     gets(exp);
111     
112     while(exp[pos] != '\0'  && exp[pos] != '\n')
113     {
114         if(isoperator(exp[pos]))
115         {
116             if(!empty(operator))
117                 while(!empty(operator)  && priority(exp[pos]) <= priority(operator->data))
118                 {
119                     operator = pop(operator,&op);
120                     operand = pop(operand,&operand1);
121                     operand = pop(operand,&operand2);
122                     
123                     operand = push(operand,get_value(op,operand1,operand2));
124                 }
125             operator = push(operator,exp[pos]);
126         }
127         else
128             operand = push(operand,exp[pos] - 48);
129         pos++;
130     }
131     
132     while(!empty(operator))
133     {
134         operator = pop(operator,&op);
135         operand = pop(operand,&operand1);
136         operand = pop(operand,&operand2);
137         
138         operand = push(operand,get_value(op,operand1,operand2));
139     }
140     operand = pop(operand,&result);
141     printf("表达式[%s]的结果是 %d\n",exp,result);
142 }

 

前序表达式求职

  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 
  4 struct stack_node
  5 {
  6     int data;
  7     struct stack_node * next;
  8 };
  9 
 10 typedef struct stack_node stack_list;
 11 typedef stack_list * link;
 12 
 13 link prefix = NULL;         //表达式栈指针
 14 link operand = NULL;
 15 
 16 link push(link stack,int value)
 17 {
 18     link new_node;
 19 
 20     new_node = (link)malloc(sizeof(stack_list));
 21     if(!new_node)
 22     {
 23         printf("内存分配失败！ \n");
 24         return NULL;
 25     }
 26     new_node->data = value;
 27     new_node->next = stack;
 28     stack = new_node;
 29     return stack;
 30 }
 31 
 32 
 33 link pop(link stack,int *value)
 34 {
 35     link top;
 36 
 37     if(stack != NULL)
 38     {
 39         top = stack;
 40         stack = stack->next;
 41         *value = top->data;
 42         free(top);
 43         return stack;
 44     }
 45     else
 46         *value = -1;
 47 }
 48 
 49 
 50 int empty(link stack)
 51 {
 52     if(stack == NULL)
 53         return 1;
 54     else
 55         return 0;
 56 }
 57 
 58 
 59 int isoperator(char op)
 60 {
 61     switch(op)
 62     {
 63         case '+':
 64         case '-':
 65         case '*':
 66         case '/': return 1;
 67         default: return 0;
 68     }
 69 }
 70 
 71 
 72 int get_value(int op,int operand1,int operand2)
 73 {
 74     switch((char)op)
 75     {
 76         case '*': return (operand2 * operand1);
 77         case '/': return (operand2 / operand1);
 78         case '+': return (operand2 + operand1);
 79         case '-': return (operand2 - operand1);
 80     }
 81 }
 82 
 83 
 84 int main()
 85 {
 86     char exp[100];
 87     int operand1 = 0;
 88     int operand2 = 0;
 89     int result = 0;
 90     int pos = 0;
 91     int token = 0;
 92 
 93     printf("请输入前序表达式 ==> ");
 94     gets(exp);
 95     printf("前序表达式[%s]的结果是 ",exp);
 96     
 97     while(exp[pos] != '\0'  && exp[pos] != '\n')
 98     {
 99         prefix = push(prefix,exp[pos]);
100         pos++;
101     }
102 
103     while(!empty(prefix))
104     {
105         prefix = pop(prefix,&token);
106         if(isoperator(token))
107         {
108             operand = pop(operand,&operand1);
109             operand = pop(operand,&operand2);
110             operand = push(operand,get_value(token,operand1,operand2));
111         }
112         else
113             operand = push(operand,token-48);
114         
115     }
116     operand = pop(operand,&result);
117     printf(" %d\n",result);
118    
119 }

后序表达式求值

  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 
  4 struct stack_node
  5 {
  6     int data;
  7     struct stack_node * next;
  8 };
  9 
 10 typedef struct stack_node stack_list;
 11 typedef stack_list * link;
 12 
 13 link operand = NULL;
 14 
 15 link push(link stack,int value)
 16 {
 17     link new_node;
 18 
 19     new_node = (link)malloc(sizeof(stack_list));
 20     if(!new_node)
 21     {
 22         printf("内存分配失败！ \n");
 23         return NULL;
 24     }
 25     new_node->data = value;
 26     new_node->next = stack;
 27     stack = new_node;
 28     return stack;
 29 }
 30 
 31 
 32 link pop(link stack,int *value)
 33 {
 34     link top;
 35 
 36     if(stack != NULL)
 37     {
 38         top = stack;
 39         stack = stack->next;
 40         *value = top->data;
 41         free(top);
 42         return stack;
 43     }
 44     else
 45         *value = -1;
 46 }
 47 
 48 
 49 int empty(link stack)
 50 {
 51     if(stack == NULL)
 52         return 1;
 53     else
 54         return 0;
 55 }
 56 
 57 
 58 int isoperator(char op)
 59 {
 60     switch(op)
 61     {
 62         case '+':
 63         case '-':
 64         case '*':
 65         case '/': return 1;
 66         default: return 0;
 67     }
 68 }
 69 
 70 
 71 int get_value(int op,int operand1,int operand2)
 72 {
 73     switch((char)op)
 74     {
 75         case '*': return (operand2 * operand1);
 76         case '/': return (operand2 / operand1);
 77         case '+': return (operand2 + operand1);
 78         case '-': return (operand2 - operand1);
 79     }
 80 }
 81 
 82 
 83 int main()
 84 {
 85     char exp[100];
 86     int operand1 = 0;
 87     int operand2 = 0;
 88     int result = 0;
 89     int pos = 0;
 90 
 91     printf("请输入后序表达式 ==> ");
 92     gets(exp);
 93     printf("后序表达式[%s]的结果是 ",exp);
 94     
 95     while(exp[pos] != '\0'  && exp[pos] != '\n')
 96     {
 97         if(isoperator(exp[pos]))
 98         {
 99             operand = pop(operand,&operand1);
100             operand = pop(operand,&operand2);
101             operand = push(operand,get_value(exp[pos],operand1,operand2));
102         }
103         else
104             operand = push(operand,exp[pos]-48);
105         pos++;
106     }
107 
108     operand = pop(operand,&result);
109     printf(" %d\n",result);
110    
111 }

中序表达式转换为后序表达式

  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 
  4 struct stack_node
  5 {
  6     int data;
  7     struct stack_node * next;
  8 };
  9 
 10 typedef struct stack_node stack_list;
 11 typedef stack_list * link;
 12 
 13 link operator = NULL;
 14 
 15 link push(link stack,int value)
 16 {
 17     link new_node;
 18 
 19     new_node = (link)malloc(sizeof(stack_list));
 20     if(!new_node)
 21     {
 22         printf("内存分配失败！ \n");
 23         return NULL;
 24     }
 25     new_node->data = value;
 26     new_node->next = stack;
 27     stack = new_node;
 28     return stack;
 29 }
 30 
 31 
 32 link pop(link stack,int *value)
 33 {
 34     link top;
 35 
 36     if(stack != NULL)
 37     {
 38         top = stack;
 39         stack = stack->next;
 40         *value = top->data;
 41         free(top);
 42         return stack;
 43     }
 44     else
 45         *value = -1;
 46 }
 47 
 48 
 49 int empty(link stack)
 50 {
 51     if(stack == NULL)
 52         return 1;
 53     else
 54         return 0;
 55 }
 56 
 57 
 58 int isoperator(char op)
 59 {
 60     switch(op)
 61     {
 62         case '(':
 63         case ')':
 64         case '+':
 65         case '-':
 66         case '*':
 67         case '/': return 1;
 68         default: return 0;
 69     }
 70 }
 71 
 72 int priority(char op)
 73 {
 74     switch(op)
 75     {
 76         case '*':
 77         case '/': return 3;
 78         case '+':
 79         case '-': return 2;
 80         case '(': return 1;
 81         default: return 0;
 82     }
 83 }
 84 
 85 int main()
 86 {
 87     char infix[100];
 88     char result[100];
 89     int op = 0;
 90     int pos = 0;
 91     int rpos = 0;
 92     
 93     printf("请输入中序表达式 ==> ");
 94     gets(infix);
 95    
 96     
 97     while(infix[pos] != '\0'  && infix[pos] != '\n')
 98     {
 99         if(isoperator(infix[pos]))
100         {
101             if(empty(operator) || infix[pos] == '(')
102                 operator = push(operator,infix[pos]);
103             else
104             {
105                 if(infix[pos] == ')')
106                 {
107                     while(operator->data != '(')
108                     {
109                         operator = pop(operator,&op);
110                         result[rpos++] = op;
111                     }
112                     operator = pop(operator,&op);
113                 }
114                 else
115                 {
116                     while(priority(infix[pos]) <=
117                           priority(operator->data) &&
118                           !empty(operator))
119                     {
120                         operator = pop(operator,&op);
121                         result[rpos++] = op;
122                     }
123                     operator = push(operator,infix[pos]);
124                 }
125             }
126         }
127         else
128             result[rpos++] = infix[pos];
129         pos++;
130     }
131     while(!empty(operator))
132     {
133         operator = pop(operator,&op);
134         result[rpos++] = op;
135     }
136 
137     result[rpos] = '\0';
138     printf("后序表达式是 %s \n",result);
139 }

用栈做回溯控制

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 struct stack_node
  5 {
  6     int x;
  7     int y;
  8     struct stack_node * next;
  9 };
 10 
 11 typedef struct stack_node stack_list;
 12 typedef stack_list * link;
 13 
 14 link path = NULL;
 15 
 16 link push(link stack,int x,int y)
 17 {
 18     link new_node;
 19     
 20     new_node = (link)malloc(sizeof(stack_list));
 21     if(!new_node)
 22     {
 23         printf("内存分配失败！ \n");
 24         return NULL;
 25     }
 26     new_node->x = x;
 27     new_node->y = y;
 28     new_node->next = stack;
 29     stack = new_node;
 30     return stack;
 31 }
 32 
 33 link pop(link stack,int *x,int *y)
 34 {
 35     link top;
 36     
 37     if(stack != NULL)
 38     {
 39         top = stack;
 40         stack = stack->next;
 41         *x = stack->x;
 42         *y = stack->y;
 43         free(top);
 44         return stack;
 45     }
 46     else
 47         *x = -1;
 48 }
 49 
 50 
 51 int main()
 52 {
 53     int maze[7][10]={
 54         1,1,1,1,1,1,1,1,1,1,
 55         1,0,1,0,1,0,0,0,0,1,
 56         1,0,1,0,1,0,1,1,0,1,
 57         1,0,1,0,1,1,1,0,0,1,
 58         1,0,1,0,0,0,0,0,1,1,
 59         1,0,0,0,1,1,1,0,0,1,
 60         1,1,1,1,1,1,1,1,1,1,
 61     };
 62     
 63     int i,j;
 64     int x = 5;
 65     int y = 8;
 66     
 67     while(x != 1 || y!= 1)
 68     {
 69         maze[x][y] = 2;
 70         if(maze[x-1][y] <= 0)
 71         {
 72             x = x -1;
 73             path = push(path,x,y);
 74         }
 75         else
 76             if(maze[x+1][y] <= 0)
 77             {
 78                 x = x + 1;
 79                 path = push(path,x,y);
 80             }
 81             else
 82                 if(maze[x][y-1] <= 0)
 83                 {
 84                     y = y - 1;
 85                     path = push(path,x,y);
 86                 }
 87                 else
 88                     if(maze[x][y] <= 0)
 89                     {
 90                         y = y + 1;
 91                         path = push(path,x,y);
 92                     }
 93                     else
 94                     {
 95                         maze[x][y] = 3;
 96                         path = pop(path,&x,&y);
 97                     }
 98     }
 99     maze[y][y] = 2;
100     printf("迷宫的路径如下图所示：\n");
101     for(i = 1;i < 6;i++)
102     {
103         for(j = 1;j < 9;j++)
104             printf("%d",maze[i][j]);
105         printf("\n");
106     }
107 
108     return 0;
109 }

 

posted @ 2020-12-29 19:03  互联星空  阅读(314)  评论(0)    收藏  举报