Day five 栈和部分应用

于 2022-05-10 20:09:51 发布
阅读量99 收藏
点赞数
文章标签： p2p c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64154426/article/details/124696065
版权

一、栈的基本功能

1.建立

typedef struct CharStack{
    int top;
    
    char data[10];
} *CharStackPtr;


2.初始化

CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;
    
    return resultPtr;
}


3.压栈

void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}


4.出栈

char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}


5.总代码

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharStack{
    int top;
    
    char data[10];
} *CharStackPtr;
 
/**
 *输出
 */
 
void outputStack(CharStackPtr paraStack) {
    int i; 
    for (i = 0; i <= paraStack->top; i ++) {
        printf("%c ", paraStack->data[i]);
    }
    printf("\n");
} 
 
/**
 *初始化
 */
 
CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}
 
/**
 *出栈
 */
 
char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}
 
void pushPopTest() {
    char ch;
    int i;
    
    printf("---- pushPopTest begins. ----\n");
    
    CharStackPtr tempStack = charStackInit();
    printf("After initialization, the stack is: ");
    outputStack(tempStack);
    
    for (ch = 'a'; ch < 'm'; ch ++) {
        printf("Pushing %c.\n", ch);
        push(tempStack, ch);
        outputStack(tempStack);
    }
    
    for (i = 0; i < 3; i ++) {
        ch = pop(tempStack);
        printf("Pop %c.\n", ch);
        outputStack(tempStack);
    }
    
    printf("---- pushPopTest ends. ----\n");
}
 
 
int main() {
    pushPopTest();
    
    return 0;
}
运行结果

二、 括号匹配

差别不大直接总代码

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharStack{
    int top;
    
    char data[10];
} *CharStackPtr;
 
/**
 *输出
 */
 
void outputStack(CharStackPtr paraStack) {
    int i; 
    for (i = 0; i <= paraStack->top; i ++) {
        printf("%c ", paraStack->data[i]);
    }
    printf("\n");
} 
 
/**
 *初始化
 */
 
CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}
 
/**
 *出栈
 */
 
char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}
 
int bracketMatching(char *paraString, int paraLength) {
    int i;
    
    CharStackPtr tempStack = charStackInit();
    push(tempStack, '#');
    char tempChar, tempPopedChar;
    
    for (i = 0; i < paraLength; i ++) {
        tempChar = paraString[i];
        
        switch(tempChar) {
            case '(':
            case '[':
            case '{':
                push(tempStack, tempChar);
                break;
            case ')':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '(') {
                    return 0;
                }
                break;
            case ']':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '[') {
                    return 0;
                }
                break;
            case '}':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '{') {
                    return 0;
                }
                break;
            default:
                break;
        }
    }
    
    tempPopedChar = pop(tempStack);
    if (tempPopedChar != '#') {
        return 0;
    }
    
    return 1;
}
 
void bracketMatchingTest() {
    char *tempExpression = "[2 + (1 - 3)] * 4";
    int tempMatch = bracketMatching(tempExpression, 17);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "( )  )";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "()()(())";
    tempMatch = bracketMatching(tempExpression, 8);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "({}[])";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = ")(";
    tempMatch = bracketMatching(tempExpression, 2);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
}
 
int main() {
    bracketMatchingTest();
    
    return 0;
}

运行结果

三、表达式求值

1、创建

typedef struct CharAndIntStack{
    int topInt;
    int topChar;
    
    int dataInt[100];
    char dataChar[100];
} *CharAndIntStackPtr;
 

2、压栈

void pushInt(CharAndIntStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->topInt >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topInt ++;
    
    paraStackPtr->dataInt[paraStackPtr->topInt] = paraValue;
}
 
void pushChar(CharAndIntStackPtr paraStackPtr, char paraValue) {
    if (paraStackPtr->topChar >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topChar ++;
    
    paraStackPtr->dataChar[paraStackPtr->topChar] = paraValue; 
}
 

3、出栈

int popInt(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topInt < 0) {
        printf("Cannot pop element: stack empty.\n");
        return 0;
    }
    
    paraStackPtr->topInt --;
    
    return paraStackPtr->dataInt[paraStackPtr->topInt + 1];
}
 
