用栈实现 链表反转、多项式运算

已于 2022-04-19 09:34:09 修改
阅读量950 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2022-04-16 22:20:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60292931/article/details/124203708
版权

目录

1、反转链表

2、检查括号是否匹配

3、中缀Infix，前缀prefix，后缀suffix

 4、中缀表达式 转 后缀表达式

5、简单的多项式运算

6、完整代码+运行截图

1、反转链表

 /*
 * 一般不建议像下面这样写，我是图省事，直接用之前的代码
 * e = (ElemTYpe)tmp;
 *  tmp->next = (SNode *) Top(S);
 *  最好在栈的数据结构中定义struct Node *类型的变量
 */

void ReverseList(SList *LL,SList S){
    ElemTYpe e;
    SNode *tmp = *LL;
    //将链表的地址全部压入栈中
    while (tmp != NULL){
        e = (ElemTYpe)tmp;
        Push(e,&S);
        tmp = tmp->next;
    }
    //拿到链表的最后一个地址
    tmp = (SNode *) Top(S);
    *LL = tmp;
    Pop(&S);
    //依次拿到后续地址
    while(IsEmpty(S) != 1){
        tmp->next = (SNode *) Top(S);
        Pop(&S);
        tmp = tmp->next;
    }
    tmp->next = NULL;
}

2、检查括号是否匹配

void Match(SList S,char *exp) {
    char e;
    while (*exp != '\0') {
        e = *exp;
        exp++;
        switch (e) {
            case '(':
            case '[': {
                Push((int) e, &S);
                break;
            }
            case ')': {
                if (IsEmpty(S) !=1 && (char) Top(S) == '('){
                    Pop(&S);
                    break;
                }
                else{
                    printf("括号匹配错误\n");
                    return;
                }
            }
            case ']': {
                if ( IsEmpty(S) !=1  &&(char) Top(S) == '[' ){
                    Pop(&S);
                    break;
                }
                else{
                    printf("括号匹配错误\n");
                    return;
                }
            }
        }
    }
    if (IsEmpty(S)) {
        printf("括号匹配正确\n");
    }
    else{
        printf("括号匹配错误\n");
    }
}

3、中缀Infix，前缀prefix，后缀suffix

中缀表达式 变 后缀表达式

中缀表达式 变 前缀表达式

 图片来源：https://www.bilibili.com/video/BV1Fv4y1f7T1?p=20
 

视频的思路非常清晰，就是没代码

 4、中缀表达式 转 后缀表达式

//优先级高的运算符一定是放在前面的
void InfixToSuffix(SList S,char *infix_exp,char *Suffix_exp){

    //首先判断括号匹配
    printf("中缀表达式：%s\n",infix_exp);
    if(Match(S,infix_exp)){
        printf("括号匹配正确\n");
    }
    else{
        printf("括号匹配错误\n");
        return;
    }

    char e;
    while(*infix_exp != '\0'){
        e = *infix_exp;
        //只要是”(”一定压入栈
        if(e == '('){
            Push((int)e,&S);
        }
        //当是乘"*"或除"/" 先判断栈顶元素，如果是乘除，则先出栈再压入栈
        else if((e == '*' || e== '/')  ) {
            if( IsEmpty(S) !=1 &&  ((char)Top(S) == '*' || (char)Top(S) == '/')){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;
                Pop(&S);

                Push((int)e,&S);
            }else{
                Push((int)e,&S);
            }
        }
        //当是加"+"或减"-" 先判断栈顶元素，除了"("，一律先出栈再压入栈
        else if(e == '+' || e== '-'){
            if(IsEmpty(S) !=1  &&  (char)Top(S) != '('){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;
                Pop(&S);

                Push((int)e,&S);
            } else{
                Push((int)e,&S);
            }
        }
        //括号里的运算符一律出栈
        else if(e == ')'){
            while((char)Top(S) != '('){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;

                Pop(&S);
            }
            Pop(&S);
        }
        //数字直接放入数组
        else{
            *Suffix_exp = e;
            Suffix_exp++;
        }
        infix_exp++;
    }
    //判断栈里是否还有运算符
    while(IsEmpty(S) != 1){
        *Suffix_exp = (char)Top(S);
        Pop(&S);
        Suffix_exp++;
    }
    *Suffix_exp = '\0';
}

5、简单的多项式运算

ElemTYpe Polynomial(SList S,char *infix_exp){

    //将前缀表达式转成后缀表达式
    int len = strlen(infix_exp);
    char Suffix_exp[len];
    InfixToSuffix(S,infix_exp,Suffix_exp);
    char *exp =  Suffix_exp;

    printf("后缀表达式：%s\n",exp);
    char e;
    ElemTYpe tmp; //临时保存运算的值
    while(*exp != '\0'){
        e = *exp;
        //数字统统入栈
        if( e == '*' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)*tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '/' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)/tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '+' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)+tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '-' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)-tmp;
            Pop(&S);

            Push(tmp,&S);
        }else{
            //atoi(&e) 字符数字转整型数字
            Push(atoi(&e),&S);
        }
        exp++;
    }

    return tmp;
}

