C/C++ 数组链表表达式计算

最新推荐文章于 2025-04-30 10:42:02 发布
最新推荐文章于 2025-04-30 10:42:02 发布
阅读量409 收藏 1
点赞数
分类专栏： c++ C 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dingchaochao_9110/article/details/108970709
版权

        国庆期间，自己搞了C/C++编译环境（cygwin其实比mingw好安装一些），跟着敲了一些代码，记录一下：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/* 
 * File:   main.cpp
 * Author: dingcc
 *
 * Created on 2020年10月6日, 下午10:10
 */

#include <cstdlib>
#include <iostream>
#include <math.h>

using namespace std;

/**
 * 寻找两个单词的相同字母的节点
 */

typedef struct LNode {
    char data;
    struct LNode *next;
}LNode;
LNode *findFirstCommon(LNode *str1, LNode *str2)
{
    int len1 = 0, len2 = 0;
    LNode *p = str1->next, *q = str2->next;
    while (p != NULL)
    {
        len1++;
        p = p->next;
    }
    while (q != NULL)
    {
        len2++;
        q = q->next;
    }
    for (p=str1->next; len1>len2; len1--)
        p=p->next;
    for (q=str2->next; len1<len2; len2--)
        q=q->next;
    while (p !=NULL && p->data != q->data)
    {
        p = p->next;
        q = q->next;
    }
    cout<<p->data<<endl;
    return p;
}

/**
 * 尾插法
 * @param head
 * @param n
 * @param length
 */
void createLinkListR(LNode *&head, char n[], int length) {
    head = (LNode*) malloc(sizeof(LNode));
    head ->next = NULL;
    LNode *p = NULL, *r=head;
    for (int i=0; i < length; ++i) {
        p = (LNode*) malloc(sizeof(LNode));
        p ->next = NULL;
        p ->data = n[i];
        p ->next = r->next;
        r ->next = p;
        r = p;
    }
    cout<<head ->next ->data<<endl;
}

/**
 * 头插法
 * @param head
 * @param n
 * @param length
 */
void createLinkListL(LNode *&head, char n[], int length) {
    head = (LNode*) malloc(sizeof(LNode));
    head ->next = NULL;
    LNode *p = NULL;
    for (int i=0; i < length; ++i) {
        p = (LNode*) malloc(sizeof(LNode));
        p ->next = NULL;
        p ->data = n[i];
        p ->next = head->next;
        head ->next = p;
    }
    cout<<head ->next ->data<<endl;
}

/**
 * 合并数组
 * @param a 数组a
 * @param m 数组a的长度
 * @param b 数组b
 * @param n 数组b的长度
 * @param c 合并后的数组c
 */
void mergearray (int a[], int m, int b[], int n, int c[])
{
    int i = 0, j = 0;
    int k = 0;
    while (i < m && j < n)
    {
        if (a[i] < b[j])
            c[k++] = a[i++]; // c[k] = a[i]; k++; i++;
        else
            c[k++] = b[j++];
    }
    
    while (i < m)
        c[k++] = a[i++];
    while (j < n)
        c[k++] = b[j++];
}

/**
 * 合并链表
 * @param A 链表A
 * @param B 链表B
 * @param C 结果链表C
 */
void merge(LNode *A, LNode *B, LNode *&C)
{
    LNode *p = A->next;
    LNode *q = B->next;
    LNode *r;
    C = A;
    C->next = NULL;
    free(B);
    r = C;
    while(p != NULL && q != NULL)
    {
        if (p ->data <= q ->data)
        {
            r->next = p; p = p->next;
            r = r->next;
        }
        else
        {
            r ->next = q; q = q->next;
            r = r->next;
        }
    }
    if(p!=NULL) r->next = p;
    if(q!=NULL) r->next = q;
}

int getPriority(char op)
{
    if (op == '+' || op == '-')
        return 0;
    else
        return 1;
}

/**
 * 中缀式转后缀式
 * @param infix
 * @param s2
 * @param top2
 */
void infixToPostFix(char infix[], char s2[], int &top2)
{
    char s1[11]; int top1 = -1;
    int i = 0;
    while(infix[i] != '\0')
    {
        if ('0' <= infix[i] && infix[i] <= '9')
        {
            s2[++top2] = infix[i];
            ++i;
        }
        else if (infix[i] == '(')
        {
            s1[++top1] = '(';
            ++i;
        }
        else if (infix[i] == '+' ||
                infix[i] == '-' ||
                infix[i] == '*' ||
                infix[i] == '/')
        {
            if (top1 == -1 || 
                    s1[top1] == '(' ||
                    getPriority(infix[i]) > getPriority(s1[top1]))
            {
                s1[++top1] = infix[i];
                ++i;
            }
            else 
                s2[++top2] = s1[top1--];
        }
        else if (infix[i] == ')')
        {
            while (s1[top1] != '(')
                s2[++top2] = s1[top1--];
            --top1;
            ++i;
        }
    }
    while (top1 != -1)
        s2[++top2] = s1[top1--];
    for (int j = 0; j < 12; j++) {
        cout<<s2[j]<<endl;
    }
}

