栈

功能受限表：对表结构的功能加以限制，形成特殊的表结构

一、栈

只有一个出入口的表结构，先进后出，FILO表

1.顺序栈：

数据项：

存储元素的内存首地址

栈的容量

栈顶位置

运算：创建、销毁、入栈、出栈、栈顶、栈空、栈满、数量

test1：实现一个函数，判断序列b是否是序列a的出栈序列

bool is_pop(const int* a,const int* b,size_t len)
{
    //    创一个栈
    ArrayStack* stack = create_array_stack(len);
    //    按a的顺序入栈
    for(int i=0,j=0; i<len; i++)
    {
        push_array_stack(stack,a[i]);
        //    判断栈顶是否可以按照b顺序出栈
        int val_top = 0;
        while(top_array_stack(stack,&val_top) && val_top == b[j])
        {
            pop_array_stack(stack);
            j++;
        }
    }
    //    判断是否为空
    bool flag = empty_array_stack(stack);
    destroy_array_stack(stack);
    return flag;
}

test2:两个顺序栈，如何安排入栈方向可以让内存使用率最大化？

让两个顺序栈相邻，且入栈方向相对入栈，能够让内存空间利用率最大化

设计顺序栈

#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;
	return stack;
}

//	销毁
void destroy_array_stack(ArrayStack* stack)
{
	free(stack->ptr);
	free(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 data)
{
	if(full_array_stack(stack)) return false;
	stack->ptr[stack->top++] = data;
	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* data)
{
	if(empty_array_stack(stack)) return false;
	*data = stack->ptr[stack->top-1];
	return true;
}

//	数量
size_t size_array_stack(ArrayStack* stack)
{
	return stack->top;
}

//	练习 判断是否是出栈序列
bool is_pop(const int* a,const int* b,size_t len)
{
	//	创一个栈
	ArrayStack* stack = create_array_stack(len);
	//	按a的顺序入栈
	for(int i=0,j=0; i<len; i++)
	{
		push_array_stack(stack,a[i]);
		//	判断栈顶是否可以按照b顺序出栈
		int val_top = 0;
		while(top_array_stack(stack,&val_top) && val_top == b[j])
		{
			pop_array_stack(stack);
			j++;
		}
	}
	//	判断是否为空
	bool flag = empty_array_stack(stack);
	destroy_array_stack(stack);
	return flag;
}

int main(int argc,const char* argv[])
{
	int a[5] = {1,2,3,4,5};
	int b[5] = {1,2,3,4,5};
	printf("%d\n",is_pop(a,b,5));
	/*
	ArrayStack* stack = create_array_stack(10);
	for(int i=0; i<20; i++)
	{
		if(push_array_stack(stack,i+1))
		{
			int num = -100;
			top_array_stack(stack,&num);
			printf("top:%d size:%d\n",num,size_array_stack(stack));
		}
	}
	printf("----------------\n");
	while(!empty_array_stack(stack))
	{
		int num = -100;
		top_array_stack(stack,&num);
		printf("top:%d size:%d\n",num,size_array_stack(stack));
		pop_array_stack(stack);
	}
	*/
}

2.链式栈

数据项：

栈顶指针

节点数量

运算：创建、销毁、入栈、出栈、栈顶、栈空、数量

设计链式栈

#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 data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

//	设计链式栈
typedef struct ListStack
{
	Node* top;		//	指向栈顶指针
	size_t size;	//	栈的节点数量
}ListStack;

//	创建栈
ListStack* create_list_stack(void)
{
	ListStack* stack = malloc(sizeof(ListStack));
	stack->top = NULL;
	stack->size = 0;
	return stack;
}
//	栈空
bool empty_list_stack(ListStack* stack)
{
	return 0 == stack->size;
}
//	入栈
void push_list_stack(ListStack* stack,TYPE data)
{
	Node* node = create_node(data);
	node->next = stack->top;
	stack->top = node;
	stack->size++;
}
//	出栈
bool pop_list_stack(ListStack* stack)
{
	if(empty_list_stack(stack)) return false;

	Node* temp = stack->top;
	stack->top = temp->next;
	free(temp);
	stack->size--;
	return true;
}
//	栈顶
TYPE top_list_stack(ListStack* stack)
{
	return stack->top->data;
}
//	节点数
size_t size_list_stack(ListStack* stack)
{
	return stack->size;
}
//	销毁栈
void destroy_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+1);
		printf("top:%d size:%d\n",
			top_list_stack(stack),size_list_stack(stack));
	}
	printf("----------------\n");
	/*
	while(!empty_list_stack(stack))
	{
		printf("top:%d size:%d\n",
			top_list_stack(stack),size_list_stack(stack));
		pop_list_stack(stack);
	}
	*/
	destroy_list_stack(stack);
}

3.栈相关的概念：

假设栈容量为cal

空增栈：top: 0开始  先入栈，再top++

满增栈：top: -1开始  先top++，再入栈

空减栈：top: cal-1开始  先入栈，再top--

满减栈：top: cal开始  先top--，再入栈

4. 栈的应用：

1、栈内存的数据存储方式

2、函数的调用

3、生产者与消费者模型(仓库：可用栈实现)

4、表达式解析:a+b*c/2 中缀表达式,计算机中以后缀表达式存储 中缀转后缀表达式使用栈