6、完整代码+运行截图

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

typedef int ElemTYpe;
//栈的数据结构
typedef struct SNode{
    struct SNode* next;
    ElemTYpe data;
}SNode,*SList;

//压栈
void Push(ElemTYpe e,SList *S);
//获取栈顶元素
ElemTYpe Top(SList S);
//出栈
void Pop(SList *S);
//判断栈空
int IsEmpty(SList S);
//打印
void PrintList(SList S);

//反转链表
void ReverseList(SList *LL,SList S);
//检查括号是否匹配 匹配1 不匹配0
int Match(SList S,char *exp);
//中缀表达式转后缀表达式
void InfixToSuffix(SList S,char *infix_exp,char *Suffix_exp);
//多项式运算
ElemTYpe Polynomial(SList S,char *infix_exp);

int main() {
    //栈
    SList S = NULL;
    ElemTYpe e = 7;

    //链表 不带头结点
    SList LL = NULL;

    for(int i = 6;i>0;i--){
        e--;
        Push(e,&LL);
    }
    printf("链表为：\n");
    PrintList(LL);
    ReverseList(&LL,S);
    printf("反转后：\n");
    PrintList(LL);


    //多项式的运算
    char infix_exp[] ={"3+1*(2+4*7)/5+6-8"};
    e = Polynomial(S,infix_exp);
    printf("%s 运算结果为 %d：\n",infix_exp,e);

    return 0;
}

void Push(ElemTYpe e,SList *S){
    SNode *tmp = (SNode *) malloc(sizeof(SNode));
    tmp->data = e;
    tmp->next = *S;
    *S = tmp;
   //printf("%d入栈\n",tmp->data);
}

ElemTYpe Top(SList S){

    if(S == NULL){
        printf("栈为空，无法获取栈顶元素\n");
        return 0;
    }
    else{
        return S->data;
    }
}

int IsEmpty(SList S){
    if(S == NULL)
        return 1;
    else
    return 0;
}

void Pop(SList *S){
    SNode *tmp;
    tmp = *S;
    if(tmp == NULL){
        printf("无法出栈，栈为空\n");
        return;
    }
    *S = (*S)->next;
    //printf("%d出栈\n",tmp->data);
    free(tmp);
}

void PrintList(SList S){
    while (S != NULL){
        printf("%d ",S->data);
        S = S->next;
    }
    printf("\n");
}

/*
 * 一般不建议像下面这样写，我是图省事，直接用之前的代码
 * e = (ElemTYpe)tmp;
 *  tmp->next = (SNode *) Top(S);
 *  最好在栈的数据结构中定义struct Node *类型的变量
 */
//反转链表
void ReverseList(SList *LL,SList S){
    ElemTYpe e;
    SNode *tmp = *LL;
    //将链表的地址全部压入栈中
    while (tmp != NULL){
        e = (ElemTYpe)tmp;
        Push(e,&S);
        tmp = tmp->next;
    }
    //拿到链表的最后一个地址
    tmp = (SNode *) Top(S);
    *LL = tmp;
    Pop(&S);
    //依次拿到后续地址
    while(IsEmpty(S) != 1){
        tmp->next = (SNode *) Top(S);
        Pop(&S);
        tmp = tmp->next;
    }
    tmp->next = NULL;
}

//检查括号是否匹配 匹配1 不匹配0
int Match(SList S,char *exp) {
    char e;
    while (*exp != '\0') {
        e = *exp;
        switch (e) {
            case '(':
            case '[': {
                Push((int) e, &S);
                break;
            }
            case ')': {
                if (IsEmpty(S) !=1 && (char) Top(S) == '('){
                    Pop(&S);
                    break;
                }
                else{
                    return 0;
                }
            }
            case ']': {
                if ( IsEmpty(S) !=1  &&(char) Top(S) == '[' ){
                    Pop(&S);
                    break;
                }
                else{
                    return 0;
                }
            }
        }
        exp++;
    }
    if (IsEmpty(S)) {
        return 1;
    }
    else{
        return 0;
    }
}

