数据结构和算法分析（9）表栈和队列的实际应用（一）

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4  
  5 #define EmptyTOS (-1)
  6 #define MinStackSize 5
  7  
  8 struct StackRecord{
  9   int Capacity;//能存元素最大量
 10   int TopOfStack;//记录新插入的元素所在数组中的位置
 11   char Array[30][5];//字符串数组，每个字符串的大小最多为5 
 12 };
 13 typedef struct StackRecord *Stack;
 14 
 15 void MakeEmpty(Stack s){
 16     s->TopOfStack=EmptyTOS;
 17 }
 18 Stack CreateStack(int MaxElement){
 19     Stack s;  
 20     if(MaxElement<MinStackSize){
 21         printf("要创建的栈太小，应大于5。\n");
 22         exit(0); 
 23     }else{        
 24       s=malloc(sizeof(struct StackRecord));
 25       s->Capacity=MaxElement;
 26       MakeEmpty(s);    
 27     }
 28     return s; 
 29 }
 30 //判断栈是否为空栈 
 31 int IsEmpty(Stack S){
 32     return S->TopOfStack==EmptyTOS; 
 33 }
 34 //判断是否满了，当为1是满了，为0是表示未满 
 35 int IsFull(Stack S){
 36     if(S->TopOfStack+1>=S->Capacity){
 37         return 1;
 38     }else
 39     return 0;
 40 }
 41 //压栈 
 42 void Push(char *x,Stack S){
 43  if(IsFull(S)){
 44      printf("栈已经满了！\n");
 45  }else{
 46      strcpy(S->Array[++S->TopOfStack],x);
 47  }     
 48 }
 49 //只获得头元素 
 50 char *Top(Stack S){
 51     if(IsEmpty(S)){
 52         printf("此栈为空，无法取栈头元素!\n");
 53         exit(0);
 54     }else{
 55         return S->Array[S->TopOfStack]; 
 56     }
 57 }
 58 //只删除头元素 
 59 void Pop(Stack S){
 60     if(IsEmpty(S)){
 61         printf("此栈为空，无法去除栈头元素!\n");
 62     }else{
 63         S->TopOfStack--; 
 64     }
 65 }
 66 //获取头元素并删除 
 67 char *PopAndTop(Stack S){
 68     if(IsEmpty(S)){
 69         printf("此栈为空，无法执行获取栈头元素和去除栈头元素!\n");
 70         exit(0);
 71     }else{
 72         return S->Array[S->TopOfStack--];
 73     }
 74 }
 75 //释放栈空间 
 76 void DisposeStack(Stack s){
 77     if(s!=NULL){
 78         free(s); 
 79     }
 80 } 
 81 void printStack(Stack s){
 82     int i;
 83     for(i=0;i<=s->TopOfStack;i++){
 84         printf("%s ",s->Array[i]);
 85     }    
 86 }
 87 //位置是从栈头开始计算，所以谁小谁离栈顶比较远 
 88 int LastPosition(char *p,Stack temp){
 89     int i;
 90     if(exist(p,temp)){
 91       for(i=temp->TopOfStack;i>=0;i--){
 92         if(strcmp(temp->Array[i],p)){
 93             return i;
 94         }
 95       }    
 96     }
 97     else{
 98       printf("临时栈没有%s这个操作符\n",p);
 99       return -1; 
100     }
101 }
102 int IsNumber(char p){
103     if(p>=‘0‘&&p<=‘9‘){
104       return 1;    
105     }else
106     return 0;
107 }
108 //由于这里允许负数的存在，所以与之前的函数不同 
109 int IsOperator(char *p){//这个函数是给turnInto函数使用的 
110     //当长度不为1.肯定是数字，不是操作符 
111     if(p[1]!=‘\0‘){
112         return 0;
113     }     
114     //当长度为1，且不为从0到9的数时，才是操作符 
115     if(IsNumber(p[0])){
116         return 0;
117     }else
118     return 1; 
119 }
120 int exist(char *p,Stack temp){
121     int i;
122     for(i=0;i<=temp->TopOfStack;i++){
123         if(strcmp(temp->Array[i],p)==0){
124             return 1;
125         }
126     }
127     return 0;
128 }
129 //用这个递归提取函数明显比以前用的顺序处理要好得多 
130 void handleString(char *s,Stack    s_center){
131     //printf("即将操作的字符串%s\n",s);
132     int i=0;
133     int flag=-1;//当递归调用这个函数，上一个函数的flag会影响下一个函数的flag值，所以最好每次用时都初始化，而且函数段中每次用flag都最好先赋初值 
134     char temp[5];
135     if(s[0]==‘\0‘){
136         return;
137     }
138     if(s[i]==‘(‘&&s[i+1]==‘-‘){//处理类似1.(-34*76+21)-12或者2.(-43)+76这种形式的表达式字符串
139       flag=0; 
140       temp[flag]=‘-‘;
141       i=i+2;//i指到-号后的第一个数字 
142       while(IsNumber(s[i])){
143           temp[++flag]=s[i];
144           temp[flag+1]=‘\0‘;
145           i++;
146       }//如果数字过后的符号不是右括号，类似1 
147       if(s[i]!=‘)‘){
148           Push("(",s_center);
149           Push(temp,s_center);
150         s=s+i;
151         handleString(s,s_center); 
152       }else{//等于右括号，类似2 
153         Push(temp,s_center);
154         i++;
155         s=s+i;
156         handleString(s,s_center); 
157         }
158    } 
159    //如果字符串的开头是是数字，就将这一串数字压栈，并将数字后的第一个操作符压栈 
160      else//else不能少，这里是为了在一次调用此函数时只能执行一次操作，他们是互斥关系 
161      if(IsNumber(s[i])){
162        flag=-1;
163        while(IsNumber(s[i])){
164           temp[++flag]=s[i];
165           temp[flag+1]=‘\0‘;
166           i++;
167        }
168        Push(temp,s_center);
169        s=s+i;
170        handleString(s,s_center); 
171     }
172     else
173     if(!IsNumber(s[0])) {
174          temp[0]=s[0];
175          temp[1]=‘\0‘;
176          Push(temp,s_center);
177          handleString(s+1,s_center);
178     }
179 }
180 int Max(int a,int b){
181     return a>b?a:b;
182 } 
183 void turnInto(Stack A,Stack B){
184     Stack s_temp=CreateStack(15);
185     int i;int max;int leftbracketPosition;
186     for(i=0;i<=A->TopOfStack;i++){
187       //printStack(s_temp);printf("\n");
188       //如果不是操作符，直接输出到后缀表达式 
189       if(!IsOperator(A->Array[i])){
190         strcpy(B->Array[++B->TopOfStack],A->Array[i]);
191         //printf("输出中存的有:%s\n",A->Array[i]);
192       }else{
193         char c=A->Array[i][0];
194         //printf("\n操作的字符是第%d个%c\n",i+1,A->Array[i][0]); 
195         switch(c){
196           case ‘(‘:{
197                       Push(A->Array[i],s_temp);
198                       break;
199                    }
200           case ‘)‘:{
201                       while(!strcmp( "(",Top(s_temp) )==0){
202                         strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
203                       }
204                       Pop(s_temp);
205                       break;
206                    }
207           case ‘+‘:
208           case ‘-‘:{
209                       if(exist("(",s_temp)){//如果存在左括号，将左括号右侧全部运算符弹出 
210                         while(Top(s_temp)[0]!=‘(‘){
211                           strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
212                         }
213                       Push(A->Array[i],s_temp);          
214                       }else{//如果不存在左括号，将栈中所有元素弹出 
215                         while(!IsEmpty(s_temp)){
216                           strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));    
217                         }
218                       Push(A->Array[i],s_temp);        
219                       }
220                       break;
221                    }
222           case ‘*‘:
223           case ‘/‘:{
224                       if(IsEmpty(s_temp)){
225                           Push(A->Array[i],s_temp);
226                       }
227                       else{
228                         if(exist("(",s_temp)){
229                           leftbracketPosition=LastPosition("(",s_temp);
230                           if(exist("/",s_temp)||exist("*",s_temp)){
231                             max=Max(LastPosition("/",s_temp),LastPosition("*",s_temp));
232                           if(max>leftbracketPosition){//表明符号在左括号右侧 
233                             while(Top(s_temp)[0]!=‘*‘ || Top(s_temp)[0]!=‘/‘){
234                               strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );      
235                             }
236                             strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
237                             Push(A->Array[i],s_temp);
238                           }else{//符号在左括号左侧 
239                             Push(A->Array[i],s_temp); 
240                           }    
241                         }else{//存在左括号，但既不存在乘号也不存在除号，判断此时有没有乘方号 
242                         //如果有乘方号，且乘方号在左括号右侧 
243                           if(exist("^",s_temp)&&(LastPosition("^",s_temp)>leftbracketPosition)){
244                             strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
245                             Push(A->Array[i],s_temp);       
246                           }else{//不存在乘方号或者存在乘方号，但乘方号在左括号的左侧 
247                             Push(A->Array[i],s_temp);
248                           }        
249                         }    
250                         }else{//不存在左括号时，只要临时栈中有乘号或除号就不可能再有乘方号 
251                           if(exist("*",s_temp)||exist("/",s_temp)){
252                             while(Top(s_temp)[0]!=‘*‘&&Top(s_temp)[0]!=‘/‘){
253                             strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
254                             }
255                             strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
256                             Push(A->Array[i],s_temp);    
257                           }else{//表示既没有左括号也没有乘号或除号，此时考虑栈中有没有乘方号 
258                             if(exist("^",s_temp)){//如果有乘方号，肯定在栈顶 
259                               strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
260                               Push(A->Array[i],s_temp);       
261                             }else{
262                               Push(A->Array[i],s_temp);    
263                             } 
264                           }//不存在*或/的结束 
265                         }//不存在左括号的结束 
266                       }    
267                       break;
268                     }
269           case ‘^‘:{
270                       if(IsEmpty(s_temp)){
271                            Push(A->Array[i],s_temp);
272                       }else{                          
273                       //最高优先级，但临时栈中有可能还有乘方号，要把临时栈中与当前操作符有相同优先级的并在左括号的右边的符号弹出 
274                       if(!exist("^",s_temp)){
275                         strcpy(s_temp->Array[++s_temp->TopOfStack],A->Array[i]);
276                         break;    
277                       }else{
278                         if(exist("(",s_temp)&& ( LastPosition("(",s_temp)<LastPosition("^",s_temp) ) ){
279                             while(Top(s_temp)[0]!=‘^‘){
280                               //printf("%s",Top(temp));
281                               strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
282                               //printf("输出中存的有:%s\n",A->Array[i]);
283                             }
284                             strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp));
285                             //printf("输出中存的有:%s\n",B->Array[B->TopOfStack]);
286                             Push(A->Array[i],s_temp);
287                             //printStack(temp); 
288                         }else{//包括不存在左括号和存在左括号且左括号在^右边的情况 
289                            if(!exist("(",s_temp)){
290                              strcpy( B->Array[++B->TopOfStack],PopAndTop(s_temp) );
291                              Push(A->Array[i],s_temp);           
292                            }else 
293                              strcpy(s_temp->Array[++s_temp->TopOfStack],A->Array[i]);    
294                            }    
295                         }     
296                      } 
297                      break;             
298                   }
299           default:printf("未知错误\n");    
300         }//switch语句的结束        
301       }//如果是操作符的结束 
302     }//for循环结束 
303     while(!IsEmpty(s_temp)){
304         strcpy(B->Array[++B->TopOfStack],PopAndTop(s_temp)); 
305     }    
306 }
307 //利用斐波那契数快速求幂 
308 unsigned long FB_QiuMi(int x,int n){
309     if(n<=2){
310         //printf("不用求幂公式！\n");
311         switch(n){
312             case 1:return x;
313             case 2:return x*x;
314         }
315     }
316     //记录斐波那契数列的下标 
317     int N=0;    
318     int f=1;
319     int temp;
320     int flag=f+1; 
321     while(flag<=n){
322         temp=flag;
323         flag=flag+f;
324         f=temp;
325         N++; 
326     }
327     int less=n-temp;
328     int i;
329     unsigned long result=x;
330     flag=x;
331     for(i=0;i<N;i++){
332         temp=result;
333         result=result*flag;
334         flag=temp;
335     } 
336     while(less>0){
337         result=result*x;
338         less--;
339     }
340     return result;
341 } 
342 void Calculate(Stack A){
343     //定义一个辅助计算后缀表达式的栈 
344     Stack as=CreateStack(10);
345     long result;
346     int a,b,temp,i;
347     char str[5];
348     for(i=0;i<=A->TopOfStack;i++){
349         //printf("%s\n",A->Array[i]);
350         if(!IsOperator(A->Array[i])){
351             Push(A->Array[i],as);
352         }else{
353             int b=atof(PopAndTop(as));
354             int a=atoi(PopAndTop(as));
355             char c=A->Array[i][0];
356             //printf("a=%d,b=%d",a,b);
357             //putchar(c);printf("\n"); 
358             switch(c){
359                 case ‘+‘:temp=a+b;break;
360                 case ‘*‘:temp=a*b;break;
361                 case ‘-‘:temp=a-b;break; 
362                 case ‘/‘:temp=a/b;break;
363                 case ‘^‘:temp=FB_QiuMi(a,b);break;
364                 default:printf("不知名错误!\n");
365             }
366             ltoa(temp,str,10);
367             Push(str,as);
368             //printStack(as);
369          }    
370     }
371     if(as->TopOfStack<=0){
372         strcpy(str,Top(as));
373         result=atol(str);
374         printf("计算的结果为:%ld\n",result); 
375     }
376 }
377 int main(){
378     printf("请输入一个中缀表达式:");
379     printf("(最多40个字符的字符串，可以包含任意整数，+，-，*，/，^和（）两个括号！)\n");
380     Stack s_center=CreateStack(35);
381     Stack s_later=CreateStack(35); 
382     char x[40];
383     gets(x);
384     char *p=x;
385     handleString(p,s_center);
386     printf("此中缀表达式为:\n"); 
387     printStack(s_center);
388     //将中缀表达式转化为后缀表达式 
389     turnInto(s_center,s_later);
390     printf("\n这个后缀表达式是:\n");
391     printStack(s_later);printf("\n");
392     Calculate(s_later);
393     return 0;
394 } 

  1 /*
  2   1.在处理源码文件时，把去掉注释并去掉空行的源码输出到新建的文件中 
  3   2.在用栈处理文件字符匹配的过程中，采用栈的链表实现，链表带有头结点。
  4   3.需要进行匹配的有(),<>,{},[],//这些符号，其中/符号不在注释里时必须成对出现。
  5   4.自定义readline()从文件中读一行。 
  6 */
  7 /*5.当前注释符号中不能再次包含此符号，否则编译器会提示语法错误。*/
  8 
  9 #include <stdio.h>
 10 #include <string.h>
 11 #include <stdlib.h> 
 12 
 13 //存无注释源码的文件名 
 14 char *newfile="F:/VS/NoAnnotationSoundCode.txt";
 15 
 16 struct SymbolNode{
 17   char handlesymbol; 
 18   struct SymbolNode *Next;
 19 };
 20 
 21 typedef struct SymbolNode *Symbol;
 22 typedef struct SymbolNode *PtrToNode;
 23 typedef PtrToNode Stack;
 24 
 25 Stack createStack(){
 26   Stack symbolstack=malloc(sizeof(struct SymbolNode));
 27   symbolstack->Next=NULL;
 28   return symbolstack;
 29 }
 30 Symbol TopAndPop(Stack test_stack){
 31   PtrToNode temp=test_stack->Next;
 32   test_stack->Next=test_stack->Next->Next;
 33   return temp;
 34 }
 35 Symbol Top(Stack test_stack){
 36   return test_stack->Next;
 37 }
 38 void Push(char p,Stack test_stack){
 39   //printf("%c进栈",p);
 40   PtrToNode temp=malloc(sizeof(struct SymbolNode));
 41   temp->handlesymbol=p; 
 42   temp->Next=test_stack->Next;
 43   test_stack->Next=temp;
 44 } 
 45 void Pop(Stack test_Stack){
 46   PtrToNode temp=test_Stack->Next;
 47   test_Stack->Next=test_Stack->Next->Next;
 48   //printf("%c出栈\n",temp->handlesymbol);
 49   free(temp);
 50 }
 51 int IsEmpty(Stack test_stack){
 52   return test_stack->Next==NULL;
 53 } 
 54 int IsQuotationAround(char *p,int i){
 55   if(p[i+1]==‘\‘‘&&p[i-1]==‘\‘‘ || p[i+1]==‘\"‘&&p[i-1]==‘\"‘ ){
 56     return 1;
 57   }else
 58     return 0; 
 59 }
 60 char *Read_Line(FILE *fp){
 61   int lines=100;
 62   char *str=malloc(sizeof(char)*100);
 63   fgets(str,lines,fp);
 64   //printf("读取的字符串是%s\n",str);
 65   return str;
 66 }
 67 int totalSpaceOrTableOrAnotation(char *p){
 68   int i=0;
 69   //printf("当前操作的字符串是%sEOF\n",p);
 70   //printf("当前字符串的长度是%d\n",strlen(p));
 71   while(p[i]==‘ ‘||p[i]==‘\t‘)
 72     i++;
 73     if(p[i]==‘\n‘){//在每行一开始就是\n肯定是无效行 
 74       return 1;
 75     }else{
 76       if(p[i]==‘/‘&&p[i+1]==‘/‘)
 77         return 1;
 78       else 
 79            return 0;
 80     }
 81 }
 82 void printStack(Stack s){
 83   PtrToNode ptr=s->Next;
 84   while(ptr!=NULL){
 85     putchar(ptr->handlesymbol);
 86     ptr=ptr->Next;
 87   }
 88 } 
 89 int symbolMatch(char *p){
 90   FILE *fp;
 91   int linenumber=0;//记录行数 
 92   //首先新建一个存无注释源码的文件
 93   FILE *outputFilePoint=fopen(newfile,"w");
 94   if(outputFilePoint==NULL){
 95     printf("无法新建存源码的文件");
 96     return 0;
 97   }    
 98     Stack temp_stack=createStack(15);//用于存需要进行匹配的符号。
 99     if((fp=fopen(p,"r"))!=NULL){
100         char *p;//指向读取的每一行的字符串 
101         int i;
102         while(!feof(fp)){
103           p=Read_Line(fp);
104             //printf("%d.输出栈中的元素:",linenumber);
105           linenumber++; 
106           //printStack(temp_stack); 
107           //printf("\n");
108             if(totalSpaceOrTableOrAnotation(p)){//如果是空行或者只有注释的行，丢掉。 
109                continue;
110             }else{
111             i=0;//每一行都要重新初始化，防止上一行的对此行产生影响
112               while(!( p[i]==‘\0‘ && !IsQuotationAround(p,i) ) ){//当字符不是每行的末尾时 
113               //putchar(p[i]);
114               //处理栈中为*号的情况。
115               if(Top(temp_stack)!=NULL&&Top(temp_stack)->handlesymbol==‘*‘){
116                    if(p[i]!=Top(temp_stack)->handlesymbol){
117                    i=i+1;
118                      continue;}
119                   else{
120                      if(p[i+1]!=‘/‘){
121                         i++;
122                       continue;}
123                     else{
124                     Pop(temp_stack);
125                     i=i+2;
126                   }
127                 }           
128             }
129             //当不属于/*注释范围时。
130             //putchar(p[i]); 
131             switch(p[i]){
132               case ‘/‘://不需要压入栈中进行匹配 
133               {    
134                   if(p[i+1]==‘/‘){
135                   fputc(‘\n‘,outputFilePoint);
136                   if(!feof(fp)){//以后的为无效注释文本，忽略，开始下一行 
137                   p=Read_Line(fp);i=0;
138                   linenumber++;
139                   while(totalSpaceOrTableOrAnotation(p)){
140                     p=Read_Line(fp);
141                     linenumber++;
142                   }     
143                 }
144                 }else if(p[i+1]==‘*‘){
145                   Push(‘*‘,temp_stack);
146                   i++;
147                   }else{
148                     fputc(p[i],outputFilePoint);
149                 }
150               }break;
151               case ‘{‘:
152               {        
153                    if(!IsQuotationAround(p,i))
154                   Push(p[i],temp_stack);
155                   fputc(p[i],outputFilePoint);        
156               }break;
157               case ‘}‘:
158               {        
159                   if(!IsQuotationAround(p,i)){
160                    if(Top(temp_stack)->handlesymbol==‘{‘){
161                     Pop(temp_stack);
162                   }else
163                     printf("在源码的%d行出现错误\n",linenumber);                                    
164                   }
165                   fputc(p[i],outputFilePoint);
166               }break;
167               case ‘(‘:
168               {    
169                    if(!IsQuotationAround(p,i))
170                   Push(p[i],temp_stack);
171                   fputc(p[i],outputFilePoint);            
172               }break;
173               case ‘)‘:
174               {        
175                   if(!IsQuotationAround(p,i)){
176                   if(Top(temp_stack)->handlesymbol==‘(‘){
177                     Pop(temp_stack);
178                   }else{
179                      printf("在源码的%d行出现错误\n",linenumber);    
180                   }                                    
181                 }
182                 fputc(p[i],outputFilePoint);                        
183               }break;
184               case ‘[‘:
185               {        
186                   if(!IsQuotationAround(p,i))
187                   Push(p[i],temp_stack);
188                   fputc(p[i],outputFilePoint);                        
189                 }break;
190               case ‘]‘:
191               {        
192                   if(!IsQuotationAround(p,i)){
193                   if(Top(temp_stack)->handlesymbol==‘[‘){
194                     Pop(temp_stack);
195                   }else{
196                     printf("在源码的%d行出现错误\n",linenumber);
197                   }                                    
198                 }
199                 fputc(p[i],outputFilePoint);
200               }break;
201               default:
202                 {
203                 if(!(i>0&&p[i-1]==‘/‘&&p[i-2]==‘*‘)){
204                     fputc(p[i],outputFilePoint);    
205                   }                          
206               }
207               }//对每个字符进行处理的结束    
208              i++;                 
209              }//当字符指针没有到行尾的while语句的结束    
210         }//此行为有效行的else语句的结束 
211       }//打开文件语句的结束                                         
212     }else{
213          printf("打开文件%s失败！\n",p);
214   }
215   fclose(fp);
216   fclose(outputFilePoint);//打开文件得指针一定要关闭，否则会影响后面的读写。 
217   if(IsEmpty(temp_stack)){
218     return 1;
219   }else{
220     return 0;
221   }        
222 }
223 void printFile(char *p){
224   printf("\n--------------------%s---------------------\n",p);
225   FILE *fp=NULL;
226   if((fp=fopen(p,"r"))==NULL){
227     printf("打开文件失败");
228       exit(0); 
229   }else{
230     printf("打开文件成功!\n"); 
231     //用来存读到的东西 
232     char ch;
233     while(!feof(fp)){    
234        ch=fgetc(fp);
235       putchar(ch);
236     }
237   }
238   fclose(fp);
239 } 
240 int main(){
241   char *file="SymbolMatch.c";
242   FILE *fp=NULL;
243   //如果此源码文件没有语法错误，就打印出去掉所有注释的源码文件 
244   if(symbolMatch(file)){
245     printFile(newfile); 
246   }else{
247     printf("符号匹配出现错误！\n");
248   }
249   return 0;
250 } 

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <stdlib.h> 
  4 char *newfile="F:/VS/NoAnnotationSoundCode.txt";
  5 struct SymbolNode{
  6   char handlesymbol; 
  7   struct SymbolNode *Next;
  8 };
  9 typedef struct SymbolNode *Symbol;
 10 typedef struct SymbolNode *PtrToNode;
 11 typedef PtrToNode Stack;
 12 Stack createStack(){
 13   Stack symbolstack=malloc(sizeof(struct SymbolNode));
 14   symbolstack->Next=NULL;
 15   return symbolstack;
 16 }
 17 Symbol TopAndPop(Stack test_stack){
 18   PtrToNode temp=test_stack->Next;
 19   test_stack->Next=test_stack->Next->Next;
 20   return temp;
 21 }
 22 Symbol Top(Stack test_stack){
 23   return test_stack->Next;
 24 }
 25 void Push(char p,Stack test_stack){
 26   PtrToNode temp=malloc(sizeof(struct SymbolNode));
 27   temp->handlesymbol=p; 
 28   temp->Next=test_stack->Next;
 29   test_stack->Next=temp;
 30 } 
 31 void Pop(Stack test_Stack){
 32   PtrToNode temp=test_Stack->Next;
 33   test_Stack->Next=test_Stack->Next->Next;
 34   free(temp);
 35 }
 36 int IsEmpty(Stack test_stack){
 37   return test_stack->Next==NULL;
 38 } 
 39 int IsQuotationAround(char *p,int i){
 40   if(p[i+1]==‘\‘‘&&p[i-1]==‘\‘‘ || p[i+1]==‘\"‘&&p[i-1]==‘\"‘ ){
 41     return 1;
 42   }else
 43     return 0; 
 44 }
 45 char *Read_Line(FILE *fp){
 46   int lines=100;
 47   char *str=malloc(sizeof(char)*100);
 48   fgets(str,lines,fp);
 49   return str;
 50 }
 51 int totalSpaceOrTableOrAnotation(char *p){
 52   int i=0;
 53   while(p[i]==‘ ‘||p[i]==‘\t‘)
 54     i++;
 55     if(p[i]==‘\n‘){
 56   return 1;
 57     }else{
 58       if(p[i]==‘/‘&&p[i+1]==‘/‘)
 59         return 1;
 60       else 
 61            return 0;
 62     }
 63 }
 64 void printStack(Stack s){
 65   PtrToNode ptr=s->Next;
 66   while(ptr!=NULL){
 67     putchar(ptr->handlesymbol);
 68     ptr=ptr->Next;
 69   }
 70 } 
 71 int symbolMatch(char *p){
 72   FILE *fp;
 73   int linenumber=0;
 74  FILE *outputFilePoint=fopen(newfile,"w");
 75   if(outputFilePoint==NULL){
 76     printf("无法新建存源码的文件");
 77     return 0;
 78   }    
 79     Stack temp_stack=createStack(15);
 80    if((fp=fopen(p,"r"))!=NULL){
 81         char *p;
 82     int i;
 83         while(!feof(fp)){
 84           p=Read_Line(fp);
 85           linenumber++; 
 86             if(totalSpaceOrTableOrAnotation(p)){
 87               continue;
 88             }else{
 89             i=0;
 90              while(!( p[i]==‘\0‘ && !IsQuotationAround(p,i) ) ){
 91           if(Top(temp_stack)!=NULL&&Top(temp_stack)->handlesymbol==‘*‘){
 92                    if(p[i]!=Top(temp_stack)->handlesymbol){
 93                    i=i+1;
 94                      continue;}
 95                   else{
 96                      if(p[i+1]!=‘/‘){
 97                         i++;
 98                       continue;}
 99                     else{
100                     Pop(temp_stack);
101                     i=i+2;
102                   }
103                 }           
104             }
105             switch(p[i]){
106               case ‘/‘:
107           {    
108                   if(p[i+1]==‘/‘){
109                   fputc(‘\n‘,outputFilePoint);
110                   if(!feof(fp)){
111                    p=Read_Line(fp);i=0;
112                    linenumber++;
113                   while(totalSpaceOrTableOrAnotation(p)){
114                     p=Read_Line(fp);
115                     linenumber++;
116                   }     
117                 }
118                 }else if(p[i+1]==‘*‘){
119                   Push(‘*‘,temp_stack);
120                   i++;
121                   }else{
122                     fputc(p[i],outputFilePoint);
123                 }
124               }break;
125               case ‘{‘:
126               {        
127                    if(!IsQuotationAround(p,i))
128                     Push(p[i],temp_stack);
129                     fputc(p[i],outputFilePoint);        
130               }break;
131               case ‘}‘:
132               {        
133                   if(!IsQuotationAround(p,i)){
134                    if(Top(temp_stack)->handlesymbol==‘{‘){
135                     Pop(temp_stack);
136                   }else
137                     printf("在源码的%d行出现错误\n",linenumber);                                    
138                   }
139                    fputc(p[i],outputFilePoint);
140               }break;
141               case ‘(‘:
142               {    
143                    if(!IsQuotationAround(p,i))
144                       Push(p[i],temp_stack);
145                       fputc(p[i],outputFilePoint);            
146               }break;
147               case ‘)‘:
148               {        
149                   if(!IsQuotationAround(p,i)){
150                   if(Top(temp_stack)->handlesymbol==‘(‘){
151                     Pop(temp_stack);
152                   }else{
153                      printf("在源码的%d行出现错误\n",linenumber);    
154                   }                                    
155                 }
156                 fputc(p[i],outputFilePoint);                        
157               }break;
158               case ‘[‘:
159               {        
160                   if(!IsQuotationAround(p,i))
161                   Push(p[i],temp_stack);
162                   fputc(p[i],outputFilePoint);                        
163                 }break;
164               case ‘]‘:
165               {        
166                   if(!IsQuotationAround(p,i)){
167                   if(Top(temp_stack)->handlesymbol==‘[‘){
168                     Pop(temp_stack);
169                   }else{
170                     printf("在源码的%d行出现错误\n",linenumber);
171                   }                                    
172                 }
173                 fputc(p[i],outputFilePoint);
174               }break;
175               default:
176                 {
177                 if(!(i>0&&p[i-1]==‘/‘&&p[i-2]==‘*‘)){
178                     fputc(p[i],outputFilePoint);    
179                   }                          
180               }
181               }
182             i++;                 
183              }
184     }
185   }
186    }else{
187          printf("打开文件%s失败！\n",p);
188   }
189   fclose(fp);
190   fclose(outputFilePoint);
191  if(IsEmpty(temp_stack)){
192     return 1;
193   }else{
194     return 0;
195   }        
196 }
197 void printFile(char *p){
198   printf("\n--------------------%s---------------------\n",p);
199   FILE *fp=NULL;
200   if((fp=fopen(p,"r"))==NULL){
201     printf("打开文件失败");
202       exit(0); 
203   }else{
204     printf("打开文件成功!\n"); 
205     char ch;
206     while(!feof(fp)){    
207        ch=fgetc(fp);
208       putchar(ch);
209     }
210   }
211   fclose(fp);
212 } 
213 int main(){
214   char *file="SymbolMatch.c";
215   FILE *fp=NULL;
216   if(symbolMatch(file)){
217     printFile(newfile); 
218   }else{
219     printf("符号匹配出现错误！\n");
220   }
221   return 0;
222 } 

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 struct numNode{
 4     char *Array;
 5     int Capicity;
 6     int TopOfStack; 
 7 };
 8 typedef struct numNode *PtrToNode;
 9 typedef PtrToNode Stack;
10 Stack create(int size){
11     Stack tempStack=malloc(sizeof(struct numNode));
12     if(size<20)
13       size=20;
14     tempStack->Array=malloc(sizeof(char)*size);
15     tempStack->Capicity=size;
16     tempStack->TopOfStack=-1;
17     return tempStack; 
18 }
19 char Top(Stack s){
20     return s->Array[s->TopOfStack];
21 }
22 char TopAndPop(Stack s){
23     if(s->TopOfStack<0){
24         printf("栈为空！\n");
25     }else{
26         return s->Array[s->TopOfStack--];
27     }
28 }
29 int isFull(Stack s){
30     if(s->TopOfStack+1<s->Capicity){
31         return 0;
32     }else{
33         return 1;
34     }
35 }
36 int isEmpty(Stack s){
37     return s->TopOfStack==-1; 
38 }
39 void Push(int element,Stack s){
40     if(element>16||element<0){
41         printf("出现错误"); 
42     }
43     char ch;
44     switch(element){
45         case 15:ch=‘f‘;break;
46         case 14:ch=‘e‘;break;
47         case 13:ch=‘d‘;break;
48         case 12:ch=‘c‘;break;
49         case 11:ch=‘b‘;break;
50         case 10:ch=‘a‘;break;
51         default:ch=(char)(48+element);
52     }
53     if(!isFull(s)){
54         s->Array[++s->TopOfStack]=ch; 
55     }else{
56         printf("栈空间已满！\n");
57     }
58 }
59 void Pop(Stack s){
60     s->TopOfStack--;
61 }
62 char *Conversion(long element,int n){
63     Stack tempStack=create(25);
64     //printf("%d",element); 
65     while(element){
66         Push(element%n,tempStack);
67         element=element/n;
68     }
69     char *temp;
70     int i=0;
71     temp=malloc(sizeof(char)*25);
72     while(!isEmpty(tempStack))
73         temp[i++]=TopAndPop(tempStack);
74     temp[i]=‘\0‘;
75     return temp;
76 }
77 int main(){
78     long element;
79     scanf("%d",&element);
80     printf("%d转化为2进制是:%s\n",element,Conversion(element,2));
81     printf("%d转化为8进制是:%s\n",element,Conversion(element,8));
82     printf("%d转化为10进制是:%s\n",element,Conversion(element,10));
83     printf("%d转化为16进制是:%s\n",element,Conversion(element,16));
84     return 0;
85 } 

 1 //汉诺塔问题的递归解法
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <time.h>
 5 struct HnNodeLeader{
 6   char name;    
 7   struct HnNode *Next;    
 8 }; 
 9 struct HnNode{
10     int element;
11     struct HnNode *Next;    
12 };
13 typedef struct HnNode *PtrToNode;
14 typedef struct HnNodeLeader *Stack;
15 Stack createStack(char ch){
16     Stack tempStack=malloc(sizeof(struct HnNodeLeader));
17     tempStack->name=ch;
18     tempStack->Next=NULL;
19     return tempStack;
20 }
21 void Push(int x,Stack s){
22     PtrToNode temp=malloc(sizeof(struct HnNode));
23     temp->element=x;
24     temp->Next=s->Next;
25     s->Next=temp;
26 }
27 int IsEmpty(Stack s){
28     return s->Next==NULL;
29 } 
30 PtrToNode TopAndPop(Stack s){
31     if(IsEmpty(s)){
32         return NULL;
33     }
34     PtrToNode temp=s->Next;
35     s->Next=s->Next->Next;
36     return temp;
37 }
38 PtrToNode Top(Stack s){
39     return s->Next;
40 }
41 int TotalNumOfStack(Stack s){
42     PtrToNode temp=s->Next;
43     int i=0;
44     while(temp!=NULL){
45         i++;
46         temp=temp->Next;
47     }
48     return i;
49 } 
50 void Move(Stack local,Stack target){
51     Push(TopAndPop(local)->element,target);
52 }
53 void printAndFreeStack(Stack temp){
54     int i=0;
55     while(!IsEmpty(temp)){
56         printf("%4d",TopAndPop(temp)->element);
57         i++;
58         if(i%20==0){
59             printf("\n");
60         }
61     }
62 }
63 //把a栈中的n个元素通过b栈送到c栈上 
64 void TransferHanNoi(int n,Stack a,Stack b,Stack c){
65     if(n==1){
66         Move(a,c);
67         printf("圆盘%2d从栈%c移动到栈%c\n",Top(c)->element,a->name,c->name);
68         return;
69     }
70     TransferHanNoi(n-1,a,c,b);//把n-1个元素从a移动到b 
71     Move(a,c);//再把a中的一个元素移动到c中。 
72     printf("圆盘%2d从栈%c移动到栈%c\n",Top(c)->element,a->name,c->name);
73     TransferHanNoi(n-1,b,a,c);//再移动b中的所有元素到c中 
74 }
75 int main(){
76     srand(time(NULL));
77     //数值太大，非常耗时间。所以测试数要非常小。 
78     int testNum=rand()%13+1;
79     printf("测试汉诺塔圆盘数为%d时候的转移问题:\n",testNum);
80     Stack A=createStack(‘A‘);
81     Stack B=createStack(‘B‘);
82     Stack C=createStack(‘C‘);
83     int i;
84     for(i=1;i<=testNum;i++){
85         Push(i,A);
86     }
87     TransferHanNoi(TotalNumOfStack(A),A,B,C);
88     printAndFreeStack(C);    
89     return 0;
90 } 

  1 //用循环链表 
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <time.h>
  5 
  6 struct PersonNode{
  7     int Num;
  8     struct PersonNode *Next;
  9 };
 10 typedef struct PersonNode *List;
 11 typedef struct PersonNode *PtrToNode;
 12 
 13 List createList(){
 14     List tempList=malloc(sizeof(struct PersonNode));
 15     tempList->Next=NULL;
 16     return tempList;
 17 }
 18 int IsEmpty(List list){
 19     if(list->Next==NULL)
 20         return 1;
 21     else
 22         return 0;
 23 } 
 24 void InsertIntoList(int n,List list){
 25     //创建临时结点 
 26     PtrToNode temp=malloc(sizeof(struct PersonNode));
 27     temp->Num=n;
 28     //找到位置
 29     if(IsEmpty(list)){
 30         list->Next=temp;
 31         temp->Next=list->Next;
 32         return;
 33     } 
 34     PtrToNode p1=list->Next;
 35     while(p1->Next!=list->Next){
 36         p1=p1->Next;
 37     }
 38     temp->Next=list->Next;
 39     p1->Next=temp;
 40 }
 41 int ClearProcess(List list,int M){
 42     int flag=1;
 43     if(IsEmpty(list)){
 44         printf("表为空!\n");
 45         return -1; 
 46     }
 47     int i;
 48     PtrToNode ptr=list->Next;
 49     //当循环链表中元素不止一个时，继续删除 
 50     while(ptr!=ptr->Next){
 51         //当M=0时，找到当前结点前一个 
 52         if(M==0){    
 53           PtrToNode p=ptr->Next;
 54           while(p->Next!=ptr)
 55               p=p->Next;
 56           ptr=p;    
 57         }else{
 58           for(i=0;i<M-1;i++)
 59             ptr=ptr->Next;    
 60         }
 61         //处理过程 
 62           PtrToNode temp=ptr->Next;
 63         ptr->Next=ptr->Next->Next;
 64         printf("%2d.游戏者%2d出局!  ",flag,temp->Num);
 65         if(flag%5==0)
 66             printf("\n");
 67         flag++;
 68            free(temp);
 69         ptr=ptr->Next;  
 70     }
 71     return ptr->Num;
 72 }
 73 void printList(List list){
 74     int flag=0;
 75     if(IsEmpty(list)){
 76       printf("链表为空");
 77       return;
 78     }
 79     PtrToNode ptr=list->Next;
 80     while(ptr->Next!=list->Next){
 81         flag++;
 82         printf("%3d",ptr->Num);
 83         ptr=ptr->Next;
 84         if(flag%30==0)
 85           printf("\n");
 86     }
 87     printf("%3d",ptr->Num);
 88     printf("\n");
 89 }
 90 int main(){
 91     srand(time(NULL));
 92     int N,M;
 93     int i;
 94     N=rand()%100+1;//人数不超过100
 95     M=rand()%50;//传递次数
 96     List list=createList();
 97     for(i=0;i<N;i++){
 98         InsertIntoList(i+1,list);
 99     }
100     printf("N的大小为%d,M的大小为%d\n",N,M);
101     //printList(list);
102     int winerNum=ClearProcess(list,M); 
103     printf("\n获胜者是%d",winerNum);
104     return 0;
105 }