王道数据结构代码题（C语言） 栈和队列综合应用

1.

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

struct Stack{
	NODETYPE* arr;	//内存首地址
	int  len;	//栈的容量
	int top; 	//栈的下标
};

struct Squeue {
	NODETYPE* arr;
	int front, rear;
};
//双链表
struct DLink {
	NODETYPE data;
	DLink* next;
	DLink* pre;
};
//单链表
struct Link {
	NODETYPE data;
	Link* next;
}; 

bool matchBracket(LinkQueue *lq, Stack *s) {
	char letterQ, letterS;
	bool isEmpty(LinkQueue *);
	bool deQueue(LinkQueue *, char *);

	bool push(Stack *, char);
	char top(Stack *);
	bool pop(Stack *);
	bool empty(Stack *);
	while (!isEmpty(lq)) {//如果队列不空
		deQueue(lq, &letterQ);//取出队首元素
		if (letterQ == '(' || letterQ == '{' || letterQ == '[') {//如果是左括号，入栈
			push(s, letterQ);
		}
		else {//如果是右括号，取出栈顶元素对比
			if (empty(s)) {
				return false;
			}
			letterS = top(s);
			pop(s);
			switch (letterQ) {
			case ')': if (letterS != '(')return false; break;
			case ']': if (letterS != '[' ) return false; break;
			case '}': if (letterS != '{' ) return false; break;
			default:break;
			}
		}
	}
	if (empty(s)) {
		return true;
	}
	else {
		return false;
	}
}
int main() {
	int n;//栈的大小
	char letter;
	struct LinkQueue *lq;
	struct Stack *s;
	LinkQueue *create();
	bool enQueue(LinkQueue *, char);
	void printQ(LinkQueue *);
	Stack *createStack(int);
	lq = create();
	printf("请输入栈的大小：n=");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		printf("请输入第%d个括号:",i+1);
		scanf("\n%c", &letter);
		enQueue(lq, letter);
	}
	printQ(lq);
	printf("\n");
	s = createStack(n);
	if (matchBracket(lq, s)) {
		printf("该算术表达式配对");
	}
	else {
		printf("该算术表达式不配对");
	}
	return 0;
}

2.

#include <stdio.h>
#include <stdlib.h>
struct Stack{
	NODETYPE* 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;
}

3.

#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;
}

4.

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20

struct Squeue {
	NODETYPE* arr;
	int front, rear;
};

void manageCar(int* arrCar, int* arrArrange, Squeue* sq) {//这里用栈会有问题，所有车辆应该是遵循先到先上的原则，而栈的特性是先进后出，所以应该用队列更合适
	int i = 0, passengerCar = 0, j = 0;
	int c;//接收出队车
	bool enQueue(Squeue*, int, int);
	bool isEmpty(Squeue*);
	bool deQueue(Squeue*, int*, int);
	for (; arrCar[i] == 1 || arrCar[i] == 2; i++) {
		if (arrCar[i] == 2 && passengerCar < 4) {//如果是货车且之前还没有4辆客车，入栈
			enQueue(sq, arrCar[i],MAXSIZE);
		}
		else {//若是客车，直接入arrArrange
			if (passengerCar == 4) {//若之前已有连续4辆客车，出队入货车
				if (!isEmpty(sq)) {
					deQueue(sq,&c,MAXSIZE);
					arrArrange[j++] = c;
					passengerCar = 0;//重新计数
				}
			}
			arrArrange[j++] = arrCar[i];
			passengerCar++;//连续客车数加一
		}
	}
	while (!isEmpty(sq)) {//队内元素不空，加入到arrArrange
		deQueue(sq, &c, MAXSIZE);
		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，接收重排的车队
	Squeue* sq = (Squeue*)malloc(sizeof(Squeue));
	Squeue* createQueue(int);
	sq = createQueue(MAXSIZE);
	manageCar(arrCar, arrArrange, sq);
	for (int i = 0; i < 10; i++) {//取10辆车出来
		printf("%d ", *(arrArrange + i));
	}
	return 0;
}