//中缀表达式转后缀表达式
//优先级高的运算符一定是放在前面的
void InfixToSuffix(SList S,char *infix_exp,char *Suffix_exp){

    //首先判断括号匹配
    printf("\n中缀表达式：%s\n",infix_exp);
    if(Match(S,infix_exp)){
        printf("括号匹配正确\n");
    }
    else{
        printf("括号匹配错误\n");
        return;
    }

    char e;
    while(*infix_exp != '\0'){
        e = *infix_exp;
        //只要是”(”一定压入栈
        if(e == '('){
            Push((int)e,&S);
        }
        //当是乘"*"或除"/" 先判断栈顶元素，如果是乘除，则先出栈再压入栈
        else if((e == '*' || e== '/')  ) {
            if( IsEmpty(S) !=1 &&  ((char)Top(S) == '*' || (char)Top(S) == '/')){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;
                Pop(&S);

                Push((int)e,&S);
            }else{
                Push((int)e,&S);
            }
        }
        //当是加"+"或减"-" 先判断栈顶元素，除了"("，一律先出栈再压入栈
        else if(e == '+' || e== '-'){
            if(IsEmpty(S) !=1  &&  (char)Top(S) != '('){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;
                Pop(&S);

                Push((int)e,&S);
            } else{
                Push((int)e,&S);
            }
        }
        //括号里的一律出栈
        else if(e == ')'){
            while((char)Top(S) != '('){
                *Suffix_exp = (char)Top(S);
                Suffix_exp++;

                Pop(&S);
            }
            Pop(&S);
        }
        //数字直接放入数组
        else{
            *Suffix_exp = e;
            Suffix_exp++;
        }
        infix_exp++;
    }
    //判断栈里是否还有运算符
    while(IsEmpty(S) != 1){
        *Suffix_exp = (char)Top(S);
        Pop(&S);
        Suffix_exp++;
    }
    *Suffix_exp = '\0';
}

//简单的多项式运算
ElemTYpe Polynomial(SList S,char *infix_exp){

    //将前缀表达式转成后缀表达式
    int len = strlen(infix_exp);
    char Suffix_exp[len];
    InfixToSuffix(S,infix_exp,Suffix_exp);
    char *exp =  Suffix_exp;

    printf("后缀表达式：%s\n",exp);
    char e;
    ElemTYpe tmp; //临时保存运算的值
    while(*exp != '\0'){
        e = *exp;
        //数字统统入栈
        if( e == '*' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)*tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '/' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)/tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '+' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)+tmp;
            Pop(&S);

            Push(tmp,&S);
        }
        else if( e == '-' ){
            tmp = Top(S);
            Pop(&S);
            tmp = Top(S)-tmp;
            Pop(&S);

            Push(tmp,&S);
        }else{
            //atoi(&e) 字符数字转整型数字
            Push(atoi(&e),&S);
        }
        exp++;
    }

    return tmp;
}

 只是自己写着玩练手的，逻辑有些混乱，还有很多细节没考虑