int calSub(float opand1, char op, float opand2, float &result)
{
    if (op == '+') result = opand1 + opand2;
    if (op == '-') result = opand1 - opand2;
    if (op == '*') result = opand1 * opand2;
    if (op == '/')
    {
        if (fabs(opand2) < 0.01)
        {
            return 0;
        }
        else 
        {
            result = opand1 / opand2;
        }
    }
    return 1;
}

int calStackTopTwo(float s1[], int &top1, char s2[], int &top2)
{
    float opnd1, opnd2, result;
    char op;
    int flag;
    opnd2 = s1[top1--];
    opnd1 = s1[top1--];
    op = s2[top2--];
    flag = calSub(opnd1, op, opnd2, result);
    if (flag == 0)
        cout<<"ERROE"<<endl; // puts("ERROR");
    s1[++top1] = result;
    return flag;
}

/**
 * 中缀表达式计算
 * @param exp
 * @return 
 */
float callInfix(char exp[])
{
    int maxSize = 10;
    float s1[maxSize]; int top1 = -1;
    char s2[maxSize]; int top2 = -1;
    int i = 0;
    while (exp[i] != '\0')
    {
        if ('0' <= exp[i] && exp[i] <= '9')
        {
            s1[++top1] = exp[i] - '0';
            ++i;
        }
        else if (exp[i] == '(')
        {
            s2[++top2] = '(';
            ++i;
        }
        else if (exp[i] == '+' ||
                exp[i] == '-' ||
                exp[i] == '*' ||
                exp[i] == '/')
        {
            if (top2 == -1 || 
                    s2[top2] == '(' ||
                    getPriority(exp[i]) > getPriority(s2[top2]))
            {
                s2[++top2] = exp[i];
                ++i;
            }
            else
            {
                int flag = calStackTopTwo(s1, top1, s2, top2);
                if (flag == 0)
                    return 0;
            }
        }
        else if (exp[i] == ')')
        {
            while (s2[top2] != '(')
            {
                int flag = calStackTopTwo(s1, top1, s2, top2);
                if (flag == 0)
                    return 0;
            }
            --top2;
            ++i;
        }
    }
    while (top2 != -1)
    {
        int flag = calStackTopTwo(s1, top1, s2, top2);
        if (flag == 0)
            return 0;
    }
    return s1[top1];
}

/**
 * 后缀表达式计算
 * @param exp
 * @return 
 */
float calPostFix(char exp[])
{
    int maxSize = 10;
    float s[maxSize]; int top = -1;
    for (int i = 0; exp[i] != '\0'; ++i)
    {
        if ('0' <= exp[i] && exp[i] <= '9')
            s[++top] = exp[i] - '0';
        else
        {
            float opnd1, opnd2, result;
            char op;
            int flag;
            opnd2 = s[top--];
            opnd1 = s[top--];
            op = exp[i];
            flag = calSub(opnd1, op, opnd2, result);
            if (flag == 0)
            {
                cout<<"ERROR"<<endl; //puts("ERROR");
                break;
            }
            s[++top] = result;
        }
    }
    return s[top];
}

/**
 * 前缀表达式计算
 * @param exp
 * @param len
 * @return 
 */
float calPreFix(char exp[], int len)
{
    int maxSize = 10;
    float s[maxSize]; int top = -1;
    for (int i = len -1; i >= 0; --i)
    {
        if ('0' <= exp[i] && exp[i] <= '9')
            s[++top] = exp[i] - '0';
        else
        {
            float opnd1, opnd2, result;
            char op;
            int flag;
            opnd1 = s[top--];
            opnd2 = s[top--];
            op = exp[i];
            flag = calSub(opnd1, op, opnd2, result);
            if (flag == 0)
            {
                cout<<"ERROR"<<endl; //puts("ERROR");
                return 0;
            }
            s[++top] = result;
        }
    }
    return s[top];
}

/**
 * 迭代输出链表元素
 * @param c
 */
void foo (LNode *c) {
    if (c->next->data != '\0') {
        cout<<c->next->data<<endl;
        foo(c->next);
    }
}

/*
 * 
 */
