c语言编写的栈的实现

第1篇一、实验目的1. 理解栈的基本概念和操作；2. 掌握栈的顺序存储和链式存储实现方法；3. 熟悉栈在程序设计中的应用。

二、实验内容1. 栈的顺序存储结构实现；2. 栈的链式存储结构实现；3. 栈的基本操作（入栈、出栈、判空、求栈顶元素）；4. 栈在程序设计中的应用。

三、实验方法1. 采用C语言进行编程实现；2. 对实验内容进行逐步分析，编写相应的函数和程序代码；3. 通过运行程序验证实验结果。

四、实验步骤1. 实现栈的顺序存储结构；（1）定义栈的结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证顺序存储结构的栈操作。

2. 实现栈的链式存储结构；（1）定义栈的节点结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证链式存储结构的栈操作。

3. 栈在程序设计中的应用；（1）实现一个简单的四则运算器，使用栈进行运算符和操作数的存储；（2）实现一个逆序输出字符串的程序，使用栈进行字符的存储和输出；（3）编写测试程序，验证栈在程序设计中的应用。

五、实验结果与分析1. 顺序存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，栈顶元素增加；（2）出栈操作：在栈非空的情况下，出栈操作成功，栈顶元素减少；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。

2. 链式存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，链表头指针指向新节点；（2）出栈操作：在栈非空的情况下，出栈操作成功，链表头指针指向下一个节点；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。

3. 栈在程序设计中的应用实验结果：（1）四则运算器：成功实现加、减、乘、除运算，并输出结果；（2）逆序输出字符串：成功将字符串逆序输出；（3）测试程序：验证了栈在程序设计中的应用。

c语言栈的定义栈（Stack）是一种常见的数据结构，它基于后进先出（Last In First Out，LIFO）的原则进行操作。

在C语言中，栈可以通过数组或链表实现。

1.数组实现栈数组实现栈是最简单和常见的方式之一。

我们可以定义一个固定大小的数组，并使用一个指针来表示栈顶位置。

栈内的元素可以通过增加或减少指针来进行入栈和出栈操作。

定义一个栈的结构体：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;```- `data`是一个整型数组，用于存储栈内的元素。

- `top`是一个整数变量，用于表示栈顶元素的位置。

初始化栈：```cvoid initStack(Stack* stack) {stack->top = -1;}```入栈操作：```cvoid push(Stack* stack, int value) {if (stack->top == MAX_SIZE - 1) {printf("栈已满，无法入栈！"); return;}stack->data[++stack->top] = value; }```出栈操作：```cint pop(Stack* stack) {if (stack->top == -1) {printf("栈已空，无法出栈！"); return -1;}return stack->data[stack->top--];}```获取栈顶元素：```cint peek(Stack* stack) {if (stack->top == -1) {printf("栈已空，无法获取栈顶元素！"); return -1;}return stack->data[stack->top];}```判断栈是否为空：```cint isEmpty(Stack* stack) {return stack->top == -1;}```判断栈是否已满：```cint isFull(Stack* stack) {return stack->top == MAX_SIZE - 1;}```2.链表实现栈链表实现栈是另一种常见的方式。

C语言中栈的基本操作栈（Stack）是一种遵循“后进先出”（LIFO）原则的数据结构，具有以下几个基本操作：入栈（Push）、出栈（Pop）、判断栈是否为空（Empty）以及获取栈顶元素（Top）。

下面将详细介绍这些基本操作。

1. 入栈（Push）：将一个元素添加到栈的顶部。

入栈操作分为两个步骤：(1)判断栈是否已满，如果已满则无法再添加元素；(2)若栈不满，则将元素添加到栈的顶部，并更新栈顶指针。

具体实现代码如下：```void push(Stack *s, int item)if (is_full(s))printf("Stack is full, cannot push more elements.\n");return;}s->top++;s->data[s->top] = item;}```2. 出栈（Pop）：将栈顶元素移除，并返回该元素的值。

出栈操作也有两个步骤：(1)判断栈是否为空，如果为空则无法进行出栈操作；(2)若栈不为空，则将栈顶元素移除，并更新栈顶指针。

具体实现代码如下：```int pop(Stack *s)int item;if (is_empty(s))printf("Stack is empty, cannot pop any elements.\n");return -1; // 指定一个特定的返回值来表示错误}item = s->data[s->top];s->top--;return item;}```3. 判断栈是否为空（Empty）：判断栈是否为空分为两种情况，一种是根据栈顶指针进行判断，另一种是根据数据数量进行判断。