z呀哈哈z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课后习题源代码
02-26
数据结构数据
用链表实现多项式运算
12-04
本项目“用链表实现多项式运算”聚焦于利用链表来表示和操作多项式，涵盖了多项式的基本运算：加法、减法、乘法以及求导。下面将详细讨论这些知识点。 首先，链表是一种非连续存储结构，由一系列节点组成，每个节点...
如何利用栈实现单链表的翻转
m0_67186846的博客
08-18 264
利用栈实现单链表的翻转
利用栈和队列的基本运算将所构建的队列中的内容进行逆转（C语言实现）
qq_60545192的博客
02-02 1076
栈和队列基本运算包括判断队空isQueueEmpty()、出队outQqueue()、入队enQueue()、初始化栈initStack()、判断栈空isEmptyStack()、入栈push()、弹栈pop()等。要求：编写一个算法，利用栈和队列的基本运算将所构建的队列中的内容进行逆转。函数原型为void reverse(cqueue *q).栈和队列的基本运算可以看我之前的文章。
利用栈来实现对字符串的逆置
weixin_45701077的博客
11-23 3579
//思路：将字符串数组进行入栈操作，然后通过出栈的方式进行逆置（栈的先进后出的性质） #include <stdio.h> #include <stdlib.h> #define MAXSIZE 20 //定义一个顺序栈 typedef struct Node{ char str[MAXSIZE]; int top; }SeqStack; //初始化 void InitStack(SeqStack &S) { S.top=-1; } //判断顺序栈是否为空 int
【LeetCode】用栈解决问题：1019. 链表中的下一个更大节点
flora
10-16 858
本篇文章主要记录一下如何用栈来解决问题 下面看一个链表的题目 1019. 链表中的下一个更大节点 给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, … 。 每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 ...
用链表实现多项式_C++_
10-04
在这个场景中，我们讨论的是如何使用C++通过链表来实现多项式的加、减、乘、除运算。首先，我们需要理解链表的基本概念以及如何将其应用到多项式表示上。 链表不同于数组，它不连续存储元素，而是通过节点之间的...
用链表实现多项式加减法运算
10-18
用链表实现两个多项式相加的C语言源代码，两个多项式相加时，同类项的系数相加，无同类项的系数保持不变，想家完后再按升幂排序，结果放回链表中。是数据结构的作业，改编了网上的代码，运行结果正确。
链表实现多项式的运算
04-05
本项目涉及的主题是“链表实现多项式的运算”，它巧妙地利用链表的数据结构来表示和操作数学中的多项式。在此，我们将深入探讨链表如何用于表示多项式以及如何进行多项式的加法、减法和乘法运算。 首先，我们要理解...
利用单链表实现多项式基本运算(C++模板实现）
08-10
本主题聚焦于如何使用C++模板实现单链表，并基于此实现多项式的加、减、乘等基本运算。下面将详细介绍这两个知识点。 **1. C++模板** C++模板是一种泛型编程工具，它允许我们编写可以处理不同数据类型的代码。模板...
C语言栈多项式运算
07-10
用C语言和栈实现多项式四则运算，已经亲自运行通过
反转链表（3种实现方法+图文解释+代码）
weixin_52514564的博客
04-27 582
递归（深度优先）遍历到最底层，然后逐级往上进行反转，每一次递归内部，将当前节点的next节点的next节点指向自身，同时将自身的next节点指向NULL（为了在最后一次递归时候，不让链表形成闭环）。建立链表1和链表2，循环遍历链表1，在每一个循环内部，将链表1的当前节点接入到链表2的头节点。图中是两种图形描述，代码是一样的，图形化理解方式不一样。将一个个数据推入栈区，然后再一个个弹出来。注意点：弹出完成之后，要把最后一个节点的next指向null，否则链表就闭环了。
用栈实现单链表的逆转
yangshuangtao的专栏
06-25 4592
#include #include using namespace std; struct ListNode { ListNode *next; int data; ListNode(int x): { data=x; next=NULL: } }; ListNode* ReverseList(ListNode* pHead) {
栈的基本运算实现
suaoyang的专栏
07-28 7214
栈是一种只能在一端进行插入和删除操作的线性表。表中允许进行插入和删除操作的一端称为栈顶。栈顶的当前位置是动态的，由一个称为栈顶指针的位置指示器指示。表的另一端称为栈底。不含数据元素的栈称为空栈。栈的插入操作称为压栈或进栈，栈的删除操作称为退栈或出栈。栈的主要特点是“后进先出（LIFO）”。 1、 顺序栈 假定栈的元素个数不超过MaxSize，所有的元素都具有同一数据类型ElemType。采用栈
链表的反转
JB666M的博客
04-26 255
链表的反转 在做一些题的时候需要将链表进行反转。一般有两种方法，使用栈和插入法。 1.栈：由于栈的特点是元素先入后出，那么将链表的元素压栈后再弹出就得到了反序。 代码如下： public ListNode ReverseList(ListNode head) { Stack<ListNode> stack = new Stack<>(); //遍历链表元素，并将个元素压栈 while (head!=null){
C++数据结构实验---栈和队列【多项式计算】
海到无边天作岸 山登绝顶我为峰
10-22 2869
实验二 栈和队列 1.实验内容与要求 理解栈和队列的逻辑结构及应用场景 针对实际问题选择循环队列或链栈的方法，编程实现构造、插入、删除等基本操作 掌握栈和队列的存储原理 2.实验环境 硬件环境：计算机 软件环境:vc++ 3.实验算法伪代码 计算优先级： char Priority(char ch1,char ch2){ int a; int b; switch(ch1){ case '=' : a=0; break; case '(' : a= 1; break;
数据结构-多项式计算(栈实现)
I will not forget who I love.
01-02 1517
#include #include #define LIST_INIT_SIZE 10 #define LISTINCREMENT 100 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TRUE 1 #define FALSE 0 #define true 1 #define false 0 #define OK 1
java 两栈计算算式_使用栈计算多项表达式的简单实现--java
weixin_32676101的博客
02-26 266
这是使用栈直接计算多项表达式的java简单实现。算法原理：1、定义两个栈：操作数栈od，操作符栈op2、逐个字符扫描多项表达式：-------a)如果是操作数，将数字转换为double类型push进od栈-------b)如果是‘(’，直接push进op栈-------c)如果是操作符，比较当前操作符”op“和op栈栈顶操作符的优先级：当前操作符优先级高时，操作符直接入栈，进行下一步；否则，使用当...
用链表表示多项式，并实现多项式的加法运算
最新发布
06-28
实现多项式的加法运算，可以先将两个多项式的节点按照指数从小到大合并成一个链表，然后对相同指数的节点进行系数相加，最后删除系数为的节点即可。 具体实现可以参考以下代码： ```python class Node: def __...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值