int main(int argc, char** argv) {
    //cout<<"hello world!"<<endl;

//合并数组    
//    int a[4] = {1,3,5,7};
//    int b[3] = {2,4,6};
//    int m = 4, n = 3;
//    int c[7];
//    mergearray(a, m, b, n, c);
//    for (int i=0; i<7; ++i) {
//        cout<<c[i]<<endl;
//    }
    
// 合并链表
//    LNode *A;
//    char a[3] = {'a', 'b', 'c'};
//    createLinkListR(A, a, 3);
//    LNode *B;
//    char b[5] = {'d', 'e', 'f', 'g', 'h'};
//    createLinkListR(B, b, 5);
//    LNode *C;
//    merge(A, B, C);
//    foo(C);
    
// 头插法生成单链表
//    LNode *p;
//    char n[] ="abc";
//    createLinkListL(p, n, 3);
    
// 尾插法生成单链表，找两个单词相同的第一个字母    
//    LNode *str1;
//    char n[7] = {'l', 'o', 'a', 'd', 'i', 'n', 'g'};
//    createLinkListR(str1, n, 7);
//    cout<<"str1;"<<str1 ->next->data<<endl;
//    LNode *str2;
//    char m[5] = {'d', 'o', 'i', 'n', 'g'};
//    createLinkListR(str2, m, 5);
//    cout<<"str2;"<<str2 ->next->data<<endl;
//    LNode *x = findFirstCommon(str1, str2);
//    cout<<"x:"<<x->data<<endl;
    
// 中缀转后缀表达式
//    char infix[] = "(6+(3+5)*2-1)/3";
//    char s2[11];
//    int top2 = 0;
//    infixToPostFix(infix, s2, top2);
//    cout<<"top2"<<top2<<endl;

// 中缀、后缀、前缀表达式计算    
    char exp[] = "(6+(3+5)*2-1)/3";
    float s1 = callInfix(exp);
    cout<<"s1:"<<s1<<endl;
    char exp2[] = "635+2*+1-3/";
    float s2 = calPostFix(exp2);
    cout<<"s2:"<<s2<<endl;
    char exp3[] = "/-+6*+35213";
    float s3 = calPreFix(exp3, 11);
    cout<<"s3:"<<s3<<endl;
    return 0;
}

代码参考：天勤率辉考研

