数据结构学习之栈和队列（C语言）

企业开发 2023-06-21 16:31:22 阅读次数: 0

一、栈和队列介绍

​ 栈和队列是两种重要的线性结构，从数据结构来看，他们也是线性表，其特殊性在于它们的基本操作是线性表的子集，也就中功能受限的线性表，也被称为限定性的数据结构。

​ 但从数据类型角度来看，它们是和线性表不大相同，有些时候它们被当作一种管理数据的规则。

二、栈结构

1、栈结构介绍

​ 栈（stack) 是限定仅在表尾进行插入或删除操作和线性表（只有一端口能进出数据），对栈来说表尾和表头有特殊含义，表尾被称为栈顶，表头被称为栈底，没有元素的空表称为空栈，元素数量达到栈的容量称为满栈，数据添加到栈中叫入栈、压栈，数据从栈中删除叫出栈、弹栈，由于栈元素特殊添加和删除的规则，所以栈的元素会先进后出的现象，简称为LIFO（Last in first out）。

2、栈结构所具备的功能

​ 1、创建栈

​ 2、销毁栈

​ 3、栈是否为空

​ 4、栈是否为满

​ 5、入栈

​ 6、出栈

​ 8、查看栈顶元素

​ 9、栈元素数量

​ 注：只有顺序栈结构才有需要判断栈是否满。

3、栈结构的顺序表示与实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

typedef struct StackArray
{
    
    
	TYPE* base;
	int top;
	size_t cap;
}StackArray;

// 创建栈
StackArray* create_stack(size_t cap)
{
    
    
	// 之所以使用成员指针是为了兼顾笔试题
	StackArray* stack = malloc(sizeof(StackArray));
	stack->base = malloc(sizeof(TYPE)*cap);
	stack->cap = cap;
	// 初始值值决定的栈空、栈满、入栈、查看栈顶时的top的操作,
	stack->top = -1; 
	return stack;
}

// 销毁栈
void destroy_stack(StackArray* stack)
{
    
    
	free(stack->base);
	free(stack);
}

// 判断栈是否为空
bool empty_stack(StackArray* stack)
{
    
    
	// 因为top的初始值是-1
	return 0 > stack->top;
}

// 判断栈是否为满
bool full_stack(StackArray* stack)
{
    
    
	// 同上
	return stack->cap == stack->top+1;
}

// 入栈
bool push_stack(StackArray* stack,TYPE val)
{
    
    
	if(full_stack(stack))
		return false;

	// 同上
	stack->base[++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+1;
}

// 查看栈顶
bool top_stack(StackArray* stack,TYPE* ptr)
{
    
    
	if(empty_stack(stack))
		return false;
	
	*ptr = stack->base[stack->top];
	return true;
}

int main(int argc,const char* argv[])
{
    
    
	int num;
	StackArray* stack = create_stack(10);
	for(int i=0; i<10; i++)
	{
    
    
		push_stack(stack,i);
		if(top_stack(stack,&num))
			printf("top %d\n",num);
	}
	printf("----------------------\n");
	while(!empty_stack(stack))
	{
    
    
		top_stack(stack,&num);
		printf("top %d\n",num);
		pop_stack(stack);
	}
}

常考的笔试题：

栈的压入、弹出序列判断，入栈顺序：1 2 3 4 5 出栈顺序可否是：1 2 3 5 4

bool push_pop_order(int* arr1,int* arr2,size_t len)
{
    
    
    StackArray* stack = create_stack(len);

    int num;
    for(int i=0,j=0; i<len; i++)
    {
    
    
        push_stack(stack,arr1[i]);
        while(top_stack(stack,&num) && num == arr2[j] && pop_stack(stack))
            j++;
    }

    return empty_stack(stack);
}

bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) 
{
    
    
    if(pushVLen != popVLen)
        return false;
    
    int stack[popVLen] , top = -1;
    for(int i=0,j=0; i<pushVLen; i++)
    {
    
    
        stack[++top] = pushV[i];
        while(top>=0 && stack[top] == popV[j])
        {
    
    
            top--;
            j++;
        }
    }
    return 0 > top;
}

bool IsPopOrder(vector<int> pushV,vector<int> popV)
{
    
    
    stack<int> s;
    for(int i=0,j=0; i<pushV.size(); i++)
    {
    
    
        s.push(pushV[i]);
        while(!s.empty() && s.top()==popV[j])
        {
    
    
            s.pop();
            j++;
        }
    }
    return s.empty();
}

4、栈结构的链式表示与实现

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

// 销毁栈
void destroy_stack(StackList* stack)
{
    
    
	while(NULL!=stack->top)
	{
    
    
		Node* node = stack->top;
		stack->top = node->next;
		free(node);
	}

	free(stack);
}

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

// 入栈
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* node = stack->top;
	stack->top = node->next;
	free(node);
	stack->cnt--;
	return true;
}

// 查看栈顶
TYPE top_stack(StackList* stack)
{
    
    
	return stack->top->data;
}

// 元素数量
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<10; i++)
	{
    
    
		push_stack(stack,i);
		if(!empty_stack(stack))
			printf("top %d\n",top_stack(stack));
	}
	printf("-------------------\n");
	while(!empty_stack(stack))
	{
    
    
		printf("top %d\n",top_stack(stack));
		pop_stack(stack);
	}
}

5、栈的应用

​ 1、内存管理，比如栈内存，它所以叫栈内存就是因为它遵循着栈的后进先出的规则，它支持着函数调用，函数在传参数就是把参数先压入到栈内存，等跳转过去后再把参数从栈内存弹出。

​ 2、特殊的算法，例如：进制转换、表达式解析、迷宫求解。

​

三、队列

1、队列介绍

