C-栈和队列-CSDN博客

本文链接：https://blog.csdn.net/m0_61386859/article/details/132331067

文章目录

- - 栈和队列

栈和队列

一、栈

栈（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;
}