(1)判断栈顶指针是否为-1，若为-1则说明栈为空；(2)若栈内数据数量为0，则栈为空。

具体实现代码如下：```int is_empty(Stack *s)return s->top == -1; // 栈顶指针为-1表示栈为空}```4. 获取栈顶元素（Top）：返回栈顶元素的值，但不对栈做任何修改。

C语⾔实现堆栈（⾃⼰的）stack.h#ifndef __STACK_H__#define __STACK_H__#include <stdio.h>#include <stdlib.h>#include <stdbool.h>typedef int ElementType;struct SNode {ElementType *Data; /* 存储元素的数组 */int Top; /* 栈顶指针 */int MaxSize; /* 堆栈最⼤容量 */};typedef struct SNode *Stack;Stack CreateStack( int MaxSize ); //建⽴结构体堆栈bool IsFull( Stack S ); //判断堆栈是是否溢出bool Push( Stack S, ElementType X ); //压栈bool IsEmpty( Stack S ); //判断堆栈是是否为空ElementType Pop( Stack S ); //出栈#endifstack.c#include "stack.h"#include "sys.h"u8 Choose_Stack_Flag=0; //未检测到加减符号时候,0:⼀个结构体,检测到1:另⼀个结构体Stack CreateStack( int MaxSize ){Stack S = (Stack)malloc(sizeof(struct SNode));S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));S->Top = -1;S->MaxSize = MaxSize;return S;}bool IsFull( Stack S ){return (S->Top == S->MaxSize-1);}bool Push( Stack S, ElementType X ){if ( IsFull(S) ) {printf("堆栈满");return false;}else {S->Data[++(S->Top)] = X;return true;}}bool IsEmpty( Stack S ){return (S->Top == -1);}ElementType Pop( Stack S ){if ( IsEmpty(S) ) {printf("堆栈空");return ERROR; /* ERROR是ElementType的特殊值，标志错误 ERROR 0 */}elsereturn ( S->Data[(S->Top)--] );}。

括号匹配问题栈c语言括号匹配问题是计算机科学领域中十分重要的一个主题，它可以在处理括号匹配问题中发挥作用。

括号匹配问题被广泛应用在计算机科学领域中，比如编译器，语法分析等领域。

要解决括号匹配问题，常用的方法之一就是使用栈数据结构来解决。

栈是一种非常简单而又十分有效的数据结构，它的特点是“后进先出”（LIFO），即一个元素最先被放入栈中，在任何情况下都会最后被取出。

因此，使用栈来解决括号匹配问题，是一种非常有效的方法。

那么，栈的c语言实现是怎样的呢？在c语言中，可以使用结构体来实现栈。

栈的结构体由以下三部分组成：Top指针，MaxSize和Data，其中Top指针表示栈顶元素的位置；MaxSize表示栈的最大存储容量；Data是存储栈内元素的数组。

栈的实现需要定义一些函数，比如push()和pop()函数，用于入栈和出栈的操作；isEmpty()函数，用于判断栈是否为空；isFull()函数，用于判断栈是否已满，以及压栈和出栈元素到栈顶等等。

接下来就是使用栈来解决括号匹配问题了。

首先，要判断输入的字符串中括号是否匹配，可以使用计数法来判断。

例如，如果字符串中出现“（”，就把计数器加1，若出现“）”，就把计数器减1；最后如果计数器为0，则说明字符串中括号是匹配的。

如果字符串的括号是匹配的，则可以使用栈来检验字符串中括号的匹配情况。

从字符串的第一个字符开始遍历，如果当前字符为“（”，则压进栈；如果当前字符为“）”，则出栈一个“（”，表示当前字符与栈中的“（”匹配；如果栈中没有“（”，则说明当前字符串中括号不匹配。

例如，“（（）（））”这个字符串，经过上述操作，最后栈空，说明括号是完全匹配的。

而“（（））（）”这个字符串，之后经过操作，栈中会剩一个“（”，说明括号不匹配。

