课程作业六

代码地址
[栈]{https://github.com/metamorphos/Circle/tree/master}

讲解####

在做这次作业时，参考了百度上关于栈的讲解，上次作业里完成了中缀后缀表达式的学习，这次对栈进行空间初始化和运算符优先级表的运用。
设置了一个 priority 变量进行存储栈顶元素的优先级，这在中缀转后缀的时候被使用到，并在每次的压栈出栈后，都须对新的栈顶元素进行记录其优先级。

//参数说明：  
//sta：    转换过程需使用的栈空间  
//infix：  待转换的中缀表达式  
//suffix： 存储转换后的后缀表达式  
//length： 记录后缀表达式的长度  
void infix_to_suffix(Stack *sta, char *infix, int *suffix, int *length);  
int  suffix_to_result(Stack *sta, int *suffix, int length);  
void init(Stack *sta);//栈空间初始化  
 int main()  
{   
//  freopen("in.txt", "r", stdin);  
//  freopen("out.txt", "w", stdout); //将输入输出流存储到文件中 
    Stack     sta;  
    int       length;  
    int       result;         //接受后缀表达式转换的结果  
    int       sstr[MAXSIZE];  //存储后缀表达式  
    char      istr[MAXSIZE];  //存储中缀表达式  
  
    printf("请输入以 + - * / 组成的四则运算\n);  
    scanf("%s", istr);  
  
    init(&sta); //对栈空间初始化  
    infix_to_suffix(&sta, istr, sstr, &length);  
    init(&sta); //再次对栈空间初始化  
    result = suffix_to_result(&sta, sstr, length);  
  
    printf("%d\n", result);  
//  fclose(stdin);  
//  fclose(stdout); //关闭文件夹； 
    return    0;  
}  
  
  
void infix_to_suffix(Stack *sta, char *infix, int *suffix, int *length)  
{  
    int    i;             
    int    b = 0;           //当数字是十位或以上的时候进行记录  
    int    j = 0;           //suffix数组的下标  
    int    priority = 0;      
 
    for (i = 0; i < strlen(infix); )  
    {  
        //如果是数字的话，直接放在suffix中,然后continue  
        if (infix[i] >= '0' && infix[i] <= '9')  
        {  
            b = 0;     
  
            while (infix[i] >= '0' && infix[i] <= '9')  
            {  
                b = b * 10 + (infix[i] - '0');  
                i++;  
            }  
            suffix[j] = b;  
            j++;  
            continue;  
        }  
  
        //如果是右括号的话，将栈中在左括号以上的所有运算符弹出,然后continue  
        if (infix[i] == 41)  
        {  
            while (sta->data[sta->top] != 40)  
            {  
                suffix[j] = sta->data[sta->top];  
                sta->data[sta->top] = 0;  
                sta->top--;  
                j++;  
            }  
            sta->data[sta->top] = 0;  
            sta->top--;   
            priority = table[sta->data[sta->top] % 10];  
            i++;  
            continue;  
        }  
  
        //如果是左括号的话，直接压栈  
        if (infix[i] == 40)  
        {  
            sta->top++;  
            sta->data[sta->top] = infix[i];  
            priority = table[sta->data[sta->top] % 10];  
            i++;  
            continue;  
        }  
  
        //如果只是普通的运算符，则压栈  
        if (infix[i] >= 42 && infix[i] <= 47)  
        {  
            //首先比较栈顶元素的优先级是否比入栈元素优先级要大  
            //如果是大于的话，则从栈顶将元素依次出栈后，把待入栈的元素压栈  
            if (priority >= table[infix[i] % 10])  
            {  
                while (priority >= table[infix[i] % 10] && sta->data[sta->top] != 40)  
                {  
                    suffix[j] = sta->data[sta->top];  
                    sta->data[sta->top] = 0;  
                    sta->top--;   
                    priority = table[sta->data[sta->top] % 10];  
                    j++;  
                }  
                sta->top++;  
                sta->data[sta->top] = infix[i];   
                priority = table[sta->data[sta->top] % 10];  
                i++;  
            }  
            else   
            {  
                //处理负数  
                if (infix[i] == 45 && sta->data[sta->top] == 40)  
                {  
                    b = 0;  
                    while (infix[i+1] >= '0' && infix[i+1] <= '9')  
                    {  
                        b = b * 10 + (infix[i+1] - '0');  
                        i++;  
                    }  
                    suffix[j] = b * -1;  
                    sta->data[sta->top] = 0;  
                    sta->top--;  
                    j++;  
                    i += 2;  
                    priority = table[sta->data[sta->top] % 10];  
                    continue;  
                }  
                sta->top++;  
                sta->data[sta->top] = infix[i];  
                //注意压栈后，须将新的栈顶元素的优先级记录下来  
                priority = table[sta->data[sta->top] % 10];  
                  
                i++;  
            }  
  
        }  
    }  
    while (sta->top != -1)  
    {  
        suffix[j] = sta->data[sta->top];  
        sta->top--;  
        j++;  
    }  
    *length = j;  
}  
  
  
int suffix_to_result(Stack *sta, int *suffix, int length)  
{  
    int    i;  
    int    j;  
    int    result = 0;
}

程序截图####

学习C++界面编程####

还没开始学，以后补上。