数据结构——栈

1.栈的基本概念

定义：栈是只允许在一端进行插入或删除操作的线性结构。

入栈次序为
$${}_{a_1}{,}_{a_2},{,}_{a_3}{,}_{a_4}{,}_{a_5}$$
则出栈次序为
$${}_{a_5}{,}_{a_4}{,}_{a_3}{,}_{a_2}{,}_{a_1}故栈的==操作特性==可概括为后进先出。$$
数学性质：n个不同元素入栈，出栈元素不同排列的个数为
$$\frac{1}{n+1}C\left(\genfrac{}{}{0ex}{}{n}{2n}\right)$$

2.栈的基本操作

1.栈的顺序存储结构为

#define MaxSize 50
typedef struct{
	Elemtype data[MaxSize];
	int top;//栈顶元素
}SqStack；

2.初始化

Stack::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new char[size];//缺省构造函数分配最大内存
}
Stack::Stack(int s)
{
	size = s;
	top = -1;
	data = new char[size];//根据指定的大小分配栈的内存空间
}Stack::Stack()//无参构造函数,初始化顺序栈
{
	base = new Node[MAXSIZE];
	pop = base;
	maxsize = MAXSIZE;
}

2.判断栈空

bool Stack::isEmpty()
{
	if (top==-1)
	{
		//cout << "空栈" << endl;
		return true;
	}
	else
	{
		//cout << "不是空栈" << endl;
		return false;
	}
}

3.判断栈满

bool Stack::isFull()
{
	if (top == size-1)
	{
		//cout << "栈满" << endl;
		return true;
	}
	else
	{
		//cout << "为满栈" << endl;
		return false;
	}
}

4.入栈

​

bool Stack::push(char ch)
{
	//if (top == size - 1) exit(-1);//栈满
    if (!isFull()) retutrn false;//栈满
    //判断条件直接用isFull函数来写比较好
	data[++top] = ch;
	//cout << "入栈成功" << endl;
    return ture;
}

5.出栈

char Stack::pop()
{
	char ch;
	if (top == -1) exit(-1);//空栈\
    //此处判断条件也应用函数
	ch = data[top--];
	//cout << "出栈成功" << ch << endl;
}

6.独取栈顶元素

char Stack::getTop()
{
	char ch;
	if (top == -1) exit(-1);//空栈
	ch = data[top];
	//cout << "栈顶元素为:" << ch << endl;
    return ch;
}

注：

这里直接用整形变量top指向栈顶元素，且top=-1，故入栈操作为S.data[++S.top]=x,出栈操作为x=S.data[S.top–].若栈顶指针初始化为S.top=0,则入栈出栈操作会发生改变，响应的栈空，栈满条件也会发生改变。

也可以用指针来指向栈顶元素。

完整代码：

#include<iostream>
using namespace std;
const int MAX_SIZE = 100;
class Stack//
{
public:
	Stack();
	Stack(int s);
	~Stack();
	void push(char ch);//入栈
	char pop();//出栈
	char getTop();//获得栈顶元素
	bool isEmpty();
	bool isFull();
	void setNull();

private:
	char* data;//属性:线性表
	int size;//属性:堆栈的实际大小
	int top;//属性:栈顶
};

Stack::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new char[size];//缺省构造函数分配最大内存
}
Stack::Stack(int s)
{
	size = s;
	top = -1;
	data = new char[size];//根据指定的大小分配栈的内存空间
}

Stack::~Stack()
{
	delete []data;//内存回收
}
void Stack::push(char ch)
{
	//if (top == size - 1) exit(-1);//栈满
    if (!isFull()) exit(-1);//栈满
    //判断条件直接用isFull函数来写比较好
	data[++top] = ch;
	cout << "入栈成功" << endl;
}
char Stack::pop()
{
	char ch;
	if (top == -1) exit(-1);//空栈\
    //此处判断条件也应用函数
	ch = data[top--];
	cout << "出栈成功" << ch << endl;
}
char Stack::getTop()
{
	char ch;
	if (top == -1) exit(-1);//空栈
	ch = data[top];
	cout << "栈顶元素为:" << ch << endl;
}
bool Stack::isEmpty()
{
	if (top==-1)
	{
		cout << "空栈" << endl;
		return true;
	}
	else
	{
		cout << "不是空栈" << endl;
		return false;
	}
}
bool Stack::isFull()
{
	if (top == size-1)
	{
		cout << "栈满" << endl;
		return true;
	}
	else
	{
		cout << "为满栈" << endl;
		return false;
	}
}
void Stack::setNull()
{
	top = -1;
}

3.双端堆栈

利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维数组空间，将两个栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延申。

这里直接给出代码，不在详细分析。

const int STACK_SIZE = 100;
class BothStack
{
private:
	//char data[STACK_SIZE];
	char* data;
	int top1, top2;
public:
	BothStack();
	~BothStack();
	void push(int num, char ch);
	char pop(int num);
	char gettop(int num);
	bool isEmpty(int mun);
	bool isFull();
	void setFull(int num);
	class Full{};
	class Empty{};
};
BothStack::BothStack()
{
	data = new char[STACK_SIZE];
	top1 = -1;
	top2 = STACK_SIZE;
}
BothStack::~BothStack()
{

}
void BothStack::push(int num, char ch)
{
	if (isFull())
	{
		throw Full();
	}
	else
	{
		if (num == 1)
		{
			data[++top1] = ch;
		}
		if (num == 2)
		{
			data[--top2] = ch;
		}
	}
}
char BothStack::pop(int num)
{
	if (num == 1) {
		if (isEmpty(1)) throw Empty();
		else return data[top1--];
	}
	if (num == 2) {
		if (isEmpty(2)) throw Empty();
		else return data[top2++];
	}
}
char BothStack::gettop(int num)
{
	if (num == 1) {
		if (isEmpty(1)) throw Empty();
		else return data[top1];
	}
	if (num == 2) {
		if (isEmpty(2)) throw Empty();
		else return data[top2];
	}
}
bool BothStack::isFull()
{
	if (top2 == top1 + 1)
	{
		return true;
	}
	else return false;
}
bool BothStack::isEmpty(int num)
{
	if (num == 1) {
		if (top1 == -1) return true;
		else return false;
	}
	if (num == 2)
	{
		if (top2 == STACK_SIZE) return true;
		else return false;
	}
}
void BothStack::setFull(int num)
{
	if (num == 1) top1 == -1;
	if (num == 2) top2 == STACK_SIZE;
}

4.栈的链式存储结构（源码（github））

链栈的存储类型可描述为

struct Stacknode
{
	DateType data;
	struct Stacknode * next;
};

采用链式存储，便于结点的插入和删除。链栈的操作与链表类似，入栈和出栈操作都在链表的表头进行。