功能受限的表结构——栈
只有一个出入口的表结构,先进后出,FILO表
1、顺序栈
①数据项:存储元素的内存首地址、栈的容量、栈顶位置
②运算:创建、销毁、入栈、出栈、栈顶、栈空、栈满、数量
#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;
}
int main(int argc,const char* argv[])
{
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、常见的栈的笔试题
①某序列为入栈序列,判断哪个序列为正确\不正确的出栈序列
入栈: 1 2 3 4 5
出栈: 1 2 3 4 5 yes
3 2 1 5 4 yes
5 4 2 1 3 no
②实现一个函数,判断序列b是否是序列a的出栈序列
int a[5] = {1,2,3,4,5},b[5]={1,2,3,4,5};
is_pop(a,b,5)
bool is_pop(int* a,int* b,int len)
{
// 创建一个栈
// 按照a的顺序一个个入栈
// 入栈一个就按b的顺序出栈
// 结束后判断是否栈空
}
// 判断是否是出栈序列
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;
}
③两个顺序栈,如何安排入栈方向可以让内存使用率最大化
让两个顺序栈相邻,且入栈方向相对入栈,能够让内存空间利用率最大化
④栈相关的概念
假设栈容量为cal
Ⅰ空增栈:top: 0开始 先入栈,再top++
Ⅱ满增栈:top: -1开始 先top++,再入栈
Ⅲ空减栈:top: cal-1开始 先入栈,再top–
Ⅳ满减栈:top: cal开始 先top–,再入栈
3、链式栈
①数据项:栈顶指针、节点数量
②运算:创建、销毁、入栈、出栈、栈顶、栈空、数量
③栈的应用
Ⅰ栈内存的数据存储方式
Ⅱ函数的调用
Ⅲ生产者与消费者模型(仓库:可用栈实现)
Ⅳ表达式解析
a+b*c/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);
}