c语言实现栈的一般操作(王道课后题)

#include <stdio.h>
#include <stdlib.h>
#include <string>
//调用命名空间std内定义的所有标识符
using namespace std;
#define MaxSize 50
#define Elemtype char

//栈的顺序存储
typedef struct {
	Elemtype data[MaxSize];
	int top;
} SqStack;

//栈的链式存储
typedef struct LinkNode {
	Elemtype data;
	struct LinkNode* next;
}*LinkStack;

typedef struct LNode {
	Elemtype data;
	struct LNode* next;
	//仅设置了前驱节点,没有写建立方法
	struct LNode* prior;
}LNode, * LinkedList;

//初始化
void InitStack(SqStack& S) {
	S.top = -1;
}
//判断栈空
bool StackEmpty(SqStack S) {
	if (S.top == -1) {
		return true;
	}
	else {
		return false;
	}
}
//入栈
bool Push(SqStack& S, Elemtype e) {
	if (S.top == MaxSize - 1) {
		return false;
	}
	S.data[++S.top] = e;
	return	true;
}
//出栈
bool Pop(SqStack& S, Elemtype& e) {
	if (S.top == -1) {
		return false;
	}
	e = S.data[S.top--];
	return true;
}
//读栈顶元素
bool GetTop(SqStack S, Elemtype& e) {
	if (S.top == -1) {
		return false;
	}
	e = S.data[S.top];
	return true;
}
//以I和O代表入栈和出栈,判断所给序列是否合法
bool Judge(char A[]) {
	int i = 0;
	int j = 0, k = 0;
	//数组结束的标识
	while (A[i] != '\0') {
		switch (A[i]) {
		case 'I':
			j++; break;
		case 'O':
			k++; break;
			if (k > j) {
				printf("序列非法\n");
				return false;
			}
		}
		i++;
	}
	if (j != k) {
		printf("序列非法");
		return false;
	}
	else {
		printf("合法");
		return true;
	}
}

//判断带头结点单链表全部n个字符是否中心对称(eg:xyx,xyyx都是中心对称)
bool centrosymmetry(LinkedList L, int n) {
	int i;
	char* s = new char[n / 2];
	LNode* p = L->next;
	for (i = 0; i < n / 2;i++) {
		s[i] = p->data;
		p = p->next;
	}
	i--;
	if (n % 2 == 1) {
		p = p->next;
	}
	while (p!=NULL&&s[i]==p->data) {
		i--;
		p = p->next;
	}
	if (i == -1) {
		return true;
	}
	else {
		return false;
	}
}

//两个栈s1和s2都采用顺序栈的方式,共享一个存储区[0,...,MaxSize-1],
//采用栈顶相向,迎面增长的存储方式,设计s1和s2有关入栈和出栈的操作算法


typedef struct {
	Elemtype stack[MaxSize];
	//top 两个栈顶指针
	int top[2];
}stk;
stk s;
   //i 为栈号,0表示s1  1表示s2
int push(int i, Elemtype e) {
	if (i<0||i>1) {
		printf("栈号输入错误");
		return 0;
	}
	if (s.top[1] - s.top[0] == 1) {
		printf("栈满");
		return 0;
	}
	switch (i) {
	case 0:s.stack[++s.top[0]] = e; return 1; break;
	case 1:s.stack[--s.top[1]] = e; return 1; break;
	default:
		break;
	}
}

//
Elemtype pop(int i) {
	if (i < 0 || i>1) {
		printf("栈号输入错误");
		return 0;
	}
	switch (i) {
	case 0:
		if (s.top[0]==-1) {
			printf("栈空");
				return -1;
		}
		else {
			return s.stack[s.top[0]--];
		}
	case 1:
		if (s.top[1]==MaxSize) {
			printf("栈空");
			return -1;
		}
		else {
			return s.stack[s.top[1]++];
		}
	default:
		break;
	}
}

/*
  一个算数表达式中包含圆括号,方括号,花括号3种类型的括号,编写一个算法来判别
  表达式中的括号是否匹配,以字符"\0" 作为算数表达式的结束符

  (扫描每个字符,遇到左括号进栈,右括号时检查栈顶元素是否为相应的左括号,
  是则退栈,否则匹配错误,最后栈不为空也错误)
*/
bool BracketsCheck(char* str) {
	//动态数组用指针
	SqStack S;
	InitStack(S);
	int i = 0;
	Elemtype e = '0';
	while (str[i]!='\0') {
		switch (str[i]) {
		case '(':
			Push(S, '('); break;
		case '[':
			Push(S, '['); break;
		case '{':
			Push(S, '{'); break;

		case ')':
			Pop(S, e);
			if (e!='(') {
				printf("括号不匹配\n");
				return false;
			}
			break;
		case ']':
			Pop(S, e);
			if (e != '[') {
				printf("括号不匹配\n");
				return false;
			}
			break;
		case '}':
			Pop(S, e);
			if (e != '{') {
				printf("括号不匹配\n");
				return false;
			}
			break;
		default:
			break;
		}
		i++;
	}
	if (!StackEmpty(S)) {
		printf("括号不匹配\n");
		return false;
	}
	else {
		printf("括号匹配\n");
		return true;
	}
}

/*
  两侧铁道均为单向行驶道,火车调度站有一个用于调度的"栈道",火车调度站的入口有
  n节硬座和软座车厢(分别用H和S表示等待调度)编写算法使所有的软座车厢都调整到硬座之前
*/
void Train_Arrange(char *train) {
	SqStack S;
	Elemtype c = '0';
	char* p = train, * q = train;
	while (*p) {
		if (*p == 'H') {
			Push(S, *p);
		}
		else {
			*(q++) = *p;
		}
		p++;
	}
	while (!StackEmpty(S)) {
		Pop(S, c);
		*(q++) = c;
	}
}

//利用一个栈实现递归函数的非递归运算(好像有点晦涩)
double p(int n, double x) {
	struct stack {
		int no;
		double val;
	}st[MaxSize];
	//top为栈的下标值
	int top = -1, i;
	//n=0,n=1时的初值
	double fv1 = 1, fv2 = 2 * x;

	for (i = n; i >= 2; i--) {
		top++;
		st[top].no = i;
	}
	while (top>=0) {
		st[top].val = 2 * x * fv2 - 2 * (st[top].no - 1) * fv1;
		fv1 = fv2;
		fv2 = st[top].val;
		top--;
	}
	if (n==0) {
		return fv1;
	}
	return fv2;

}