数据结构学习笔记4之特殊的表结构（栈）

栈：只有一个进去出口的表结构，先进后出
顺序栈：
数据域：
存储元素的内存首地址
栈的容量
栈顶位置
运算：
创建、销毁、入栈、出栈、栈满、栈空、栈顶

​ 链式栈：
​ 数据域：
​ 栈顶
​ 节点数量
​ 运算：
​ 创建、销毁、入栈、出栈、栈空、栈顶
​ 栈的应用：
​ 1、函数的调用（栈内存）
​ 2、生产者与消费者模型(栈作为仓库)
​ 3、表达式解决（中缀表达式转后缀表达式）
​ 常见的笔试面试题：
​ 某序列为入栈顺序，某序列是否是出栈顺序（边入边出）。
​ 1 2 3 4 5
​ 3 1 2 4 5 NO

顺序栈：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 设置顺序栈结构
typedef struct ArrayStack
{
	TYPE* ptr;	// 存储元素的内存首地址
	size_t cal;	// 栈的容量
	size_t top;	// 栈顶
}ArrayStack;

// 创建
ArrayStack* create_array_stack(size_t cal)
{
	// 为栈结构分配内存
	ArrayStack* stack = malloc(sizeof(ArrayStack));
	// 分配存储元素的内存
	stack->ptr = malloc(sizeof(TYPE)*cal);
	// 备份栈的容量
	stack->cal = cal;
	// 初始化栈顶
	stack->top = 0;
}

// 销毁
void destory_array_stack(ArrayStack* stack);

// 栈空
bool empty_array_stack(ArrayStack* stack)
{
	return !stack->top;
}

// 栈满
bool full_array_stack(ArrayStack* stack)
{
	return stack->top >= stack->cal;
}

// 入栈
bool push_array_stack(ArrayStack* stack,TYPE val)
{
	if(full_array_stack(stack)) return false;
	stack->ptr[stack->top++] = val;
	return true;
}

// 出栈
bool pop_array_stack(ArrayStack* stack)
{
	if(empty_array_stack(stack)) return false;
	stack->top--;
	return true;
}

// 栈顶
bool top_array_stack(ArrayStack* stack,TYPE* val)
{
	if(empty_array_stack(stack)) return false;
	*val = stack->ptr[stack->top-1];
	return true;
}

int main(int argc,const char* argv[])
{
	ArrayStack* stack = create_array_stack(10);
	for(int i=0; i<10; i++)
	{
		push_array_stack(stack,i);
		TYPE val = 0;
		top_array_stack(stack,&val) && printf("top:%d\n",val);
	}
	printf("---------------------------\n");
	while(!empty_array_stack(stack))
	{
		TYPE val = 0;
		top_array_stack(stack,&val) && printf("top:%d\n",val);
		pop_array_stack(stack);
	}
}

链式栈：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 链式节点
typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

// 创建节点
Node* create_node(TYPE val)
{
	Node* node = malloc(sizeof(Node));
	node->next = NULL;
	node->data = val;
	return node;
}

// 链式栈
typedef struct ListStack
{
	Node* top;
	size_t cnt;
}ListStack;

// 创建 因为栈不能随意插入、删除，因此不需要头节点
ListStack* create_list_stack(void)
{
	ListStack* stack = malloc(sizeof(ListStack));
	stack->top = NULL;
	stack->cnt = 0;
	return stack;
}


// 栈空
bool empty_list_stack(ListStack* stack)
{
	return NULL == stack->top;
}

// 入栈
void push_list_stack(ListStack* stack,TYPE val)
{
	Node* node = create_node(val);
	node->next = stack->top;
	stack->top = node;
	stack->cnt++;
}

// 出栈
bool pop_list_stack(ListStack* stack)
{
	if(empty_list_stack(stack)) return false;
	Node* temp = stack->top;
	stack->top = temp->next;
	free(temp);
	stack->cnt--;
	return true;
}

// 栈顶 通过判断栈是否为空确保栈中有数据
TYPE top_list_stack(ListStack* stack)
{
	return stack->top->data;
}

// 节点数 不应该在外面访问数据结构的成员(打破了封装必)
size_t size_list_stack(ListStack* stack)
{
	return stack->cnt;
}

// 销毁
void destory_list_stack(ListStack* stack)
{
	while(pop_list_stack(stack));
	free(stack);
}

int main(int argc,const char* argv[])
{
	ListStack* stack = create_list_stack();
	for(int i=0; i<10; i++)
	{
		push_list_stack(stack,i);
		!empty_list_stack(stack) && printf("top:%d\n",top_list_stack(stack));
	printf("------节点数量：%d\n",size_list_stack(stack));
	}
	while(!empty_list_stack(stack))
	{
		printf("top:%d\n",top_list_stack(stack));
		pop_list_stack(stack);
	printf("------节点数量：%d\n",size_list_stack(stack));
	}

	destory_list_stack(stack);

}