GDPU 数据结构 天码行空4

堆栈的应用

一、实验目的

1．掌握堆栈的存储方式和基本操作
2．掌握堆栈后进先出运算原则在解决实际问题中的应用

二、实验内容

1. 用栈结构，编写程序将十进制数转换成N制数（N可以为2、4、8、16等）。
   说明:十进制数值转换成二进制使用辗转相除法将一个十进制数值转换成二进制数值。即用该十进制数值除以2，并保留其余数；重复此操作，直到该十进制数值为0为止。最后将所有的余数反向输出就是所对应的二进制数值。十进制数值转换成八进制算法类似。转换算法要求用一个函数完成。

2. 设算术表达式中允许包含两种括号:圆括号和方括号，其嵌套的顺序随意，即（[][]）或[（）]等为正确格式，而[(]或()))或 [())均为不正确的格式。请使用栈结构，写一算法检验某表达式中的括号是否匹配，并测试你的算法是否正确。测试表达式为:
   (1) (1+2)*3-1]+[((1+2]*3)-1]
   (2) [(1+2)*3-1]+[(1+2)*3-1]

三、实验源代码

1. 进制转换

注意：最大支持36进制
🌸 头文件 Stack.h

#include 
#include 
#include 
#define MaxStackSize  100
typedef int ElemType;

typedef struct {
    ElemType stack[MaxStackSize];
    int top;
} SequenceStack;

void StackInitiate(SequenceStack *S) { /*初始化顺序堆栈S*/
    S->top = 0;/*定义初始栈顶下标值*/
}

int StackNotEmpty(SequenceStack S)
/*判顺序堆栈S非空否，非空则返回1，否则返回0*/
{
    if (S.top <= 0)    return 0;
    else return 1;
}
int StackPush(SequenceStack *S, ElemType x)
/*把数据元素值x压入顺序堆栈S，入栈成功则返回1，否则返回0*/
{
    if (S->top >= MaxStackSize) {
        printf("堆栈已满无法插入! \n");
        return 0;
    } else {
        S->stack[S->top] = x;
        S->top ++;
        return 1;
    }
}



int StackPop(SequenceStack *S, ElemType *d)
/*弹出顺序堆栈S的栈顶数据元素值到参数d ，出栈成功则返回1，否则返回0*/
{
    if (S->top <= 0) {
        printf("堆栈已空无数据元素出栈! \n");
        return 0;
    } else {
        S->top --;
        *d = S->stack[S->top];
        return 1;
    }
}

int StackTop(SequenceStack S, ElemType *d)
/*取顺序堆栈S的当前栈顶数据元素值到参数d ，成功则返回1，否则返回0*/
{
    if (S.top <= 0)
    {
        printf("堆栈已空! \n");
        return 0;
    }
    else
    {
        *d = S.stack[S.top - 1];
        return 1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

🌸 主文件

#include "Stack.h"

void conversion(int n, int m) {
    SequenceStack S;
    int e;
    StackInitiate(&S);
    while (n != 0) {
        StackPush(&S, n % m);
        n = n / m;
    }
    while (StackNotEmpty(S)) {
        StackPop(&S, &e);
//        if (e >= 36)
//            printf("%c", 65 + (e - 36));
        if (e >= 10)
            printf("%c", 97 + (e - 10));
        else
            printf("%d", e);
    }
    printf("\n");
}

int main() {
    int n, m;
    printf("请输入十进制数及要转换的进制(输入 0 0 结束):\n");
    while (1) {
        scanf("%d%d", &n, &m);
        if (n == 0 && m == 0)
            break;
        conversion(n, m);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2. 扩号匹配

🌸 头文件 Stack.h

#include 
#include 
#include 
#define MaxStackSize  100
typedef char ElemType;

typedef struct {
    ElemType stack[MaxStackSize];
    int top;
} SequenceStack;

void StackInitiate(SequenceStack *S) { /*初始化顺序堆栈S*/
    S->top = 0;/*定义初始栈顶下标值*/
}

int StackNotEmpty(SequenceStack S)
/*判顺序堆栈S非空否，非空则返回1，否则返回0*/
{
    if (S.top <= 0)    return 0;
    else return 1;
}
int StackPush(SequenceStack *S, ElemType x)
/*把数据元素值x压入顺序堆栈S，入栈成功则返回1，否则返回0*/
{
    if (S->top >= MaxStackSize) {
        printf("堆栈已满无法插入! \n");
        return 0;
    } else {
        S->stack[S->top] = x;
        S->top ++;
        return 1;
    }
}



int StackPop(SequenceStack *S, ElemType *d)
/*弹出顺序堆栈S的栈顶数据元素值到参数d ，出栈成功则返回1，否则返回0*/
{
    if (S->top <= 0) {
        printf("堆栈已空无数据元素出栈! \n");
        return 0;
    } else {
        S->top --;
        *d = S->stack[S->top];
        return 1;
    }
}

int StackTop(SequenceStack S, ElemType *d)
/*取顺序堆栈S的当前栈顶数据元素值到参数d ，成功则返回1，否则返回0*/
{
    if (S.top <= 0)
    {
        printf("堆栈已空! \n");
        return 0;
    }
    else
    {
        *d = S.stack[S.top - 1];
        return 1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

🌸 主文件

#include "Stack.h"

/*判断有n个字符的字符串exp左右括号是否配对正确*/
void ExpIsCorrect(char exp[])
{
    SequenceStack myStack;                   /*定义链式堆栈*/
    int i;
    char c;
    int n = strlen(exp);
    StackInitiate(&myStack);
    for(i = 0; i < n; i++)
    {
        if((exp[i] == '(') || (exp[i] == '[') || (exp[i] == '{'))
            StackPush(&myStack, exp[i]);
        else if((exp[i] == ')') || (exp[i] == ']') || (exp[i] == '}')) 
        {
           if(!StackNotEmpty(myStack))        
            {
                printf("%s:右括号多于左括号！\n",exp);
                return;    
            }
            else 
                {
                    StackTop(myStack, &c);
                    if((exp[i] == ')' && c == '(') || (exp[i] == ']' && c == '[') ||(exp[i] == '}' && c == '{'))
                         StackPop(&myStack, &c);
                    else 
                      {
                       printf("%s:左右括号配对次序不正确！\n",exp);
                        return;
                        }
                }
          }   
       
    }

    if(StackNotEmpty(myStack))
        printf("%s:左括号多于右括号！\n",exp);
    else
        printf("%s:左右括号匹配正确！\n",exp);
}


int main(void)
{
    char a[] = "[(1+2)*3-1]+[((1+2]*3)-1]";
    char b[] = "[(1+2)*3-1]+[(1+2)*3-1]";
    
    ExpIsCorrect(a);
    ExpIsCorrect(b);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53