总结以上就是括号匹配问题栈的c语言实现的内容，括号匹配问题是计算机领域中一个常见的问题，栈的c语言实现就是使用结构体定义栈，然后定义一些函数，来实现栈的入栈和出栈操作，最后通过计数法或者栈结构，来判断字符串中括号是否完全匹配。

用栈实现进制转换#include <stdio.h>#define STACK_SIZE 100 /*假定预分配的栈空间最多为100个元素*/ typedef char DataType;/*假定栈元素的数据类型为字符*/typedef struct{DataType *base;DataType *top;int stacksize;}SeqStack;/* 置栈空*/void Initial(SeqStack *s){/*构造一个空栈*/s->base=(DataType *)malloc(STACK_SIZE * sizeof(DataType));if(!s->base) exit (-1);s->top=s->base;s->stacksize=STACK_SIZE;}/*判栈空*/int IsEmpty(SeqStack *S){return S->top==S->base;}/*判栈满*/int IsFull(SeqStack *S){return S->top-S->base==STACK_SIZE-1;}/*进栈*/void Push(SeqStack *S,DataType x){if (IsFull(S)){printf("栈上溢"); /*上溢,退出运行*/exit(1);}*S->top++ =x;/*栈顶指针加1后将x入栈*/}/*出栈*/DataType Pop(SeqStack *S){if(IsEmpty(S)){printf("栈为空"); /*下溢,退出运行*/exit(1);}return *--S->top;/*栈顶元素返回后将栈顶指针减1*/}/* 取栈顶元素*/DataType Top(SeqStack *S){if(IsEmpty(S)){printf("栈为空"); /*下溢,退出运行*/exit(1);}return *(S->top-1);}void conversion (int N,int B){/*假设N是非负的十进制整数，输出等值的B进制数*/ int i;SeqStack *S=(SeqStack *)malloc(sizeof(SeqStack));Initial(S);while(N){ /*从右向左产生B进制的各位数字，并将其进栈*/ Push(S,N%B); /*将bi进栈0<=i<=j*/N=N/B;}while(!IsEmpty(S)){ /*栈非空时退栈输出*/i=Pop(S);printf("%d",i);}}void main(){int n,d;printf("Input the integer you want to transform:");scanf("%d",&n);printf("Input the integer of the system: ");scanf("%d",&d);printf("result:");conversion(n,d);getch();}用栈实现编辑程序将用户输入的信息存入用户的数据区。

c语言栈的名词解释在计算机科学和编程中，栈（Stack）是一种重要的数据结构。

C语言作为一种广泛应用的编程语言，自然也涉及到栈的概念和使用。

在本文中，将对C语言栈进行详细的名词解释和功能介绍。

1. 栈的定义和特点栈是一种线性的数据结构，它的特点是后进先出（Last In First Out, LIFO）。

也就是说，最后一个进入栈的元素将是第一个被访问、被移除的。

栈采用两个基本操作，即压栈（Push）和弹栈（Pop），用于对数据的插入和删除。

2. 栈的结构和实现方式在C语言中，栈可以用数组或链表来实现。

使用数组实现的栈叫作顺序栈，使用链表实现的栈叫作链式栈。

顺序栈使用数组来存储数据，通过一个指针（栈顶指针）来指示栈顶元素的位置。

当有新元素要进栈时，栈顶指针先向上移动一位，然后将新元素存入该位置。

当要弹栈时，栈顶指针下移一位，表示将栈顶元素移除。

链式栈通过链表来存储数据，每个节点包含一个数据项和一个指向下一个节点的指针。

链式栈通过头指针指示栈顶节点的位置，新元素插入时构造一个新节点，并将其指针指向原栈顶节点，然后更新头指针。

弹栈时，只需将头指针指向下一个节点即可。

3. 栈的应用场景栈在计算机科学中有广泛的应用。

以下是一些常见的应用场景：a. 函数调用：在函数调用过程中，函数的参数、局部变量和返回地址等信息会以栈的形式压入内存中，而在函数返回时将逆序地从栈中弹出这些信息。

b. 表达式求值：中缀表达式在计算机中不方便直接求值，而将中缀表达式转换为后缀表达式后，利用栈可以方便地完成求值过程。

c. 内存分配：在程序运行时，栈用于管理变量和函数的内存分配。

当变量定义时，栈会为其分配内存空间，并在其作用域结束时将其回收。

