王道数据结构【栈队列及其应用】部分代码实现（C语言）

已于 2022-08-01 17:17:16 修改
阅读量745 收藏 6
点赞数
分类专栏： 数据结构Code 文章标签： 数据结构 c语言
于 2022-07-28 23:50:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014297502/article/details/126046468
版权

数据结构专栏：

  1. 王道数据结构【顺序表】部分代码实现（C语言）
  2. 王道数据结构【链表】部分代码实现（C语言）
  3. 王道数据结构【栈队列及其应用】部分代码实现（C语言）
  4. 王道数据结构【二叉树】部分代码实现（C语言）
  5. 王道数据结构【图】部分代码实现（C语言）
  6. 王道数据结构【查找排序】部分代码实现（C语言）

本章目录

判断链表是否中心对称

/*
	设单链表的表头指针为h，节点结构由data和next两个域构成，其中data域为字符型。
	试设计算法判断该链表的全部n个字符是否是中心对称，例如xyx，xyyx都是中心对称。

	分析：
		我们可以利用栈的先进后出的特性来搞定这道题，我们设置两个快慢指针，fast和slow
		之前我们就用过这种方法，用以找到中间节点，之后将slow节点之后的节点依次入栈，
		fast指针重新指向首节点，然后fast和栈内元素一一比较，若存在不同，则不对称。
*/
struct Link {
	union {
		char letter;
	}type;
	struct Link *next;
};
struct Stack {
	char *arr;
	int len;
	int top;
};
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void isSymmetry(Link *h) {
	int size;
	struct Stack *s;
	Stack *createStack(int);
	bool push(Stack *,char);
	bool empty(Stack *);
	char *top(Stack *);
	bool pop(Stack *);
	void destory(Stack *);
	printf("请输入要创建的栈的大小：size=");
	scanf("%d",&size);
	s = createStack(size);
	struct Link *fast = h->next, *slow = h->next;
	while (fast->next&&fast->next->next) {
		fast = fast->next->next;
		slow = slow->next;
	}
	fast = h->next;
	while (slow->next) {//将中间元素的后面节点依次入栈
		push(s,slow->next->type.letter);
		slow = slow->next;//我总是忘记往下走
	}
	while (!empty(s)) {
		if (fast->type.letter != *top(s) ) {
			printf("该链表非中心对称");
			break;
		}
		fast = fast->next;
		pop(s);
	}
	if(empty(s))printf("该链表是中心对称的");
	destory(s);//最后销毁栈
}
int main() {
	struct Link *head;
	Link *createLink(int);
	head = createLink(1);
	isSymmetry(head);
	return 0;
}

实现共享栈