C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 10万+
C/C++学习路线总结与分享
理解 C 与 C++ 中的 const 常量与数组大小的关系
禅宗里有一个词叫做“因缘和合”。 所谓因缘，是指事件要发生所必须的条件。因缘和合就是当你聚集了这件事的一切条件，它就会自然而然的发生。“它就会自然而然的发生”，这种朴素而坚定的价值观让我们感到无比安心，安心到可以不用有任何担心焦虑。
02-05 2040
在 C 语言和 C++ 中，数组的大小通常要求是一个编译时常量，也就是说数组的长度必须在编译阶段就能够确定。这对于程序的性能优化和内存管理是至关重要的。在很多初学者学习这两门语言时，对于数组大小的常量有时会感到困惑，尤其是在遇到 const 关键字时。在此篇文章中，我们将详细探讨 C 和 C++ 中数组大小的常量要求，分析 const 在这两种语言中的作用，解答为什么在 C 中常量 const int a = 10; 无法作为数组大小 2025.2.5-✍60min
表达式计算（C++实现）
zRegle的博客
03-09 3577
目前正在学习数据结构，根据书本上的思路自己捣鼓了一个表达式计算的小程序，目前支持负数、小数运算和报错。下面贴上代码，代码写的很烂（耦合度比较高，比较繁琐），大家如果有什么更好的建议可以提一下！PS：第一次写博客，诚惶诚恐#include <stack> #include <iostream> #include <string> //cin>>string #include <cstring> //s
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 64万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
C 语言链表详解
最新发布
m0_75187370的博客
04-30 1161
链表是一种线性数据结构，与数组不同，它在内存中不是连续存储的。链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。这种链式存储方式使得链表在插入和删除操作上具有高效性，并且可以动态地分配内存，无需像数组那样预先确定大小。
链表，数组实现堆栈，表达式计算
qq_41951198的博客
03-09 239
一、 结果显示 堆栈实现测试 Test.h 表达式运算： Expression.h 二、 ArrayStack.h #include using namespace std; const int Max_size = 128; template class ArrayStack { public: ArrayStack() { count = 0; array = new T...
C程序单链表面试题详解
大头针的专栏
06-12 1015
测试空间旗下大头针出品   最近C语言辅导过程中，发现有很多同学对于有关C语言链表的问题一直不是很清楚，而在最近部分临毕业学员应聘测试工作中又遇到单链表的问题而且反应不是很熟练这块的内容。今天就谈谈有关但单链表的基本用法。链表1。是由结构体和指针构成的。2。包括两个部分一个是数据域和指针域。3。链表中的结点分为两类：头结点和一般结点。头结点是没有数据域的。4。基本操作有
Python中的链表表达式
海涛高软
03-14 769
num = [1, 2, 3, 4, 5] myvec = [x * 2 for x in num] print(myvec) [x * 2 for x in num]的意思就是 循环遍历num ，然后取出每一个值*2,并将得到的链表最终赋值给myvec 最终打印结果： 下面再举个例子： inputStr = [1,3,5,7] positive_labels = ...
C/C++后缀表达式计算机实现与优先级处理
总结来说，这份资源对于希望了解如何使用C/C++语言实现后缀表达式计算的读者来说是一个宝贵的参考资料。它不仅涉及到栈这种数据结构的实现和操作，还包括了计算机算法中的重要概念，例如操作符优先级的判断，这都是...
实现一个计算机.zip_C/C++__C/C++_
08-09
本项目通过使用C/C++编程语言，利用栈的数据结构来实现一个简单的计算器，其核心是处理后缀表达式（也称为逆波兰表示法）进行计算。后缀表达式的优点在于它消除了括号和优先级解析的需要，使得计算过程更为直观。 ...
data-structure.rar_Linux/Unix编程_C/C++_
08-11
在C/C++中，主要的数据结构包括数组、链表、栈、队列、树、图、哈希表等。这些数据结构在解决实际问题时扮演着不同角色，例如： 1. **数组**：是最基础的数据结构，它提供了通过索引访问元素的能力。在C/C++中，...
单链表，表达式求值，二叉树，二叉排序树，哈弗曼树（c语言）
07-09
数据结构课设做的内容，拿出来分享一下 #include"bintree.h" #include"Bitree.h" #include"evaluate.h" #include"hufmtree.h" #include"linklist.h" #include"stdio.h" void main() { int flag=1,d; while(flag) { printf("\n*******************************\n"); printf("**** 1:二叉树 *****\n"); printf("**** 2:二叉排序树 *****\n"); printf("**** 3:表达式求值 *****\n"); printf("**** 4:哈夫曼树 *****\n"); printf("**** 5:单链表 *****\n"); printf("**** 0:退出 *****\n"); printf("*******************************\n"); printf("请选择:"); scanf("%d",&d);getchar(); switch(d) { case 1:bintree();break; case 2:Bitree();break; case 3:evaluate();break; case 4:hufmtree();break; case 5:linklist();break; case 0:flag=0;break; } } }
表达式计算（C++ STL 实现）
03-24
通过逆波兰式来计算数学中的中缀表达式，例如：3+(4-7*5)，主要是处理运算优先级问题。源码里面的注释非常详细，由于基于基本数据类型实现，实用价值较小，用作学习还是很不错的。（支持的符号（半角模式）：0123456789 ( ) .（小数点） + - * / !（阶乘） ^（次方））
c/c++算术表达式求值演示
12-17
实现四则运算！！！ 支持的运算包括：加法（+或＋），减法（-或－），乘法（*或×），除法（/），幂运算（^），阶乘（!或！）。 可以是长表达式，如(3+2)*4+2^3+5!-6/3+3.21*6/4=
用数组处理计算带括号的算术表达式
04-26
这是个仅用 对数组的操作 处理 带括号的四则运算 ，能对基本的四则运算式进行计算，拥有输入查错功能，对不科学的算术表达式输入将给出提示并自动退回上一步输入
获取运算表达式的值--数组版
06-09
获取运算表达式的值，根据运算符的优先级，计算值
C++表达式
Hello World
05-02 823
C++表达式 主要是参考C++ primer书籍上的一些内容，加上一些找的其他资料与自己写的代码 重载右键头-&gt; 详细解释：https://blog.youkuaiyun.com/friendbkf/article/details/45949661 二维数组引用 二维数组中，每个元素都是一个一维数组。但是如果在使用中，直接取其特定的值，会将该值视为指针(指向一个一维数组)，而如果...
C链表
小旺的博客
03-13 5243
单链表 最简单的链表。元素之间由一个单独的指针链接。这种结构的链表允许从第一个元素开始遍历到最后一个元素。 双向链表 这种形式的链表元素之间通过两个指针链接。双向链表可以正向遍历，也可以反向遍历。 循环链表 这种形式的链表最后一个元素的指针指向链表的首元素，而不是设置为NULL。这种结构的链表允许循环遍历。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值