d. 括号匹配：在处理一些语法相关的问题时，栈可以很好地用来检测括号的匹配情况，例如括号是否成对出现、嵌套层次是否正确等。

4. 栈的复杂度分析栈的操作主要包括入栈和出栈两种操作，它们的时间复杂度均为O(1)。

c语⾔stack（栈）和heap（堆）的使⽤详解⼀、预备知识—程序的内存分配⼀个由C/C++编译的程序占⽤的内存分为以下⼏个部分1、栈区（stack）—由编译器⾃动分配释放，存放函数的参数值，局部变量的值等。

其操作⽅式类似于数据结构中的栈。

2、堆区（heap）—⼀般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。

注意它与数据结构中的堆是两回事，分配⽅式倒是类似于链表。

3、全局区（静态区）（static）—全局变量和静态变量的存储是放在⼀块的，初始化的全局变量和静态变量在⼀块区域，未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域。

程序结束后由系统释放。

4、⽂字常量区—常量字符串就是放在这⾥的。

程序结束后由系统释放。

5、程序代码区—存放函数体的⼆进制代码。

⼆、例⼦程序复制代码代码如下://main.cppint a=0; //全局初始化区char *p1; //全局未初始化区main(){intb;栈char s[]="abc"; //栈char *p2; //栈char *p3="123456"; //123456\0在常量区，p3在栈上。

static int c=0； //全局（静态）初始化区p1 = (char*)malloc(10);p2 = (char*)malloc(20); //分配得来得10和20字节的区域就在堆区。

strcpy(p1,"123456"); //123456\0放在常量区，编译器可能会将它与p3所向"123456"优化成⼀个地⽅。

}三、堆和栈的理论知识2.1申请⽅式stack:由系统⾃动分配。

例如，声明在函数中⼀个局部变量int b;系统⾃动在栈中为b开辟空间heap:需要程序员⾃⼰申请，并指明⼤⼩，在c中⽤malloc函数如p1=(char*)malloc(10);在C++中⽤new运算符如p2=(char*)malloc(10);但是注意p1、p2本⾝是在栈中的。

C语言数据结构之栈的基本操作栈是一种特殊的数据结构，它按照后进先出（LIFO）的原则进行操作。

栈可以用数组或链表来实现，下面将介绍栈的基本操作。

1.初始化栈：栈的初始化就是为栈分配内存空间，并将栈顶指针设置为-1（如果是数组实现）或者NULL（如果是链表实现）。

2.判断栈空：栈空表示栈中没有任何元素。

如果栈顶指针等于-1或者NULL，则表示栈空。

3.判断栈满：栈满表示栈中已经存满了元素。

如果栈顶指针等于栈的最大容量减1，则表示栈满。

4. 进栈（push）：进栈操作就是将元素放入栈中。

如果栈不满，则将栈顶指针加1，并将元素放入栈顶位置。

5. 出栈（pop）：出栈操作就是从栈中取出一个元素。

如果栈不空，则将栈顶指针减1，并返回栈顶元素。

6. 获取栈顶元素（getTop）：获取栈顶元素操作不改变栈的状态，只返回栈顶元素的值。

如果栈不空，则返回栈顶元素值；否则，返回空值。

7.清空栈：清空栈操作就是将栈中的所有元素全部出栈，即将栈顶指针设置为-1或者NULL。

8.销毁栈：销毁栈操作是释放栈的内存空间，将栈的指针设置为NULL。

栈的应用：栈在计算机领域有广泛的应用，其中一个常见的应用是函数调用栈。

当一个函数调用另一个函数时，当前函数的状态（包括局部变量、返回地址等）会被压入到栈中。

当被调用函数执行完成后，栈顶的元素会被弹出，然后继续执行调用该函数的代码。

另一个常见的应用是表达式求值。

在表达式求值过程中，需要用到运算符优先级。

我们可以利用栈来处理运算符的优先级。

将运算符入栈时，可以先与栈顶运算符比较优先级，如果栈顶运算符的优先级高于当前运算符，则将栈顶运算符出栈，并继续比较。

这样可以确保栈中的运算符按照优先级从高到低的顺序排列。

此外，栈还可以用于处理括号匹配问题。

当遇到左括号时，将其入栈；当遇到右括号时，判断栈顶元素是否为对应的左括号，如果是，则将栈顶元素弹出，否则表示括号不匹配。

