栈和队列
一、栈
栈(stack) 是限定仅在表尾进行插入或删除操作和线性表(只有一端口能进出数据),对栈来说表尾和表头有特殊含义,表尾被称为栈顶,表头被称为栈底,由于栈元素特殊添加和删除的规则,所以栈的元素会先进后出的现象,简称为LIFO(Last in first out)。
栈的顺序存储
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//假定为int类型
#define TYPE int
typedef struct StackArray
{
TYPE* arr;
int top;
size_t cap;
}StackArray;
//创建栈结构
StackArray* create_stack(size_t cap)
{
StackArray* stack = malloc(sizeof(StackArray));
stack->arr = malloc(sizeof(TYPE)*cap);
stack->cap = cap;
stack->top = 0;
return stack;
}
//销毁
void destroy_stack(StackArray* stack)
{
free(stack->arr);
free(stack);
}
//
bool empty_stack(StackArray* stack)
{
return 0 == stack->top;
}
bool full_stack(StackArray* stack)
{
return stack->cap <= stack->top;
}
//入栈
bool push_stack(StackArray* stack,TYPE val)
{
if(full_stack(stack))
return false;
stack->arr[stack->top++] = val;
return true;
}
//出栈
bool pop_stack(StackArray* stack)
{
if(empty_stack(stack))
return false;
stack->top--;
return true;
}
size_t size_stack(StackArray* stack)
{
return stack->top;
}
//查看栈顶元素
/*
TYPE top_stack(StackArray* stack)
{
return stack->arr[stack->top-1];
}
*/
bool top_stack(StackArray* stack,TYPE* ptr)
{
if(empty_stack(stack))
return false;
*ptr = stack->arr[stack->top-1];
return true;
}
int main(int argc,const char* argv[])
{
StackArray* stack = create_stack(10);
int val = 0;
while(push_stack(stack,val++))
{
//printf("top val = %d\n",top_stack(stack));
}
/*
while(!empty_stack(stack))
{
printf("top val = %d\n",top_stack(stack));
pop_stack(stack);
}
*/
while(top_stack(stack,&val))
{
printf("top val = %d\n",val);
pop_stack(stack);
}
return 0;
}
栈的链式存储
#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 StackList
{
Node* top;
size_t cnt;
}StackList;
// 创建栈
StackList* create_stack(void)
{
StackList* stack=malloc(sizeof(StackList));
stack->top=NULL;
stack->cnt=0;
return stack;
}
// 栈空
bool empty_stack(StackList* stack)
{
return 0 == stack->cnt;
}
// 入栈
void push_stack(StackList* stack,TYPE data)
{
Node* node=create_node(data);
node->next=stack->top;
stack->top=node;
stack->cnt++;
}
// 出栈
bool pop_stack(StackList* stack)
{
if(empty_stack(stack))
return false;
Node* tmp=stack->top;
stack->top=tmp->next;
free(tmp);
stack->cnt--;
return true;
}
// 查看栈顶
TYPE top_stack(StackList* stack)
{
return stack->top->data;
}
// 销毁栈
void destroy_stack(StackList* stack)
{
while(pop_stack(stack))
free(stack);
}
// 元素数量
size_t size_stack(StackList* stack)
{
return stack->cnt;
}
int main(int argc,const char* argv[])
{
StackList* stack = create_stack();
for(int i=0; i<5; i++)
{
push_stack(stack,i);
printf("top:%d\n",top_stack(stack));
}
printf("-----------------\n");
while(!empty_stack(stack))
{
printf("top:%d\n",top_stack(stack));
pop_stack(stack);
}
return 0;
}
++++++++++++柔性数组++++++++++++++++++++
什么是柔性数组:
C99中,定义在结构体内部末尾的零长数组。
修改"顺序存储的部分代码"以演示用法
typedef struct StackArray
{
int top;
size_t cap;
TYPE arr[]; //TYPE arr[0]; 取决于编译器
}StackArray;
void destroy_stack(StackArray* stack)
{
free(stack);
}
柔性数组的特点:
- 必须在结构体的末尾且前面至少有一个成员
- 与结构体内存地址连续
从第二张图可以看出内存地址是连续的
柔性数组的优点:
- 节约内存:数组名不占内存空间
- 方便分配和释放,和成员指针相比只需要分配、释放一次
- 内存空间连续,有利于读写速度和减少内存碎片
二、队列
与栈刚好相反,是一种先进先出的线性表,它有两个端口添加、删除元素,一个端口只能添加元素,被称为入队,该端口被为队尾,另一个端口只能删除,被称为出队,该端口被称为队头。
队列的链式存储
#include<stdio.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 QueueList
{
Node* front;
Node* rear;
}QueueList;
// 创建队列
QueueList* create_queue(void)
{
QueueList* queue=malloc(sizeof(QueueList));
queue->font=NULL;
queue->rear=NULL;
return queue;
}
// 判断队列是否为空
bool empty_queue(QueueList* queue)
{
return NULL == queue->front;
}
// 入队 尾添加
void push_queue(QueueList* queue,TYPE data)
{
Node* node=create_node(data);
if(empty_queue(queue))
{
queue->front=ndoe;
queue->rear=node;
}
else
{
queue->rear->next=node;
queue->rear=node;
}
}
// 出队 头删除
bool pop_queue(QueueList* queue)
{
if(empty_queue(queue))
return false;
Node* tmp=queue->front;
queue->front=tmp->next;
free(tmp);
return true;
}
// 查看队头元素
TYPE front_queue(QueueList* queue)
{
return queue->front->data;
}
// 查看队尾元素
TYPE rear_queue(QueueList* queue)
{
return queue->rear->data;
}
// 队列元素数量
size_t size_queue(QueueList* queue)
{
size_t cnt=0;
for(Node* n=queue->front;n!=NULL;n=n->next)
{
cnt++;
}
return cnt;
}
// 销毁队列
void destroy_queue(QueueList* queue)
{
while(pop_queue(queue));
free(queue);
}
int main(int argc,const char* argv[])
{
return 0;
}
队列的顺序表示
因为顺序队列的队头指针和队尾指针,会随着元素的入队出队一直增加,无法重复使用,而形成一次性的数据结构。
为了避免这种情况,有两种解决方案:
1、使用计数器
2、少使用一个元素,rear->next=front 为满
第一种
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define TYPE int
typedef struct QueueArray
{
TYPE* arr;
int front;
int rear;
size_t cnt;
size_t cap;
}QueueArray;
// 创建队列
QueueArray* create_queue(size_t cap)
{
QueueArray* queue=malloc(sizeof(QueueArray));
queue->arr=malloc(sizeof(TYPE)*cap);
queue->cap=cap;
queue->cnt=0;
queue->front=0;
queue->rear=-1;
}
// 销毁队列
void destroy_queue(QueueArray* queue)
{
free(queue->arr);
free(queue);
}
// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
return 0==queue->cnt;
}
// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
return queue->cnt==queue->cap;
}
// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
if(full_queue(queue))
return false;
//rear-1开始
queue->rear=queue->rear+1;
//+1后等于cap则满 因为下标从0开始 则取余从0开始
queue->arr[(queue->rear)%queue->cap]=data;
//更新rear值
queue->rear%=queue->cap;
queue->cnt++;
return true;
}
// 出队
bool pop_queue(QueueArray* queue)
{
if(empty_queue(queue))
return false;
//新的front等于下一个对cap取余 直至0全部出列
queue->front = (queue->front+1)% queue->cap;
queue->cnt--;
return true;
}
// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
return queue->arr[queue->front];
}
// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
return queue->arr[queue->rear];
}
// 队列元素数量
size_t size_queue(QueueArray* queue)
{
return queue->cnt;
}
int main(int argc,const char* argv[])
{
QueueArray* queue = create_queue(10);
for(int i=0; i<10; i++)
{
push_queue(queue,i);
printf("%d ",rear_queue(queue));
}
printf("\n");
for(int i=0; i<5; i++)
{
printf("%d ",front_queue(queue));
pop_queue(queue);
}
printf("\n");
for(int i=0; i<5; i++)
{
push_queue(queue,i+10);
printf("%d ",rear_queue(queue));
}
printf("\n");
while(!empty_queue(queue))
{
printf("%d ",front_queue(queue));
pop_queue(queue);
}
return 0;
}
第二种
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define TYPE int
typedef struct QueueArray
{
TYPE* arr;
int front;
int rear;
size_t cap;
}QueueArray;
// 创建队列
QueueArray* create_queue(size_t cap)
{
QueueArray* queue=malloc(sizeof(QueueArray));
queue->arr=malloc(sizeof(TYPE)*(cap+1));
queue->front=0;
queue->rear=0;
queue->cap=cap;
return queue;
}
// 销毁队列
void destroy_queue(QueueArray* queue)
{
free(queue->arr);
free(queue);
}
// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
return queue->front==queue->rear;
}
// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
return queue->front==(queue->rear+1)%queue->cap;
}
// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
if(full_queue(queue))
return false;
queue->arr[queue->rear]=data;
queue->rear=(queue->rear+1)%queue->cap;
return true;
}
// 出队
bool pop_queue(QueueArray* queue)
{
if(empty_queue(queue))
return false;
queue->front=(queue->front+1)%queue->cap;
return true;
}
// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
return queue->arr[queue->front];
}
// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
return queue->arr[(queue->rear-1+queue->cap)%queue->cap];
}
// 队列元素数量
size_t size_queue(QueueArray* queue)
{
return (queue->rear-queue->front+queue->cap)%queue->cap;
}
int main(int argc,const char* argv[])
{
QueueArray* queue = create_queue(10);
for(int i=0; i<10; i++)
{
push_queue(queue,i);
printf("%d ",rear_queue(queue));
}
printf("\n");
for(int i=0; i<5; i++)
{
printf("%d ",front_queue(queue));
pop_queue(queue);
}
printf("\n");
for(int i=0; i<5; i++)
{
push_queue(queue,i+10);
printf("%d ",rear_queue(queue));
}
printf("\n");
while(!empty_queue(queue))
{
printf("%d ",front_queue(queue));
pop_queue(queue);
}
return 0;
}