​ 它与栈刚好相反，是一种先进先出的线性表，它有两个端口添加、删除元素，一个端口只能添加元素，被称为入队，该端口被为队尾，另一个端口只能删除，被称为出队，该端口被称为队头。

2、队列结构所具备的功能

​ 1、创建队列

​ 2、销毁队列

​ 3、队列是否为空

​ 4、队列是否为满

​ 5、入队

​ 6、出队

​ 8、查看队头元素

​ 9、查看队尾元素

​ 10、队列元素数量

​ 注：只有顺序栈结构才有需要判断队列是否满。

3、队列结构的链式表示与实现

#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 QueueList
{
    
    
	Node* front;
	Node* rear;
}QueueList;

// 创建队列
QueueList* create_queue(void)
{
    
    
	QueueList* queue = malloc(sizeof(QueueList));
	queue->front = NULL;
	queue->rear = NULL;
	return queue;
}

// 销毁队列
void destroy_queue(QueueList* queue)
{
    
    
	while(NULL != queue->front)
	{
    
    
		Node* node = queue->front;
		queue->front = node->next;
		free(node);
	}
	free(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 = node;
		queue->rear = node;
		return;
	}

	queue->rear->next = node;
	queue->rear = node;
}

// 出队
bool pop_queue(QueueList* queue)
{
    
    
	if(empty_queue(queue))
		return false;

	Node* node = queue->front;
	queue->front = node->next;
	free(node);
}

// 查看队头元素，调用该函数前要先判断队列是否为空，否则就会使用到空指针
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 size = 0;
	for(Node* n=queue->front; NULL!=n; n=n->next)
	{
    
    
		size++;
	}
	return size;
}

int main(int argc,const char* argv[])
{
    
    
	QueueList* queue = create_queue();
	for(int i=0; i<10; i++)
	{
    
    
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
    
    
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
}

4、顺序队列的表示与实现

​ 顺序栈的栈顶下标会随着元素入栈增大，元素出栈减小，从而让空间重复使用，而顺序队列的队头指针和队尾指针，会随着元素的入队出队一直增加，无法重复使用，而形成一次性的数据结构。

​ 为了避免这种情况，当队头下标的队尾下标到达存储空间的末尾时，要想办法把队头下标的队尾下标"回头"，就是把顺序队列的存储空间当作一个"环形"，循环使用，所以顺序队列也叫循环队列。

带计数器版本的循环队列：

​ 1、解决了计算元素数量的问题

​ 2、解决了判断队列空、满状态的问题

​ 3、缺点就是增加了一个成员，在创建、入队、出队时都要操作它。

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

#define TYPE int

typedef struct QueueArray
{
    
    
	TYPE* base;
	int front;
	int rear;
	size_t cnt;
	size_t cap;
}QueueArray;

// 创建队列
QueueArray* create_queue(size_t cap)
{
    
    
	QueueArray* queue = malloc(sizeof(QueueArray));
	queue->base = malloc(sizeof(TYPE)*cap);
	queue->cap = cap;
	queue->front = 0;
	queue->rear = -1;
	queue->cnt = 0;
	return queue;
}

// 销毁队列
void destroy_queue(QueueArray* queue)
{
    
    
	free(queue->base);
	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;

	queue->rear = (queue->rear+1)%queue->cap;
	queue->base[queue->rear] = data;
	queue->cnt++;
	return true;
}

// 出队
bool pop_queue(QueueArray* queue)
{
    
    
	if(empty_queue(queue))
		return false;

	queue->front = (queue->front+1)%queue->cap;
	queue->cnt--;
	return true;
}

// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
    
    
	return queue->base[queue->front];
}

// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
    
    
	return queue->base[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("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
    
    
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	printf("---------------------\n");
	for(int i=0; i<10; i++)
	{
    
    
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
    
    
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	destroy_queue(queue);
	return 0;
}
不带计数器版本的循环队列：

1、如何判断队列空、状态?

​ 把队头下标初始化为front=0，队尾下标也初始化rear=0，队列空时的判断条件是front == rear，但随机队列的使用，队列满时的判断也是front == rear。

​ 解决方法就是把队列的最后一个位置空置不使用，这样队列满的状态front == rear+1;

2、如何计算队列元素数量?

​ (rear-front+cap)%cap

3、查看队尾元素

​ base[(read-1+cap)%cap]

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

#define TYPE int

typedef struct QueueArray
{
    
    
	TYPE* base;
	int front;
	int rear;
	size_t cap;
}QueueArray;

// 创建队列
QueueArray* create_queue(size_t cap)
{
    
    
	QueueArray* queue = malloc(sizeof(QueueArray));
	queue->base = malloc(sizeof(TYPE)*cap+1);
	queue->cap = cap+1;
	queue->front = 0;
	queue->rear = 0;
	return queue;
}

// 销毁队列
void destroy_queue(QueueArray* queue)
{
    
    
	free(queue->base);
	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->base[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->base[queue->front];
}

// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
    
    
	return queue->base[(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("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
    
    
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	printf("---------------------\n");
	for(int i=0; i<10; i++)
	{
    
    
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
    
    
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	destroy_queue(queue);
}

5、队列的应用

队列结构一般应用于业务处理，例如：银行叫号系统，12306购票系统，电商的订单处理等。

猜你喜欢

转载自blog.csdn.net/m0_62480610/article/details/126179747
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
OOP第二次作业
java web 乱码问题
android 禁止scrollview 因控件变化自动滚动到底的方法
mysql服务解压版的安装(5.7)
centos7 nginx+tomcat配置https 安装免费SSL Let’s Encrypt
使用Mosquitto遗嘱机制实现感知客户端上下线功能的方法
面向对象之------多态与多态性
开发Teams Tabs应用程序
C# 希尔排序
第2章 Jupyter Notebooks
每日归档
更多
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022