/*
	设有两个栈s1、s2都采用顺序栈方式，并共享一个存储区，大小为max，为了尽量利用空间，减少溢出的可能，
	可采用栈顶相向、迎面增长的存储方式，试设计s1、s2有关入栈和出栈的算法。
	分析：
		
*/
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#define TYPE char 
struct Stack
{
	TYPE* arr;	//内存首地址
	int top[2]; 	//栈的下标
};

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	struct Stack *stack = (struct Stack*)malloc(sizeof(struct Stack));//给栈分配空间
	stack->arr = (TYPE *)malloc(sizeof(TYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->top[0] = -1;//栈顶下标，当前无元素，故为-1
	stack->top[1] = size;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top[1]-stack->top[0] == 1;
}
//判断栈空
bool empty(int i,Stack *stack,int size) {
	switch (i) {
	case 0:
		return stack->top[0] == -1; 
	case 1:
			return stack->top[0] == size;

	}
}
//入栈(具体值)
bool push(Stack *stack, TYPE data,int i) {
	if (full(stack)) return false;
	switch (i) {
	case 0:
		*(stack->arr + ++stack->top[i]) = data;
	case 1:
		*(stack->arr + --stack->top[i]) = data;
	}
	return true;
}

//出栈
bool pop(int i,Stack *stack,int size) {
	if (empty(i,stack,size)) return false;
	switch (i) {
	case 0:
		stack->top[i]--;
	case 1:
		stack->top[i]++;
	}
	return true;

}

创建栈


#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#define TYPE int
//#define TYPE biTree*
//#define TYPE char
//#define TYPE Recursion
struct biTree {
	char data;
	struct biTree *lchild;
	struct biTree *rchild;
};
struct Recursion {
	int no;
	int val;
};
struct Stack
{
	TYPE* arr;	//内存首地址
	int  len;	//栈的容量
	int top; 	//栈的下标
};

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	struct Stack *stack = (struct Stack*)malloc(sizeof(struct Stack));//给栈分配空间
	stack->arr = (TYPE *)malloc(sizeof(TYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->len = size;//栈容量
	stack->top = -1;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top + 1 >= stack->len;
}
//判断栈空
bool empty(Stack *stack) {
	return stack->top == -1;
}
//入栈
bool push(Stack *stack, TYPE p) {
	if (full(stack)) return false;
	*(stack->arr + ++stack->top) = p;
	return true;
}

//出栈
bool pop(Stack *stack) {
	if (empty(stack)) return false;
	stack->top--;
	return true;

}

//查看栈顶元素
TYPE top(Stack *stack) {
	if (empty(stack)) return NULL;
	return *(stack->arr + stack->top);
}

//销毁
void destory(Stack *stack) {
	free(stack->arr);
	free(stack);

}
//判断是否含有某个元素
bool contain(Stack *stack, TYPE r) {
	if (empty(stack)) return false;
	for (int i = stack->top; i >= 0; i--) {
		if (r == *(stack->arr + i) ){//疯了，我居然把==写成了=
			return true;
		}
	}
	return false;
}

创建链队

/*
	此文件用于创建一个链式队列
	分析：
		我们需要创建一个链表，然后设置front、rear指针，用来模拟入队出队的过程
*/
//#define TYPE biTree* 
#define TYPE char
//#define TYPE int
struct biTree {//新增树节点
	char data;
	struct biTree *lchild;
	struct biTree *rchild;

};
struct Link {
	//TYPE data;
	TYPE node;
	struct Link *next;
};
struct LinkQueue {
	struct Link *front, *rear;
};
#include <stdio.h>
#include <stdlib.h>

//创建一个空链表
Link* createLink() {
	int n, data;
	char letter;
	struct Link *q;
	struct Link *head = (struct Link*) malloc(sizeof(struct Link));
	head->next = NULL;
	q = head;
	return head;
}
//创建链队
LinkQueue *create() {
	struct Link *h,*p;
	struct LinkQueue *lq=(struct LinkQueue *)malloc(sizeof(struct LinkQueue));
	h = createLink();
	p = h->next;
	lq->front = lq->rear = h;
	return lq;
}
//判断空
bool isEmpty(LinkQueue *lq) {
	return lq->front == lq->rear;
}
//入队
bool enQueue(LinkQueue *lq,TYPE data) {//队尾插入
	struct Link *newd = (struct Link *)malloc(sizeof(struct Link));
	newd->node = data;
	lq->rear->next = newd;
	lq->rear = newd;
	lq->rear->next = NULL;
	return true;
}
//出队
bool deQueue(LinkQueue *lq,TYPE *data) {
	if (isEmpty(lq))return false;
	struct Link *p = lq->front->next;//保存下一个节点
	*data = lq->front->next->node;//取出队首节点值
	lq->front->next = p->next;//删除队首节点
	if (lq->rear==p) {
		lq->rear = lq->front;
	}
	free(p);
	return true;
}
//打印队列中元素
void printQ(LinkQueue *lq) {
	Link *p = lq->front->next;
	while (p!=NULL) {
		printf("%c",p->node);
		p = p->next;
	}
};

tag队列

/*
	若希望循环队列中的元素都能得到利用，则需设置一个标志域tag，并以tag 的值为0或1来区分队头指针front和队尾指针rear
	相同时的队列状态是“空”还是“满”。试编写此结构相应的入队和出队算法。
	分析：
		
*/
#include <stdio.h>
#include <stdlib.h>
#define TYPE int 
struct Squeue {
	TYPE *arr;
	int front, rear;
	int tag;
};

//创建队列
Squeue *create(int n) {
	struct Squeue *sq = (struct Squeue *)malloc(sizeof(struct Squeue));
	sq->arr = (TYPE *)malloc(sizeof(TYPE)*n);//数组大小
	sq->front = 0;
	sq->rear = 0;
	sq->tag = 0;
	return sq;
}
//判断队满
bool isFull(Squeue *sq, int maxSize) {
	return (sq->rear == sq->front) && (sq->tag == 1);
}
//判断队空
bool isEmpty(Squeue *sq) {
	return (sq->front == sq->rear) && sq->tag==0;
}
//判断队列中元素个数
int count(Squeue *sq, int maxSize) {
	return (sq->rear - sq->front + maxSize) % maxSize;
}
//入队
bool enQueue(Squeue *sq, int data, int maxSize) {
	if (isFull(sq, maxSize)) return false;
	sq->arr[sq->rear] = data;
	sq->rear = (sq->rear + 1) % maxSize;
	sq->tag = 1;
	return true;
}
//出队
bool deQueue(Squeue *sq, int &data, int maxSize) {
	if (isEmpty(sq)) return false;
	data = sq->arr[sq->front];
	sq->front = (sq->front + 1) % maxSize;
	sq->tag = 0;
	return true;
}

利用栈逆置队列中的元素

//createStack.cpp

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#define TYPE int
//#define TYPE biTree*
//#define TYPE char
//#define TYPE Recursion
struct biTree {
	char data;
	struct biTree *lchild;
	struct biTree *rchild;
};
struct Recursion {
	int no;
	int val;
};
struct Stack
{
	TYPE* arr;	//内存首地址
	int  len;	//栈的容量
	int top; 	//栈的下标
};

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	struct Stack *stack = (struct Stack*)malloc(sizeof(struct Stack));//给栈分配空间
	stack->arr = (TYPE *)malloc(sizeof(TYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->len = size;//栈容量
	stack->top = -1;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top + 1 >= stack->len;
}
//判断栈空
bool empty(Stack *stack) {
	return stack->top == -1;
}
//入栈
bool push(Stack *stack, TYPE p) {
	if (full(stack)) return false;
	*(stack->arr + ++stack->top) = p;
	return true;
}

//出栈
bool pop(Stack *stack) {
	if (empty(stack)) return false;
	stack->top--;
	return true;

}

//查看栈顶元素
TYPE top(Stack *stack) {
	if (empty(stack)) return NULL;
	return *(stack->arr + stack->top);
}

//销毁
void destory(Stack *stack) {
	free(stack->arr);
	free(stack);

}
//判断是否含有某个元素
bool contain(Stack *stack, TYPE r) {
	if (empty(stack)) return false;
	for (int i = stack->top; i >= 0; i--) {
		if (r == *(stack->arr + i) ){//疯了，我居然把==写成了=
			return true;
		}
	}
	return false;
}

括号匹配

// createStack.cpp
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#define TYPE int
//#define TYPE biTree*
//#define TYPE char
//#define TYPE Recursion
struct biTree {
	char data;
	struct biTree *lchild;
	struct biTree *rchild;
};
struct Recursion {
	int no;
	int val;
};
struct Stack
{
	TYPE* arr;	//内存首地址
	int  len;	//栈的容量
	int top; 	//栈的下标
};

/* --------------以下为实现函数--------------------*/
//创建一个栈
Stack *createStack(int size) {
	struct Stack *stack = (struct Stack*)malloc(sizeof(struct Stack));//给栈分配空间
	stack->arr = (TYPE *)malloc(sizeof(TYPE)*size);//给内存首地址分配空间，大小用户指定
	stack->len = size;//栈容量
	stack->top = -1;//栈顶下标，当前无元素，故为-1
	return stack;
}
//判断栈满
bool full(Stack *stack) {
	return stack->top + 1 >= stack->len;
}
//判断栈空
bool empty(Stack *stack) {
	return stack->top == -1;
}
//入栈
bool push(Stack *stack, TYPE p) {
	if (full(stack)) return false;
	*(stack->arr + ++stack->top) = p;
	return true;
}

//出栈
bool pop(Stack *stack) {
	if (empty(stack)) return false;
	stack->top--;
	return true;

}

//查看栈顶元素
TYPE top(Stack *stack) {
	if (empty(stack)) return NULL;
	return *(stack->arr + stack->top);
}

//销毁
void destory(Stack *stack) {
	free(stack->arr);
	free(stack);

}
//判断是否含有某个元素
bool contain(Stack *stack, TYPE r) {
	if (empty(stack)) return false;
	for (int i = stack->top; i >= 0; i--) {
		if (r == *(stack->arr + i) ){//疯了，我居然把==写成了=
			return true;
		}
	}
	return false;
}

车厢调度

/*
	利用栈进行车厢调度，使软座全部位于硬座前面
	分析：
		原文题目较长，但仔细分析后，这道题是一类较为简单的题。这里其实也并不需要用到栈的先入后出的特性，仅仅需要将硬座
		暂存，让软座先出去而已，所以将栈换成其他结构也是可以的，只要能够暂存数据。但这里题目要求用栈。
		为了模拟列车座位，我们采用两个数组来存储，数组A为入口处火车，数组B为出口处火车，A内数据依次入栈，若为硬座则压入
		栈，若为软座则直接进入B，最后栈内元素全部出栈，入B，至此，完成要求。
*/
#include <stdio.h>
#include <stdlib.h>
struct Stack {
	char *arr;
	int len;
	int top;
};
void trainArrange(char *arrA,char *arrB,Stack *s) {//传入入口车厢，出口车厢，栈
	int i = 0, j = 0;
	char *c;//接收出栈硬座
	bool push(Stack *,char );
	char *top(Stack *);
	bool pop(Stack *);
	bool empty(Stack *);
	while (i<10) {
		if (arrA[i]=='H') {//硬座，入栈
			push(s,arrA[i]);
		}
		else {//软座，入B
			arrB[j++] = arrA[i];
		}
		i++;
	}
	while (!empty(s)) {//若栈中还有硬座，全部入B
		c = top(s);
		pop(s);
		arrB[j++] = *c;
	}

}
int main() {
	char arrA[10] = {'H','S','S','H','H','S','S','S','H','H' };//用H代表硬座，S代表软座
	char arrB[10] = { 0 };//B数组初始为空
	Stack *createStack(int);
	Stack *s;
	s = createStack(10);//创建栈
	trainArrange(arrA,arrB,s);
	for (int i = 0; i < 10;i++) {//打印重排后的车厢
		printf("%c",arrB[i]);

	}
	return 0;
}

利用栈实现递归函数的非递归计算

/*
	利用一个栈实现以下递归函数的非递归计算
	分析：
		这里我们需要使用栈的先进后出特性。我们可以看出，从n=2开始，每一个值便都与前两个值挂钩，且式子不变，我们
		可以从栈顶到栈底依次边出栈边计算，直至栈底，便可以得出最终结果。
		
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
struct Recursion {
	int no;
	int val;
};
struct Stack {
	Recursion *arr;
	int len;
	int top;
};
int getP(Stack *s,int n,int x) {//该算法函数,传入栈，n和x
	if (n==0) {
		return 1;
	}
	int fv1 = 1, fv2 = 2 * x;
	for (int i = n; i >= 2;i--) {//将序号入栈，从上至下，从2到n
		s->top++;
		s->arr[s->top].no = i;
	}
	while (s->top>=0) {//边出栈边计算
		s->arr[s->top].val = 2 * x*fv2 - 2 * (s->arr[s->top].no - 1)*fv1;
		fv1 = fv2;
		fv2 = s->arr[s->top].val;
		s->top--;
	}
	return fv2;
}
int main() {
	Stack *s;
	//声明各类方法
	Stack *createStack(int);
	bool push(Stack *,Recursion *);
	bool full(Stack *);
	bool empty(Stack *);
	bool top(Stack *);
	bool pop(Stack *);

	int n, x;//题目所要用到的n和x
	int p;//用于接收结果
	printf("请输入n和x: \n");
	printf("n=");
	scanf("%d",&n);
	printf("x=");
	scanf("%d", &x);

	//创建大小为n的栈
	s = createStack(n);
	p=getP(s,n,x);
	printf("%d",p);
	return 0;
}

车辆调度

/*
	栈和队列应用最后一题：汽车轮渡，要求：每次10辆，客车优先于货车，每上4辆客车才能上1辆货车，客车不足4辆时，货车代替
	货车不足时，允许客车都上
	分析：
		这仍然是一类排序的问题，王道书上的解答可以，核心意思就是客车和货车分为两个队列，客车队列出4辆，紧接着货车
		队列出一辆；当出现客车不足时，出货车队列代替，当货车不足时，继续出客车队列。代码也不难实现，
		这里我想分享一下自己的想法，我们上一题做过货车车厢调整的算法，利用栈将软座调整到硬座的前面，这里我们可以仿造
		相当于我们要将客车调整到货车的前面，只是有限制，每4辆客车就需要插入一辆货车，而面对特殊情况，我们也可以很好
		地处理，直接将剩余车辆（无论客车还是货车）直接连接到队列后面。
		之后我们从队列中取10辆车即可
*/
#include <stdio.h>

struct Stack {
	int *arr;
	int len;
	int top;
};
void manageCar(int *arrCar, int *arrArrange, Stack *s) {
	int i = 0, passengerCar = 0, j = 0;
	int *c;//接收出栈硬座
	bool push(Stack *, int);
	int *top(Stack *);
	bool pop(Stack *);
	bool empty(Stack *);
	for (; arrCar[i] == 1 || arrCar[i] == 2; i++) {
		if (arrCar[i] == 2 && passengerCar < 4) {//如果是货车且之前还没有4辆客车，入栈
			push(s, arrCar[i]);
		}
		else {//若是客车，直接入arrArrange
			if (passengerCar == 4) {//若之前已有连续4辆客车，出栈入货车
				if (!empty(s)) {
					c = top(s);
					pop(s);
					arrArrange[j++] = *c;
					passengerCar = 0;//重新计数
				}
			}
			arrArrange[j++] = arrCar[i];
			passengerCar++;//连续客车数加一
		}
	}
	while (!empty(s)) {//栈内元素不空，加入到arrArrange
		c = top(s);
		pop(s);
		arrArrange[j++] = *c;
	}

}
int main() {

	int arrCar[] = { 2,1,2,1,1,1,1,2,2,2,1,1 };//我们用1代表客车，用2发表货车,arrCar代表当前的车序列，然后我们需要重排
	int arrArrange[20] = { 0 };//初始化为0，接收重排的车队
	Stack *createStack(int);
	Stack *s;
	s = createStack(20);//创建一个栈
	manageCar(arrCar, arrArrange, s);
	for (int i = 0; i < 10; i++) {//取10辆车出来
		printf("%d ", *(arrArrange + i));
	}
	return 0;
}
落难Coder
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【2023王道数据结构】【栈的应用】利用栈实现括号匹配C、C++完整实现（可直接运行）
CSDN 精品推荐
04-30 490
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ 如果需要完整代码可以关注下方公众号，后台回复“代码”即可获取，阿光期待着您的光临~ ✌ 题目及题解持续更新中 【2023王道数据结构目录】课后算法设计题C、C++代码实现完整版大全 题目： 栈的应用——实现括号匹配利用栈实现括号匹配C、C++完整实现（可直接运行） 解题思路： >遇到左括号将其压入栈中 >当遇到右括号，则判断此时栈是否为空 >如果是空栈，则不匹配 >如果非空，则弹出栈顶元素，与当前右括号进行匹配 .
【王道数据结构】第三章 栈和队列
weixin_48434658的博客
08-22 731
【王道数据结构】第三章 栈和队列
王道数据结构习题代码3.3.7(栈和队列的应用)
weixin_46503238的博客
05-22 315
第一题(括号匹配) #include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; } SqStack; bool InitStack(SqStack *s) { s->top=-1;//初始化栈 }
数据结构--队列的实现（C语言）
COOL_jack的博客
06-18 301
目录声明一 队列的基本概念1.队列的基本定义2.队列的基本操作二 队列的顺序存储结构1.代码实现（C语言）2.循环队列三 队列的链式存储结构1.代码实现（C语言）四 双端队列 声明 以下内容仅供学习，如有侵权，联系作者删除。 参考文献：王道考研系列数据结构、B站up主：C语言技术网 链接: C语言技术网 一 队列的基本概念 1.队列的基本定义 队列（Queue）：也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。 队头（Front）：允许删除的一端。 队尾（Rear）：允许插入的一
2022 数据结构与算法《王道》学习笔记 （九）栈和队列的应用
小超嵌入式笔记
03-08 812
1.栈在括号匹配中的应用 2.栈在表达式求值中的应用 3.栈在递归中的应用 4.队列在层次遍历中的应用 5.队列在计算机系统中的应用
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
C实现数据结构王道第一章代码(自己记录的)
08-24
"C实现数据结构王道第一章代码(自己记录的)"这个压缩包文件很可能是对经典教材《数据结构王道》中第一章节内容的C语言实现。这里，我们将深入探讨这一章可能涵盖的知识点。 第一章通常会介绍数据结构的基本概念和...
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
考研数据结构代码大全
10-26
【考研数据结构代码大全】是针对计算机专业考研者准备的一份综合性的数据结构代码集合，主要涵盖数据结构的基础部分，包括列表、栈、队列、树、图、查找、字符串和排序等多种数据结构的C语言实现。这些内容是408...
王道数据结构第一章《绪论》
05-19
### 数据结构概述与基本概念 #### 1.1 数据结构的基本概念 - **数据**: 数据是计算机能够识别和处理的信息载体。它可以是数字、字符、符号等任何形式的信息。 - **数据元素**: 数据的基本单位，例如在学生信息管理...
数据结构中链栈的实现
11-05
数据结构中链栈的实现，C语言在VC6.0下编译通过
考研王道数据结构代码.zip
11-26
里面是2020王道数据结构课后习题可执行代码。https://blog.csdn.net/qq_40285036 可以参考这个博客一起学习。
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
王道数据结构练习-通过链表实现队列（c++版）
希望可以给你点帮助
07-11 256
王道数据结构练习-通过链表实现队列（c++版）
王道3.3 栈的应用以及队列的应用
沉晨尘宸的博客
08-02 349
从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数。② 选择下一个运算符，按照**[左操作数 右操作数 运算符]**的方式组合成一个新的操作数。② 选择下一个运算符，按照**[运算符 左操作数 右操作数]**的方式组合成一个新的操作数。③ 若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①。A+B*(C-D)-E/F 前缀： +A-*B-CD/EF。② 若扫描到操作数就压入栈，并回到①，否则执行③。① 确定中缀表达式各个运算符的运算顺序。.
2022版王道数据结构算法题C语言代码实现-第3章-栈和队列
DanielSYC的博客
10-03 737
概述 这是2022版王道数据结构的第3章——栈和队列的算法大题的C语言代码实现，主要分为栈，队列和栈和队列的应用三部分。代码都经过了简单的测试，基本上不会有太大问题。 编译环境为gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0，文件目录结构如下： ch3 ├── 3-1-stack.c ├── 3-2-queue.c ├── 3-3-application.c ├── application_test.c ├── queue_test.c └── stack_test.c 栈
【王道C语言中级阶段+数据结构】队列代码笔记
Alan_Dr的博客
02-23 836
【王道C语言中级阶段+数据结构】顺序队列、循环队列、链式队列的实现
王道数据结构代码3.1.5(栈)
weixin_46503238的博客
05-15 359
第三题(入栈出栈序列的合法性) #include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50 //定义栈中元素最大个数 typedef int ElemType; bool Judge(char A[]) { int i=0; int j=0,k=0; while(A[i]!='\0') { switch(A[i]){
王道数据结构 队列 ★★★★★
旅途
06-20 384
队列(Queue)：是一种只允许在一端插入（队尾），在另一端删除（队头）的线性表。
王道数据结构代码实现C语言
最新发布
07-29
王道数据结构提供了一系列的代码实现，包括顺序表、链表、栈队列、二叉树、图以及查找排序等部分的代码实现。\[1\]这些代码实现使用了C语言来实现各种数据结构的功能。 例如，可以使用createDouLoopLink函数来创建...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落难Coder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值