数据结构与算法分析（栈）

栈有时又叫作LIFO（后进先出）表，是限制插入和删除只能在一个位置上进行的表。首先栈是一个线性表，但限定这种线性表只能在某一端进行插入和删除操作。

下面是栈的链表实现：

采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高效率，且不存在栈上溢的情况。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
typedef int Elemtype;

typedef struct Stack {
	int data;
	struct Stack* next;
}SNode,*StackList;

StackList InitStackLink() {//初始化一个栈
	SNode* L;
	L = (StackList)malloc(sizeof(SNode));//申请节点
	if (L == NULL) {//判断是否有足够的存储空间
		printf("ERROR");
	}
	//L->next = NULL;
	return L;
}

/*
//采用头插法插入数据
StackList createStackList(StackList L) {
	SNode* s;
	int x;
	printf("头插法输入链表值：\n");
	scanf("%d", &x);
	while (x != 9999) {
		s = (SNode*)malloc(sizeof(SNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}
*/

//运用头插法的思想进行入栈
void Push(StackList L,Elemtype e) {
	SNode* s;
	s = (SNode*)malloc(sizeof(SNode));
	s->data = e;
	s->next = L->next;
	L->next = s;
	//return L;
}

//出栈
bool Pop(StackList L,int *y) {
	SNode* p;
	p = L->next;
	if (L == NULL) {
		printf("该栈为空");
		return false;
	}
	else {
		*y = p->data;
		L->next = p->next;
		free(p);
		printf("出栈元素：%d\n", *y);
		return true;
	}
}

bool GetTop(StackList L, int* num) {
	SNode* p;
	p = L->next;
	if (L == NULL) {
		printf("栈不存在\n");
		return false;
	}
	else {
		*num = p->data;
		printf("栈顶元素：%d\n", *num);
		return true;
	}
}

void DestoryStack(StackList L) {
	SNode* p = L;
	if (L == NULL) {
		printf("栈不存在");
	}
	while (L) {
		L = L->next;
		free(p);
		p = L;
	}
}

void printLinkList(StackList L)
{
	StackList p;
	p = L->next;
	if (p == NULL) {
		printf(" ");
	}
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}


int main() {
	StackList L,R;
	int y = 0, length = 0;
	L = InitStackLink();
	Push(L, 1);
	Push(L, 2);
	Push(L, 3);
	Push(L, 4);
	Push(L, 5);
	Push(L, 6);
	Pop(L, &y);
	GetTop(L, &y);
	return 0;
}

下面是顺序栈的实现：

采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素位置。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>

#define MaxSize 100//定义栈中最大元素个数

typedef int Elemtype;

typedef struct Stack {
	Elemtype data[MaxSize];//存放栈中元素
	int top;//栈顶指针
}SqStack;

void InitStack(SqStack* S) {//初始化栈
	S->top = -1;//初始化栈顶指针
}

bool StackEmpty(SqStack S) {//判断栈是否为空
	if (S.top == -1)
		return true;
	else
		return false;
}

bool Push(SqStack *S, int x) {
	if (S->top == MaxSize)//栈慢，无法继续添加，报错。
		return false;
	else {
		printf("%d\n", S->top);
		S->top++;
		S->data[S->top] = x;
		return true;
	}
}

bool Pop(SqStack *S, int* x) {//出栈
	if (S->top == -1)//栈为空，无法出栈，报错
		return false;
	*x = S->data[S->top--];
	printf("出栈元素为：%d\n", *x);
	return true;
}

bool GetTop(SqStack S) {
	//printf("2");
	int x = 0;
	if (S.top == -1)
		return false;
	x = S.data[S.top];
	printf("得到栈顶元素:%d", x);
	return true;
}

bool DestoryStack(SqStack* S) {
	S->top = -1;
	return true;
}

int main() {
	SqStack S;
	int x = 0;
	InitStack(&S);
	Push(&S, 1);
	Push(&S, 2);
	Push(&S, 3);
	Pop(&S, &x);
	GetTop(S);
	return 0;
}