char popChar(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->topChar --;
    
    return paraStackPtr->dataChar[paraStackPtr->topChar + 1];
}



4、计算

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharAndIntStack{
    int topInt;
    int topChar;
    
    int dataInt[100];
    char dataChar[100];
} *CharAndIntStackPtr;
 
/**
 *初始化
 */
  
CharAndIntStackPtr charandintStackInit() {
    CharAndIntStackPtr resultPtr = (CharAndIntStackPtr)malloc(sizeof(struct CharAndIntStack));
    
    resultPtr->topChar = -1;
    resultPtr->topInt = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void pushInt(CharAndIntStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->topInt >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topInt ++;
    
    paraStackPtr->dataInt[paraStackPtr->topInt] = paraValue;
}
 
void pushChar(CharAndIntStackPtr paraStackPtr, char paraValue) {
    if (paraStackPtr->topChar >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topChar ++;
    
    paraStackPtr->dataChar[paraStackPtr->topChar] = paraValue; 
}
 
/**
 *出栈
 */
 
int popInt(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topInt < 0) {
        printf("Cannot pop element: stack empty.\n");
        return 0;
    }
    
    paraStackPtr->topInt --;
    
    return paraStackPtr->dataInt[paraStackPtr->topInt + 1];
}
 
char popChar(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->topChar --;
    
    return paraStackPtr->dataChar[paraStackPtr->topChar + 1];
}
 
/**
 *优先级
 */
 
int Priority(char temp) {
    if (temp == '+' || temp == '-') {
        return 1;
    } else if (temp == '*' || temp == '/') {
        return 2;
    } else {
        return 0;
    }
} 
 
/**
 *判断数字
 */
  
int judgenumber(char temp) {
    if (temp >= '0' && temp <= '9') {
        return 1;
    } else {
        return 0;
    }
}
 
/**
 *计算
 */
 
void compute(CharAndIntStackPtr tempStack) {
    int b = popInt(tempStack);
    int a = popInt(tempStack);
    char c = popChar(tempStack);
    int x;
    if (c == '+') {
        x = a + b;
    } else if (c == '-') {
        x = a - b;
    } else if (c == '*') {
        x = a * b;
    } else {
        x = a / b;
    }
    pushInt(tempStack, x);
}
 
/**
 *判断符号剩余
 */
  
int judgeSize(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar == -1) {
        return 0;
    }
    
    if (paraStackPtr->dataChar[paraStackPtr->topChar] != '\0') {
        return 1;
    } else {
        return 0;
    }
}
 
int main() {
    CharAndIntStackPtr tempStack = charandintStackInit();
    char test[100];
    gets(test);
    
    int testLength = 0, i;
    for (i = 0; test[i] != '\0'; i ++) {
        testLength ++;
    }
    
    for (i = 0; i < testLength; i ++) {
        char c = test[i];
        
        if (judgenumber(c) == 1) {
            int x = 0, j = i;
            while (j < testLength && judgenumber(test[j])) {
                x = x * 10 + test[j ++] - '0';
            }
            i = j - 1;
            pushInt(tempStack, x);
        } else if (c == '(') {
            pushChar(tempStack, c);
        } else if (c == ')') {
            while (tempStack->dataChar[tempStack->topChar] != '(') {
                compute(tempStack);
            }
            popChar(tempStack);
        } else {
            while (judgeSize(tempStack) == 1 && tempStack->dataChar[tempStack->topChar] != '(' && Priority(tempStack->dataChar[tempStack->topChar]) >= Priority(c)) {
                compute(tempStack);
            }
            pushChar(tempStack, c);
        }
    }
    
    while (judgeSize(tempStack) == 1) {
        compute(tempStack);
    }
    
    printf("%d", tempStack->dataInt[tempStack->topInt]);
    
    return 0;
}

 运行结果

 

