栈（基于数组实现和链表实现）

一、基于数组实现的顺序栈

#include
#include
#define maxsize 100
//栈的数组结构体
typedef struct Stack
{
	char data[maxsize]; // 数组实现栈内元素定位
	int top; // 作为数组下标
	int buttom;
}Array_Stack;

// 创建一个空栈
Array_Stack* Create_Stack()
{
	Array_Stack* st = (Array_Stack*)malloc(sizeof(Array_Stack));
	if (st == NULL)
	{
		return 1;
	}
	st->top = st->buttom = 0;
	return st;
}

//入栈
void push(Array_Stack* st, char data)
{
	st->data[st->top] = data;
	st->top++;
}

//出栈
void pop(Array_Stack* st, char data)
{
	int n = st->top;
	while (n != st->buttom)//判断是否是空栈
	{
		if (st->data[n - 1] == data)  // 按元素索引出栈 
		{
			//重新标记栈顶位置，并跳出循环
			st->top = n - 1;
			break;
		}
		n--;
	}
}

//打印栈元素
void Print(Array_Stack* st)
{
	int n = st->top;
	while (n != st->buttom)
	{
		printf("%c ", st->data[n - 1]);
		n--;
	}
	printf("\n");
}

int main()
{
	int i = 5, j = 5;
	Array_Stack* st;
	st = Create_Stack();
	printf("开始进栈: \n");
	while (i--)
	{
		push(st, 'A' + i);
		printf("%c进栈后，栈内元素为：", 'A' + i);
		Print(st);
	}
	pop(st, 'B');
	printf("开始出栈: \n");
	Print(st);
	return 0;
}

运行结果：

用数组实现的栈在执行出栈操作时并没有把栈顶元素给删除掉，只是移动了栈顶的下标位置，当再执行一次入栈操作时，又将原来位置的元素给覆盖掉了

基于数组实现的顺序栈的大小是确定的，当栈内元素已满，或者栈顶下标已经移动到末尾时，需要重新申请一个数组空间来重新进行入栈操作

栈的本质也可看成数组，一个倒过来的数组，出栈时通过重新标记栈顶下标，将该元素下标前的元素打印出来，呈现出一种先入后出的效果罢了

二、基于链表实现的链式栈

#include
#include
#include

typedef struct Node  // 定义结点
{
	int elem;  // 结点元素
	struct Node* next;
}Node;

// 定义栈结构体
typedef struct LinkList_Stack
{
	Node* top;  // 栈顶指针
}LinkList_Stack;

LinkList_Stack* Create_Stack()  // 创建一个空栈
{
	LinkList_Stack* st = (LinkList_Stack*)malloc(sizeof(LinkList_Stack));
	if (st == NULL)
	{
		printf("分配内存空间失败！");
	}
	st->top = NULL;
	return st;
}

// 入栈
LinkList_Stack* push(LinkList_Stack* st, int x)
{
	Node* p = (Node*)malloc(sizeof(Node));
	p->elem = x;  // 将要入栈的元素放入新结点中
	p->next = st->top;
	st->top = p;  // 类似链表的插入，将元素（结点）压入栈顶
	return st;
}

// 出栈
LinkList_Stack* pop(LinkList_Stack* st, int x)
{
	Node* p = (Node*)malloc(sizeof(Node));
	p = st->top;
	if (p == NULL)  // 判断是不是空栈
	{
		printf("该栈是空栈！");
	}
	while (--x) p = p->next;
	st->top = p->next;
	free(p);
	// 通过改变一次指针完成栈顶元素的出栈
	return st;
}

// 打印栈
void Print(LinkList_Stack* st)
{
	Node* p = (Node*)malloc(sizeof(Node));
	p = st->top;
	while (p != NULL)
	{
		printf("%d ", p->elem);  // 打印该元素
		p = p->next;
	}
	printf("\n");
}

int main()
{
	int i = 5;
	LinkList_Stack* st = Create_Stack();
	printf("开始进栈: \n");
	while (i--)
	{
		push(st, i);
		printf("%d进栈后，栈内元素为：", i);
		Print(st);
	}
	printf("删除栈顶元素后的栈：\n");
	pop(st, 1);
	Print(st);
	free(st);
	return 0;
}

运行结果：

用链表实现的栈在执行出栈操作时通过指针的移动可以实现栈顶元素的删除，用链表实现的栈，其内部储存结构更像栈“先入后出”的特点