数据结构与算法分析（7）表、栈和队列（二）

    介绍栈的相关知识:

    (2)栈ADT:

    2.1栈模型:

      栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶（top）。对栈的基本操作有Push(进栈)和Pop(出栈)，前者相当于插入，后者则是删除最后插入的元素。

      栈有时又叫做LIFO(后进先出表)。一般的栈模型是，存在某个元素位于栈顶，而该元素是唯一可见元素。

      

    2.2栈的实现:

      由于栈是一个表，所以任何实现表的方法都可以实现栈，我们将给出两种方法，一个使用指针，一个使用数组。

      1)栈的链表实现:

      栈的链表实现的例程:

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

int IsEmpty(Stack s);
Stack CreateStack(void);
void DisposeStack(Stack s);
void MakeEmpty(Stack s);
void Push(ElementType x,Stack s);
ElementType Top(Stack s);
void Pop(Stack s);

struct Node{
  ElementType Element;
  PtrToNode Next;
};

      栈的链表实现的简单实例:

      编写程序，从键盘输入10个数据放入栈中，然后从栈中依次弹出这些数据，并输出。

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
 
struct Node{
  int Element;
  struct Node* Next;      
};
//定义一个指向结点类型变量的指针类型 
typedef struct Node *Stack;
Stack creatStack(){
    Stack s;
    s=malloc(sizeof(struct Node));
    if(s==NULL)
      printf("Out of space!");
    s->Next=NULL;
    return s;
}
void Push(int n,Stack s){
    struct Node *temp;
    temp=malloc(sizeof(struct Node));
    if(temp==NULL)
      printf("Out of Space!");
    else{
        temp->Element=n;
        temp->Next=s->Next;
        s->Next=temp; 
    }
}
int IsEmpty (Stack s){
    return s->Next==NULL;
}
int Top(Stack s){
    struct Node *temp;
    if(IsEmpty(s)){
      printf("Empty stack");
      return 0;        
    }
    else
    return s->Next->Element;
}
void Pop(Stack s){
  struct Node *temp;
  if(IsEmpty(s))
    printf("Empty stack");
  else
    temp=s->Next;
    s->Next=s->Next->Next;
    free(temp);    
}
void MakeEmpty(Stack s){
    if(s==NULL){
        printf("此栈为空，必须先创建一个栈!
");
    }else{
        while(!IsEmpty(s)){
            Pop(s);
        }
    }
} 
int main(){
    printf("请输入10个整数，压入栈中:
");
    Stack s;
    s=creatStack();
    int temp;
    int k;
    for(k=0;k<10;k++){
        //printf("请输入第%d个数
",k+1);
        temp=rand()%100;
        printf("Num[%d]=%2d  ",k+1,temp);  
        Push(temp,s);   
    }    
    printf("
下面按照顺序弹出栈中所有元素并输出:
");
    for(k=0;k<10;k++){
      printf("第%2d个出栈的是%4d",k+1,s->Next->Element);
      if((k+1)%5==0){
          printf("
");
      } 
      Pop(s);        
    }
    return 0;
}

      2)栈的数组实现:

      栈的数组实现避免了指针并且可能是更加流行的解决方案。这种策略的唯一潜在危害是我们需要提前声明一个数组的大小。

      栈的数组实现中一个很大的问题是对空栈的Pop和对满栈的Push都将超出数组的界限并引起程序的崩溃，因此有时可能需要防止用于构造栈的数组的下标越界。

      栈的数组实现的例程:

#include<stdlib.h>
#include<stdio.h>

struct StackRecord;
typedef struct StackRecord *Stack;
typedef int ElementType;

int IsEmpty(Stack s);
int IsFull(Stack s);
Stack CreateStack(int MaxElements);
void  DisposeStack(Stack s);
void MakeEmpty(Stack s);
void Push(ElementType x,Stack s);
ElementType Top(Stack s);
void Pop(Stack s);
ElementType TopAndPop(Stack s);

#define EmptyTOS (-1)
#define MinStackSize (5)
struct StackRecord{
  int Capacity;
  int TopOfStack;
  ElementType *Array; 
};
void MakeEmpty(Stack s){
    s->TopOfStack=EmptyTOS;
}
int IsFull(Stack s){
    return s->TopOfStack==s->Capacity;
}
Stack CreateStack(int MaxElements){
    Stack s;
    if(MaxElements<MinStackSize){
        printf("所建的栈空间太小");
        MaxElements=5;
    }
    s=malloc(sizeof(struct StackRecord));
    s->Array=malloc(sizeof(ElementType)*MaxElements);
    s->Capacity=MaxElements;
    MakeEmpty(s);    
    return s;
}
void DisposeStack(Stack s){
    if(s!=NULL){
        free(s->Array);
        free(s);
    }
}
int IsEmpty(Stack s){
    return s->TopOfStack==EmptyTOS;
}
void Push(ElementType x,Stack s){
    if(!IsFull(s)){
      printf("栈空间已经用完了");
    }
    else
      s->Array[++s->TopOfStack]=x;
}
ElementType Top(Stack s){
    if(!IsEmpty(s))
      return s->Array[s->TopOfStack];
    printf("空栈");
    return 0;
}
void Pop(Stack s){
    if(IsEmpty(s))
        printf("空栈");
    else
        s->TopOfStack--;    
}
ElementType    TopAndPop(Stack s){
    if(!IsEmpty(s))
      return s->Array[s->TopOfStack--];
    printf("空栈");
    return 0;
}

      栈的数组实现的实例在此就不做介绍了，下面的后缀表达式的实例涉及到了。

    2.4栈的应用: 

      1)平衡符号:

        编译器检查你的程序的语法错误，但是常常由于缺少一个符号（如遗漏一个花括号或者注释起始符）引起编译器列出上百行的诊断，而真正的错误却没有找出。

        在这种情况下一个有用的工具就是检验是否每件事情都能成对出现的一个程序:

        做一个空栈。读入字符指到文件尾，如果字符是一个开放的符号，则将推入栈中。如果是一个封闭符号，则当栈为空时报错，否则将栈元素推出。在文件尾，如果栈非空则报错。

      2)后缀表达式:

       主要包括后缀表达式的计算和中缀到后缀的转换:  

　　 编写程序，从键盘输入一个中缀表达式，利用栈先转换为后缀表达式，然后计算该后缀表达式的结果，要求

　　（1）用栈的数组实现完成

　　（2）为简单起见，表达式中的操作数为非负整数

　　（3）操作符仅包括加（+）、乘（*）、左括号（、右括号）

　　（4）若后缀表达式正确，输出计算结果；若表达式有误，输出错误提示信息

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define EmptyTOS (-1)
#define MinStackSize 5
 
struct StackRecord{
  int Capacity;//能存元素最大量
  int TopOfStack;//记录新插入的元素所在数组中的位置
  char Array[20][5];//字符串数组，每个字符串的大小最多为5 
};
typedef struct StackRecord *Stack;

void MakeEmpty(Stack s){
    s->TopOfStack=EmptyTOS;
}

Stack CreateStack(int MaxElement){
    Stack s;  
    if(MaxElement<MinStackSize){
        printf("要创建的栈太小，应大于5。
");
        exit(0); 
    }else{        
      s=malloc(sizeof(struct StackRecord));
      s->Capacity=MaxElement;
      MakeEmpty(s);    
    }
    return s; 
}

//判断栈是否为空栈 
int isEmpty(Stack S){
    return S->TopOfStack==EmptyTOS; 
}
//判断是否满了，当为1是满了，为0是表示未满 
int IsFull(Stack S){
    if(S->TopOfStack+1>=S->Capacity){
        return 1;
    }else
    return 0;
}
//压栈 
void Push(char *x,Stack S){
 if(IsFull(S)){
     printf("栈已经满了！
");
 }else{
     strcpy(S->Array[++S->TopOfStack],x);
 }     
}
//只获得头元素 
char *Top(Stack S){
    if(isEmpty(S)){
        printf("此栈为空，无法取栈头元素!
");
        exit(0);
    }else{
        return S->Array[S->TopOfStack]; 
    }
}
//只删除头元素 
void Pop(Stack S){
    if(isEmpty(S)){
        printf("此栈为空，无法去除栈头元素!
");
    }else{
        S->TopOfStack--; 
    }
}
//获取头元素并删除 
char *PopAndTop(Stack S){
    if(isEmpty(S)){
        printf("此栈为空，无法执行获取栈头元素和去除栈头元素!
");
        exit(0);
    }else{
        return S->Array[S->TopOfStack--];
    }
}
//释放栈空间 
void DisposeStack(Stack s){
    if(s!=NULL){
        free(s); 
    }
} 
void printStack(Stack s){
    int i;
    for(i=0;i<=s->TopOfStack;i++){
        printf("%s ",s->Array[i]);
    }    
}

int isNumber(char p){
    if(p>='0'&&p<='9'){
      return 1;    
    }else
    return 0;
}
int isOperator(char *p){     
    //当长度为1，且不为从0到9的数时，才是操作符 
    if(isNumber(p[0])){
        return 0;
    }else
    return 1; 
} 
int exist(char *p,Stack temp){
    int i;
    for(i=0;i<=temp->TopOfStack;i++){
        if(strcmp(temp->Array[i],p)==0){
            return 1;
        }
    }
    return 0;
}
//位置是从栈头开始计算，所以谁小谁离栈比较远 
int LastPosition(char *p,Stack temp){
    int i;
    if(exist(p,temp)){
      for(i=temp->TopOfStack;i>=0;i--){
        if(strcmp(temp->Array[i],p)){
            return i;
        }
      }    
    }
    else{
      //这个应该执行不到 
      //printf("临时栈没有%s这个操作符
",p); 
    }
}
void turnInto(Stack A,Stack B){
    Stack temp=CreateStack(10);
    int i;
    for(i=0;i<=A->TopOfStack;i++){
        //如果不是操作符，直接输出到后缀表达式 
        if(!isOperator(A->Array[i])){
            strcpy(B->Array[++B->TopOfStack],A->Array[i]);
            //printf("输出中存的有:%s
",A->Array[i]);
        }else{
            char c=A->Array[i][0];
        //当是操作符时，有可能是右括号 
            if(c==')'){
                //printStack(temp);
                //当两个字符串不相等时 
                while(!strcmp( "(",Top(temp) )==0){
                  strcpy(B->Array[++B->TopOfStack],PopAndTop(temp));
                  //printf("输出中存的有:%s
",B->Array[B->TopOfStack]);    
                }
                Pop(temp);
            }else if(c=='('){
                //Push("(",temp);
                //printf("%s",A->Array[i]);
                Push(A->Array[i],temp);
            }else if(c=='+'){
                //如果临时栈中有乘号
                if(exist("*",temp)){
                    //printStack(temp); 
                    //当没有左括号或者有，但左括号在乘号的左边 
                    if( !exist("(",temp) || ( exist("(",temp)&& LastPosition("(",temp)>LastPosition("*",temp) ) ){
                        //printf("%d<%d",LastPosition("(",temp),LastPosition("*",temp));
                        //将乘号及以后的操作符输出到后缀表达式 
                        while(Top(temp)[0]!='*'){
                          //printf("%s",Top(temp));
                          strcpy( B->Array[++B->TopOfStack],PopAndTop(temp) );
                          //printf("输出中存的有:%s
",A->Array[i]);
                        }
                        strcpy(B->Array[++B->TopOfStack],PopAndTop(temp));
                        //printf("输出中存的有:%s
",B->Array[B->TopOfStack]);
                        Push(A->Array[i],temp);
                        //printStack(temp); 
                    }else
                    Push(A->Array[i],temp);
                }
                else{
                  //如果不存在乘号 
                  Push(A->Array[i],temp);    
                }                
           }else if(c=='*'){
            strcpy(temp->Array[++temp->TopOfStack],A->Array[i]);    
           }            
        }
    }
    while(!isEmpty(temp)){
        strcpy(B->Array[++B->TopOfStack],PopAndTop(temp)); 
    }    
}

void calculate(Stack A){
    //定义一个辅助计算后缀表达式的栈 
    Stack as=CreateStack(10);
    int result,i;
    int a,b,temp;
    char str[5];
    for(i=0;i<=A->TopOfStack;i++){
        //printf("%s
",A->Array[i]);
        if(isNumber(A->Array[i][0])){
            Push(A->Array[i],as);
        }else{
            int a=atoi(PopAndTop(as));
            int b=atoi(PopAndTop(as));
            char c=A->Array[i][0];
            //putchar(c);
            switch(c){
                case '+':temp=a+b;break;
                case '*':temp=a*b;break;
                default:printf("不知名错误!
");
            }
            itoa(temp,str,10);
            Push(str,as);
         }    
    }

    if(as->TopOfStack<=0){
        strcpy(str,Top(as));
        result=atoi(str);
        printf("计算的结果为:%3d
",result); 
    }
}

int main(){
    printf("请输入一个中缀表达式(最多30个字符的字符串)，只包含非负整数，+号，-号和（）两个括号！
");
    Stack s_center=CreateStack(20);
    Stack s_later=CreateStack(20); 
    char x[30];
    gets(x);
    int i=0;
    //用于提取有多个位数的数字，或操作符 
    char temp[5];
    int flag; 
    while(x[i]!=''){
        flag=-1;
        while(isNumber(x[i])){
          temp[++flag]=x[i];
          temp[flag+1]='';
          i++;
        }
        Push(temp,s_center);
        //printf("temp=%s
",temp); 
        while(!isNumber(x[i])){
              if(x[i]!=''){
              temp[0]=x[i];
              temp[1]='';
              i++;
              Push(temp,s_center);    
                //printf("temp=%s
",temp);
            }else{
                break;
            }    
        } 
    }
    printf("此中缀表达式为:
"); 
    printStack(s_center);
    //将中缀表达式转化为后缀表达式 
    turnInto(s_center,s_later);
    printf("
这个后缀表达式是:
");
    printStack(s_later);
    printf("
");
    calculate(s_later);
    return 0;
} //这里的所有用来输出的被注释掉的语句都是调试用的。

      这里只是简单的介绍包括+,*,(,)的运算，以后还会将四则运算全部解决，敬请期待。

      3)函数调用

      检测平衡符号的算法提供一种实现函数调用的方法。当主调函数调用被调函数时，系统需要将主调例程中的所有局部变量存起来以防止被被调函数的变量覆盖，而且还要记录主调函数的位置，以便被掉函数运行完时知道向哪里转移。在这里函数调用和函数返回就类似与开括号和闭括号。

      函数调用问题的过程所有的工作都可以由一个栈来完成，所存储的信息或称为活动记录（activation record），或叫做栈帧（stack frame）。

      在这里我们简要了解，如果以后的工作需要用到单片机，汇编语言，计算机组成原理和编译原理时，我会深入探讨这个问题。