如果最后栈为空，则表示所有括号都匹配。

c语言栈的定义在计算机科学中，栈（Stack）是一种常见的数据结构，它遵循先进后出（Last In First Out，LIFO）的原则。

C语言提供了一种实现栈的方式，即使用数组来模拟栈。

在C语言中，栈可以被定义为一个数组和一个指向栈顶的指针。

栈顶指针指向栈中最新添加的元素，也是栈中下一个将被访问的元素。

栈的大小可以根据实际需求进行调整。

以下是一个简单的C语言栈的定义示例：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;```在上述定义中，我们使用了`#define`预处理指令来定义了一个常量`MAX_SIZE`，用于表示栈的最大大小。

我们还定义了一个结构体`Stack`，其中包含一个整型数组`data`和一个整型变量`top`。

`Stack`结构体中的`data`数组用于存储栈中的元素，而`top`变量则用于指示栈顶的位置。

初始情况下，栈是空的，所以我们可以将`top`的值设置为-1。

接下来，我们可以定义一些栈的基本操作函数，比如入栈（push）、出栈（pop）等。

下面是一个入栈函数的示例：```cvoid push(Stack *stack, int element) {if (stack->top < MAX_SIZE - 1) {stack->top++;stack->data[stack->top] = element;} else {printf("Error: Stack overflow.\n");}}```在上述代码中，`push`函数接受一个指向`Stack`结构体的指针和一个整型变量`element`作为参数。

首先，函数检查栈是否已满（即`top`是否达到了`MAX_SIZE-1`），如果没有满，则将`top`的值加1，并将`element`赋值给`data`数组中的相应位置。

c语言栈的定义摘要：1.栈的概述2.C 语言栈的定义与实现3.栈的基本操作4.栈的应用实例正文：【栈的概述】栈是一种线性数据结构，它按照后进先出（Last In First Out, LIFO）的原则组织数据。

栈可以用来存储程序运行过程中产生的中间结果，或者用于函数调用、表达式求值等场景。

栈在计算机科学中具有广泛的应用，如编译原理、操作系统等。

【C 语言栈的定义与实现】C 语言中，栈可以通过数组或链表来实现。

栈的定义通常包括两个部分：栈顶指针（top）和栈的大小（size）。

栈顶指针用于指向栈顶元素，而栈的大小表示栈可以容纳的元素个数。

【栈的基本操作】栈的基本操作包括：入栈（push）、出栈（pop）、查看栈顶元素（top）和判断栈是否为空（is_empty）。

1.入栈：将一个元素放入栈顶。

2.出栈：弹出栈顶元素。

3.查看栈顶元素：获取栈顶元素的值，但不将其弹出。

4.判断栈是否为空：检查栈中是否还有元素。

【栈的应用实例】栈在程序设计中有很多应用，下面以计算表达式值为例，展示栈如何用于表达式求值。

假设有一个表达式：a + b * c，我们需要计算该表达式的值。

首先，我们需要将表达式中的每个操作数和运算符入栈。

然后，按照栈的出栈顺序，进行运算。

具体过程如下：1.将"a" 入栈。

2.将"+" 入栈。

3.将"b" 入栈。

4.将"*" 入栈。

5.将"c" 入栈。

6.弹出栈顶元素"+"，进行加法运算，结果入栈。

7.弹出栈顶元素"b"，进行乘法运算，结果入栈。

8.弹出栈顶元素"c"，进行乘法运算，结果入栈。

9.弹出栈顶元素，得到表达式的值：a + b * c。

【结语】栈作为一种重要的数据结构，在C 语言编程中具有广泛的应用。

c语言实现栈详细代码栈（Stack），又称堆栈，是一种后进先出（LIFO，Last In First Out）的数据结构，它只允许在一段端点进行插入和删除操作，这个端点被称为栈顶。

C语言实现栈的基本思路是建立一个结构体，结构体中包含一个数组和栈顶指针top。

数组用来存放栈中元素，top指针指向栈顶元素的下标。

实现栈的操作包括压栈（push）、出栈（pop）和获取栈顶元素（get_top）。

