数据结构 - 堆栈

1 堆栈的主要操作

2 栈的顺序存储

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

#include<iostream>
#include<vector>
using namespace std;

#define MAX 100
typedef struct SNode* StackPtr;
struct SNode {
	int data[MAX];
	int top;
};
StackPtr pushStack(StackPtr Stack, int value) {
	if (Stack->top == MAX) {
		cout << "This stack is fool." << endl;
	}
	else {
		//++(Stack->top);
		//Stack->data[Stack->top] = value;
		Stack->data[++(Stack->top)] = value;
	}
	return Stack;
}
int popStack(StackPtr &Stack) {
	if (Stack->top == -1) {
		cout << "This stack is null." << endl;
		return -101;
	}
	else {
		//int data = Stack->data[Stack->top];
		//(Stack->top)--;
		//return data;
		return Stack->data[(Stack->top)--];
	}
}
int main() {
	StackPtr stack = new SNode;
	stack->top = -1;
	auto a = vector<int>(10, 4);
	for (auto i : a) {
		pushStack(stack, i);
		auto data = popStack(stack);
		cout << data << endl;
	}
	return 0;
}

3 堆栈的链式存储

栈的链式存储结构实际上就是一个单链表，叫做链栈。插入和删 除操作只能在链栈的栈顶进行。栈顶指针top在链表的头部。

#include <iostream>
#include <vector>
using namespace std;
typedef struct SNode* Stack;
struct SNode{
	int data;
	Stack next;
};
Stack creatStack() {
	Stack s = new SNode;
	s->next = nullptr;
	return s;
}
bool isEmpty(Stack stack) {
	return stack->next == nullptr;
}
Stack pushStack(Stack stack, int indata) {
	Stack newnode = new SNode;
	newnode->data = indata;
	newnode->next = stack->next;
	stack->next = newnode;
	return stack;
}
int popStack(Stack stack) {
	int outdata;
	if (isEmpty(stack)) {
		cout << "This stack is empty." << endl;
		return NULL;
	}
	else {
		Stack temp = new SNode;
		temp = stack->next;
		stack->next = temp->next;
		outdata = temp->data;
		delete temp;
		return outdata;
	}
}
int main() {
	auto data = vector<int>(10, 3);
	auto stack = creatStack();
	for (auto i : data) {
		pushStack(stack, i);
	}
	for (int i = 0; i <= data.size(); i++) {
		cout << popStack(stack) << endl;
	}
	return 0;
}

4 表达式求值

中缀表达式转后缀表达式

从头到尾读取中缀表达式的每个对象，对不同对象按不同的情况处理。

• 运算数：直接输出；
• 左括号：压入堆栈；
• 右括号：将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出）；
•  运算符：

1. 若优先级大于栈顶运算符时，则把它压栈；
2. 若优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出；再比较新的栈顶运算符，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压栈；

• 若各对象处理完毕，则把堆栈中存留的运算符一并输出。