陈皮话梅糖991
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构学习笔记（五）—— 栈
小胖子的博客
04-25 2472
数据结构学习笔记（五）—— 栈
day-one:预算应用程序
07-14
这些工具帮助我们管理和测试应用程序。 我们通过npm （获得我们依赖的工具。 我们通过bower获取角度代码。 我们已经预先配置了npm来自动运行bower所以我们可以简单地做： npm install 在幕后这也将调用bower ...
数据结构学习笔记——栈的简析
平凡的博客
08-25 854
#include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;malloc.h&amp;amp;amp;gt; #define STACK_INIT_SIZE 12000 //存储空间初始分配量 #define STACKINCREMENT 100 // 存储空间分
数据结构学习笔记 - 栈
Mr.W的博客
11-25 304
栈 基本特性 后进者先出, 先进者后出, 这就是典型的栈结构 栈是一种操作受限的线性表, 只允许在一端插入和删除数据 栈是一种特定的数据结构,是对特定场景的抽象 当某个数据集合只涉及在一端插入和删除数据, 并且满足后进先出, 先进后出的特性, 我们就应该首选栈这种数据结构 实现一个栈 栈主要包含两个操作, 入栈和出栈 用数组实现的栈叫顺序栈 (todo) 用链表实现的栈叫链式栈 (todo) 两种实现的空间复杂度和时间复杂度都为O(1) 栈的应用 函数调用栈 操作系统给每个线程分配了一块独立的内存空间，这
数据结构笔记：第三章 栈和队列
qq_43632319的博客
10-27 171
栈：限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶，另一端称为栈底。 设指针top指示栈顶元素在数组中的位置。 进栈：top加1 出栈：top减1 栈空：top= -1 栈满：top= MAX_SIZE-1 顺序栈类的声明 ： const int MAX_SIZE=100; template <class T> c...
数据结构 学习笔记 栈
Sensente的博客
10-18 481
首先明确，栈和队列 是特殊的线性表。 栈(STL : STACK) 一、定义 栈是只能在一端进行插入和删除操作的线性表 日常例子： 洗碗摞一堆； 书摞成一堆； 一些枪支子弹夹中子弹的操作方式等。 1.1一些基本概念 栈顶(top) 进行插入和删除操作的一端 栈底(bottom) 相对栈顶的另一端 入栈(push) 插入操作 出栈(pop) 出栈操作 空栈：无元素的栈 ...
Day_five.rar_day_five_学习计划_日程安排系统_日程管理
09-24
这可能包括环境配置、依赖安装、数据库设置和应用启动等。 6. **文本文件**：“www.pudn.com.txt”可能是一个链接或资源列表，提供额外的学习资料或者开发者社区链接，以便用户获取更多帮助或交流经验。 7. **用户...
Java堆、栈和常量池
08-10
Java编程语言中的内存管理是通过堆、栈和常量池三个关键区域来实现的，这些区域各有其特定的用途和特点。 首先，寄存器是最快的存储区，它由编译器自动分配和管理，程序员无法直接控制。寄存器主要用于存储运算过程...
Day_XX_单调栈1
08-08
Day_XX_单调栈1
day3rsync和EMOS
07-19
day3rsync 和 EMOS day3rsync 和 EMOS 是 Linux 命令行下的数据备份和同步工具。rsync 是一个快速、可靠、功能强大的备份和同步工具，广泛应用于 Linux 操作系统中。EMOS 是一个基于 rsync 的数据同步工具，提供了...
[数据结构笔记]栈-总结笔记
m0_37769093的博客
08-07 256
一、栈 1.1 基本概念 栈 ：限定仅在标为进行插入和删除操作的线性表 栈顶：允许插入和删除的一段 栈底：另一端 不含任何数据的栈叫做空栈。 栈又称为后进后出（Last In First Out）的线性表，简称LIFO结构。 二、栈的抽象数据类型 ADT 栈(stack) Data //同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系 Operation InitStack(*S); //初始化操作，建立一个空栈S DestroyStack(*S); //若栈存在，则销毁
数据结构——栈（笔记）
weixin_51154479的博客
11-01 394
栈 栈是限定仅在表尾进行插入和删除操作的线性表(先进后出) 允许插入和删除的一端叫做栈顶，另一端为栈底； 栈底是固定的，栈顶随着元素的进栈和出栈一直在移动 不含任何元素的叫做空栈 关于出栈的顺序：最先进栈的元素不一定是在最后出栈，有可能一进栈就出栈，一定是栈顶元素先出栈！！！ 如果用数组保存数据，一般栈底的下标记为0； 定义变量top指示栈顶元素在数组中的位置，top无论如何都不能超过栈的最大长度maxsize（依据此条件判断栈是否已满） 为什么在创建栈的时候，top要等于-1？ 因为当栈有一个元素时，此元
数据结构栈 学习笔记
杜甲同学的专栏
09-19 1446
栈是先进后出的数据结构。 下面直接上代码了。
数据结构之队列和栈学习笔记
phoneix_bleach的博客
04-30 385
这两天学习了队列和栈（当然还有哈希表，不过暂且不表），由于队列与栈的类似性故放在一块讲。队列和栈与链表不一样在于其强调的不是存储单元间的关系而是存储后数据流动的一种形式，队列和栈恰好相互对应，一个是先进先出，一个是先进后出。一张图便能轻易掌握这两种数据结构的特点。说白了栈就像个桶，而队列就像个带开关的漏斗。 废话不多说，直接上代码，以栈为例，通过栈1.0版来看栈的建立以及一些基本操作。队列则可
数据结构学习笔记——栈
面向未来编程
06-03 234
栈 它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 我的理解 栈就是一个桶形的线性表 准从先进后出，后进先出的原则 底层是数组...
数据结构笔记——栈与队列
雨潇的博客
10-12 252
总述 栈和队列是我们在stl中比较熟悉的容器了，关于它的操作我们虽然有可能会混淆，但是应该很明白有什么操作、能怎么操作。 在数据结构里面，我们学习的重点不是如何使用栈与队列，而是学习这个容器的运行基本原理，为我们日后对容器应用的拓展打下基础。（当然能用stl里面的模板栈还是要用模板栈的，自己写万一写错又不知道该怎么改正了） 栈 栈是一种先进后出的数据使用模式，常见题型为括号匹配、表达式计算...
学习笔记之数据结构的栈与队列
sskai163的博客
01-09 191
共同点 栈和队列的访问是受限制的，即在特定时刻只有一个数据项可以被读取或删除 栈 特点: 后进先出 实现: 主要机制可用数组来实现，也可以用链表来实现 查询: 栈只允许访问一个数据项：即最后插入的数据 基本操作: 出栈（Pop）、入栈（Push），还有其他扩展操作，如查看栈顶元素，判断栈是否为空、是否已满，读取栈的大小 队列 特点: 先进先出 删除: 环绕式...
数据结构笔记——栈
晓风岚月
04-30 426
一、栈的定义 栈是只允许在一端进行插入或删除操作的线性表 重要术语：栈顶、栈底、空栈 进栈顺序：a1->a2->a3->a4->a5 出栈顺序：a5->a4->a3->a2->a1 特点：后进先出 Last In First Out(LIFO) 二、栈的基本操作 InitStack(&S)：初始化栈。构造一...
数据结构笔记-----栈
碧海蓝天观潮涌
03-13 319
栈的定义及实现 1 2 3 4 5 6 7 8 15
day--和--day区别
最新发布
04-18
"day--"和"day"是两种不同的操作符，它们在编程中有着不同的含义和用法。 1. "day--"是一个后缀自减操作符，用于将变量的值减1，并返回减1之前的值。例如，如果有一个变量day的值为5，执行day--操作后，day的值将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值