下面是详细代码：```#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100 //栈的最大长度typedef struct stack {int data[MAX_SIZE]; //栈中元素int top; //栈顶指针} Stack;//初始化栈void init(Stack *s) {s->top = -1; //栈顶指针初始化为-1，表示栈为空}//判断栈是否为空int is_empty(Stack *s) {return s->top == -1;}//判断栈是否已满int is_full(Stack *s) {return s->top == MAX_SIZE-1;}//压栈void push(Stack *s, int value) {if (is_full(s)) {printf("Stack is full, cannot push!\n");return;}s->data[++(s->top)] = value; //栈顶指针先加1，再将元素入栈}//出栈void pop(Stack *s) {if (is_empty(s)) {printf("Stack is empty, cannot pop!\n");}s->top--; //栈顶指针减1，表示栈顶元素已删除}//获取栈顶元素int get_top(Stack *s) {if (is_empty(s)) {printf("Stack is empty, cannot get top element!\n"); return -1;}return s->data[s->top]; //返回栈顶元素}int main() {Stack s;init(&s); //初始化栈for (i = 0; i < 5; i++) {push(&s, i); //压入5个元素}printf("Top element: %d\n", get_top(&s)); //获取栈顶元素while (!is_empty(&s)) {printf("%d ", get_top(&s)); //依次输出栈中元素pop(&s); //弹出栈顶元素}return 0;}```代码中定义了一个结构体，包含一个整型数组data和一个整型变量top，数组用来存放栈中元素，top表示栈顶指针。

c语言顺序栈实现表达式求值下面是C语言顺序栈实现表达式求值的代码示例：```c#include <stdio.h>#include <stdlib.h>#define MAX_EXPR_LEN 100typedef struct {double* data; // 存储数据的数组指针int top; // 栈顶指针int maxSize; // 栈的最大容量} Stack;// 初始化栈void init(Stack* stack, int maxSize) {stack->data = (double*)malloc(maxSize * sizeof(double));stack->top = -1;stack->maxSize = maxSize;}// 判断栈是否为空int isEmpty(Stack* stack) {return stack->top == -1;}// 判断栈是否已满int isFull(Stack* stack) {return stack->top == stack->maxSize - 1;}// 入栈void push(Stack* stack, double value) {if (isFull(stack)) {printf("Stack is full.\n");return;}stack->data[++stack->top] = value;}// 出栈double pop(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}return stack->data[stack->top--];}// 获取栈顶元素double top(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}return stack->data[stack->top];}// 运算符优先级比较int priority(char op) {switch(op) {case '+':case '-':return 1;case '*':case '/':return 2;case '(':case ')':return 0;default:return -1;}}// 执行操作double operate(double operand1, double operand2, char op) { switch(op) {case '+':return operand1 + operand2;case '-':return operand1 - operand2;case '*':return operand1 * operand2;case '/':return operand1 / operand2;default:return 0;}}// 表达式求值double evaluateExpression(char* expression) {Stack operandStack; // 操作数栈Stack operatorStack; // 运算符栈init(&operandStack, MAX_EXPR_LEN);init(&operatorStack, MAX_EXPR_LEN);int i = 0;while (expression[i] != '\0') {if (expression[i] >= '0' && expression[i] <= '9') {// 处理数字double num = 0;while (expression[i] >= '0' && expression[i] <= '9') {num = num * 10 + (expression[i] - '0');i++;}push(&operandStack, num);} else if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*' || expression[i] == '/') {// 处理运算符while (!isEmpty(&operatorStack) && priority(expression[i]) <= priority(top(&operatorStack))) {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}push(&operatorStack, expression[i]);i++;} else if (expression[i] == '(') {// 处理左括号push(&operatorStack, expression[i]);i++;} else if (expression[i] == ')') {// 处理右括号while (top(&operatorStack) != '(') {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}// 弹出左括号pop(&operatorStack);i++;} else {i++;}}// 处理剩余的运算符while (!isEmpty(&operatorStack)) {char op = pop(&operatorStack);double operand2 = pop(&operandStack);double operand1 = pop(&operandStack);double result = operate(operand1, operand2, op);push(&operandStack, result);}double result = pop(&operandStack);return result;}int main() {char expression[MAX_EXPR_LEN];printf("请输入表达式：");fgets(expression, sizeof(expression), stdin);double result = evaluateExpression(expression);printf("表达式的结果为：%lf\n", result);return 0;}```使用该代码，可以实现对不带括号的四则运算表达式进行求值。