数据结构 第三章（学习笔记一（顺序栈和链栈））

什么是栈

栈是限定只能在表的一端进行插入或删除操作的线性表。

允许插入、删除操作的一端是栈顶、另一端是栈底。
一般将插入和删除操作称为入栈和出栈。

现实生活中有很多类似于栈的操作，比如洗碗的时候，将洗干净的碗一个接一个的往上放（相当于入栈），取碗时，则从上面一个接一个往下取（相当于出栈）。

我们放碗的顺序是12345、取碗的顺序是54321，放碗的时候必须按照从下往上的顺序放，不能先放上面的再放下面的，取得时候必须从上往下取。

特点：限制在表的一端操作，后入先出（LIFO，即 Last In First Out）

顺序栈和链栈

顺序栈
利用一组地址连续的存储单元依次存放栈底到栈顶的数据元素，栈底位置固定不变，栈顶位置随着入栈和出栈操作而变化。

链栈
链栈是一种特殊的线性链表，和所有链表一样，是动态存储结构，无需预先分配存储空间。

顺序栈C++实现完整代码

#include<iostream>
#define STACK_INIT_SIZE 100	//初始空间分配量
#define STACKINCREMENT	10		//存储空间分配增量 

using namespace std;

typedef int Status;
typedef int ElemType;

typedef struct Stack {
	ElemType* base;//栈底指针
	ElemType* top;//栈顶指针
	int StackSize;//栈可用的最大容量
}SqStack;

Status InitStack(SqStack& S) {
	S.base = (ElemType*)malloc(STACK_INIT_SIZE * sizeof(ElemType));
	if (!S.base) {
		cout << "动态空间分配失败!" << endl;
		return 0;
	}
	S.top = S.base;
	S.StackSize = STACK_INIT_SIZE;
	cout << "初始化成功!" << endl;
	return 0;
}

//入栈
Status Push(SqStack& S, ElemType e) {
	//判断栈是否满
	if (S.top - S.base >= S.StackSize) {
		S.base = (ElemType*)realloc(S.base, (S.StackSize + STACKINCREMENT) * sizeof(ElemType));
		if (!S.base) {
			cout << "动态空间分配失败!" << endl;
			return 0;
		}
		S.top = S.base + S.StackSize;
		S.StackSize += STACKINCREMENT;
	}
	*S.top++ = e;
	return 0;
}

//创建栈
void Creat(SqStack& S, int n) {
	InitStack(S);
	for (int i = 0; i < n; i++) {
		int e;
		cout << "请输入入栈的第" << i + 1 << "个元素!" << endl;
		cin >> e;
		Push(S, e);
	}
	cout << "创建成功!" << endl;
}

//获取入栈元素的个数
Status StackLength(SqStack S) {
	int count = S.top - S.base;
	return count;
}

//判断栈空
bool StackEmpty(SqStack S) {
	if (S.base == S.top) {
		cout << "栈为空!" << endl;
		return true;
	}
	else {
		cout << "栈不为空!" << endl;
		return false;
	}
}

//获取栈顶元素
Status GetTop(SqStack S, ElemType e) {
	if (!StackEmpty(S)) {
		e = *(S.top - 1);
		cout << "栈顶元素为:" << e << endl;
	}
	return 0;
}

//出栈
Status Pop(SqStack& S, ElemType e) {
	if (!StackEmpty(S)) {
		e = *(--S.top);
		cout << "栈顶元素" << e << "出栈成功!" << endl;
	}
	return 0;
}

//遍历栈内元素
Status StackTraverse(SqStack S) {
	cout << "遍历开始:" << endl;
	for (ElemType* i = S.base; i < S.top; i++) {
		cout << *i << endl;
	}
	return 0;
}

//置空
Status ClearStack(SqStack& S) {
	S.top = S.base;
	cout << "置空成功!" << endl;
	return 0;
}

//销毁
Status DestroyStack(SqStack& S) {
	free(S.base);
	S.base = NULL;
	S.top = NULL;
	S.StackSize = 0;
	cout << "销毁成功!";
	return 0;
}

//主函数
int main() {
	SqStack S;
	int n, value1 = 0, value2 = 0;
	cout << "请输入要输入元素的个数:" << endl;
	cin >> n;
	Creat(S, n);
	cout << "栈中元素的个数为:" << StackLength(S) << endl;
	Pop(S, value2);
	GetTop(S, value1);
	StackTraverse(S);
	ClearStack(S);
	StackEmpty(S);
	DestroyStack(S);
	return 0;
}

链栈C++实现完整代码

#include<iostream>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

using namespace std;

typedef int Status;
typedef int SElemType;

typedef struct StackNode {
	SElemType data;
	struct StackNode* next;
}StackNode, * LinkStackPtr;

typedef struct {
	LinkStackPtr top;
	int count;
}LinkStack;


Status visit(SElemType c) {
	cout << c << endl;
	return OK;
}

Status InitStack(LinkStack* S) {
	S->top = (LinkStackPtr)malloc(sizeof(StackNode));
	if (!S->top)
		return ERROR;
	S->top = NULL;
	S->count = 0;
	return OK;
}

Status ClearStack(LinkStack* S) {
	LinkStackPtr p, q;
	p = S->top;
	while (p) {
		q = p;
		p = p->next;
		free(q);
	}
	S->count = 0;
	return OK;
}


Status StackEmpty(LinkStack S) {
	if (S.count == 0)
		return TRUE;
	else
		return FALSE;
}

int StackLength(LinkStack S) {
	return S.count;
}

Status GetTop(LinkStack S, SElemType* e) {
	if (S.top == NULL)
		return ERROR;
	else
		*e = S.top->data;
	return OK;
}


Status Push(LinkStack* S, SElemType e) {
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
	s->data = e;
	s->next = S->top;
	S->top = s;
	S->count++;
	return OK;
}

Status Pop(LinkStack* S, SElemType* e) {
	LinkStackPtr p;
	if (StackEmpty(*S))
		return ERROR;
	*e = S->top->data;
	p = S->top;
	S->top = S->top->next;
	free(p);
	S->count--;
	return OK;
}

Status StackTraverse(LinkStack S) {
	LinkStackPtr p;
	p = S.top;
	while (p) {
		visit(p->data);
		p = p->next;
	}
	return OK;
}

int main() {
	LinkStack s;
	int e,n,m;
	if (InitStack(&s) == OK) {
		cout << "请输入要入栈元素的个数:" << endl;
		cin >> n;
		for (int i = 0; i < n; i++) {
			cout << "请输入要入栈的第" << i + 1 << "个元素:" << endl;
			cin >> m;
			if (Push(&s, m))
				cout << "入栈成功!" << endl;
		}
	}
	cout << "栈中元素依次为:" << endl;
	StackTraverse(s);
	Pop(&s, &e);
	cout << "弹出的栈顶元素为" << e << endl;
	cout << "栈空否:" << StackEmpty(s) << "(1:空 0:否)" << endl;
	GetTop(s, &e);
	cout << "栈顶元素" << e << endl << "栈的长度为" << StackLength(s) << endl;
	ClearStack(&s);
	cout << "清空栈后,栈空否:" << StackEmpty(s) << "(1:空 0:否)" << endl;

	return 0;
}