数据结构---栈和队列

已于 2024-03-06 15:04:15 修改
阅读量1k 收藏 25
点赞数 21
分类专栏： 数据结构（c语言） 文章标签： 数据结构
于 2024-03-06 14:49:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63219391/article/details/136504316
版权

目录

1、栈

1.1 栈的概念及结构

1.2 栈的实现

1.2.3 栈的实现代码

2.队列

2.1 队列的概念和结构

2.2 队列的实现

2.3 队列代码实现

2.3 循环队列

3.扩展

3.1 使用队列实现栈oj链接

3.2 使用栈实现队列oj链接

1、栈

1.1 栈的概念及结构

        栈：栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除的一端称之为栈顶，另一端称为栈底。栈中的元素遵循先进后出原则

        压栈：栈的插入操作叫做进栈/压栈/入栈。栈顶入数据。

        出栈：栈的删除操作叫做出栈，栈底出数据。

1.2 栈的实现

        栈一般有数组栈和链式栈两种，可以使用数组或者链表来实现，相对而言数组的结构实现比链表实现更优一些，因为数组的尾插的代价较小。

1.2.3 栈的实现代码

Stack.h

//Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

Stack.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Stack.h"
void StackInit(Stack* ps) {
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data) {
	assert(ps);
	if (ps->_capacity == ps->_top) {
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, newcapacity * sizeof(STDataType));
		if (tmp == NULL) {
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps) {
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps) {
	assert(ps);
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps) {
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps) {
	assert(ps);
	if (ps->_top == 0) {
		return 1;
	}
	else {
		return 0;
	}
}
// 销毁栈 
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

2.队列

2.1 队列的概念和结构

        队列:只允许一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出原则，进行插入操作的一端成为队尾，进行删除操作的一端称为队头,队尾插入数据，队头出数据。

2.2 队列的实现

        队列和栈一样都有数组和链表两种实现结构，但是和数组不同的是队列一般使用链表实现，因为出队列是在队头，相对数组而言，链表效率更高。

2.3 队列代码实现

                Queue.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
// 链式结构：表示队列
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

        Queue.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Queue.h"
// 初始化队列 
void QueueInit(Queue* q) {
	q->_front = q->_rear = NULL;
	q->size = 0;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("malloc fail");
		return NULL;
	}
	newnode->_data = data;
	newnode->_next = NULL;
	if (q->_front == NULL) {
		
		q->_front = q->_rear = newnode;
		q->size++;
	}
	else {
		q->_rear->_next = newnode;
		q->_rear = newnode;
		q->size++;
	}
}
// 队头出队列 
void QueuePop(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	if (q->_front->_next == NULL) {
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	else {
		QNode* del = q->_front;
		q->_front = q->_front->_next;
		free(del);
		del = NULL;
	}
	
	q->size--;
	

}
// 获取队列头部元素 
QDataType QueueFront(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q) {
	assert(q);
	return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q) {
	assert(q);
	if (q->size == 0) {
		return 1;
	}
	else {
		return 0;
	}
}
// 销毁队列 
void QueueDestroy(Queue* q) {
	assert(q);
	QNode* cur = q->_front;
	while (cur) {
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->size = 0;
}

2.3 环形队列

oj链接. - 力扣（LeetCode）

typedef struct {
    int front;
    int rear;
    int k;
    int*a;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1)==obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj)){
        return false;
    }
    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear%=obj->k+1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)){
        return false;
    }
    obj->front++;
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)){
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)){
        return -1;
    }
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}




void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

3.扩展

3.1 使用队列实现栈oj链接

// 链式结构：表示队列
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);
// 初始化队列 
void QueueInit(Queue* q) {
	q->_front = q->_rear = NULL;
	q->size = 0;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("malloc fail");
	}
	newnode->_data = data;
	newnode->_next = NULL;
	if (q->_front == NULL) {
		
		q->_front = q->_rear = newnode;
		q->size++;
	}
	else {
		q->_rear->_next = newnode;
		q->_rear = newnode;
		q->size++;
	}
}
// 队头出队列 
void QueuePop(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	if (q->_front->_next == NULL) {
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	else {
		QNode* del = q->_front;
		q->_front = q->_front->_next;
		free(del);
		del = NULL;
	}
	
	q->size--;
	

}
// 获取队列头部元素 
QDataType QueueFront(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q) {
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q) {
	assert(q);
	return q->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q) {
	assert(q);
	if (q->size == 0) {
		return 1;
	}
	else {
		return 0;
	}
}
// 销毁队列 
void QueueDestroy(Queue* q) {
	assert(q);
	QNode* cur = q->_front;
	while (cur) {
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->size = 0;
}


typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    if(obj==NULL){
        perror("molloc fail");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1,x);
    }else{
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* pEmpty =&obj->q1;
    Queue* pNotEmpty =&obj->q2;
    if(!QueueEmpty(&obj->q1)){
        pEmpty = &obj->q2;
        pNotEmpty =&obj->q1;
    }
    while(QueueSize(pNotEmpty)>1){
        QueuePush(pEmpty,QueueFront(pNotEmpty));
        QueuePop(pNotEmpty);
    }
    int top=QueueFront(pNotEmpty);
    QueuePop(pNotEmpty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1)){
        return QueueBack(&obj->q1);
    }else{
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

3.2 使用栈实现队列oj链接

typedef int STDataType;
typedef struct Stack {
    STDataType* _a;
    int _top;      // 栈顶
    int _capacity; // 容量
} Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
void StackInit(Stack* ps) {
    assert(ps);
    ps->_a = NULL;
    ps->_capacity = 0;
    ps->_top = 0;
}
// 入栈
void StackPush(Stack* ps, STDataType data) {
    assert(ps);
    if (ps->_capacity == ps->_top) {
        int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
        STDataType* tmp =
            (STDataType*)realloc(ps->_a, newcapacity * sizeof(STDataType));
        if (tmp == NULL) {
            perror("realloc fail");
            return;
        }
        ps->_a = tmp;
        ps->_capacity = newcapacity;
    }
    ps->_a[ps->_top] = data;
    ps->_top++;
}
// 出栈
void StackPop(Stack* ps) {
    assert(ps);
    assert(!StackEmpty(ps));
    ps->_top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps) {
    assert(ps);
    return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps) {
    assert(ps);
    return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps) {
    assert(ps);
    if (ps->_top == 0) {
        return 1;
    } else {
        return 0;
    }
}
// 销毁栈
void StackDestroy(Stack* ps) {
    assert(ps);
    free(ps->_a);
    ps->_a = NULL;
    ps->_capacity = ps->_top = 0;
}
typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL){
        perror("malloc fail");
    }
    StackInit(&obj->popst);
    StackInit(&obj->pushst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) {
    int front=myQueuePeek(obj);
    StackPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popst)){
        while(!StackEmpty(&obj->pushst)){
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);
    free(obj);
}

ღ星ღ
关注
  • 21
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构---栈和队列之顺序栈（C语言）
05-05
在这个主题中，我们将专注于两种基本的线性数据结构：栈和队列，特别是C语言实现的顺序栈。顺序栈是一种在内存中连续分配空间的抽象数据类型，它具有后进先出（LIFO）或先进后出（FILO）的特性。 ### 栈的基本概念 ...
数据结构---栈和队列之共享栈（C语言）
05-05
数据结构---栈和队列之共享栈（C语言）完整代码，可以运行
数据结构---栈和队列之链栈（C语言）
05-05
本话题主要探讨的是数据结构中的两种特殊结构：栈和队列，特别是如何使用C语言实现链栈。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是先进先出（FIFO, First In First Out）的数据结构。链栈...
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构---栈和队列之顺序队（C语言）
05-05
本主题聚焦于两种基本数据结构：栈和队列，特别是它们的一个实例——顺序队，用C语言实现。这里我们将深入探讨这些概念以及它们在实际编程中的应用。 栈是一种后进先出（LIFO）的数据结构，这意味着最后插入的元素...
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 386
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 229
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
java算法原理
jylee的博客
07-25 819
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
c语言（7.23）
fhgfyrsg的博客
07-23 687
【代码】c语言（7.23）
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 850
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
数据结构~~顺序表
TU^的博客
07-22 1122
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构：顺序表的实现
2303_81073778的博客
07-25 297
3.test.c文件。
Java实现七大排序（一）
lllsure的博客
07-23 571
插入排序、希尔排序、选择排序、堆排序
数据结构：（1）线性表
weixin_71751116的博客
07-24 1076
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
数据结构经典测试题4
c23856的博客
07-25 531
语句将'c'替换为'd'，字符串变更为"abddcccd"，同时指针it1加 加停在第四个字符'd'上，it2再次跳过字符'c'，停在最后一个'd'上，赋值后，字符串不变，再后移外层循环遇到0结束.p是char*类型，每次++，后移一个地址，char *p = str[0]相当于char *p = "stra"，p先指向其中的字符's'，printf输出遇到 0停止，第一次输出"stra"，p++后，指向字符't'，第二次输出"tra"，第三次输出"ra".上述代码运行结果是什么？上述代码运行结果是什么？
数据结构：数据类型与抽象数据类型
Weiki的博客
07-25 1211
数据结构：数据类型与抽象数据类型
数据结构前言
weixin_67466860的博客
07-25 1059
主要了解学习数据结构之前所需要了解的知识
数据结构--二叉树详解
2302_81705247的博客
07-24 799
二叉树的分类、二叉树的遍历。一棵树的节点个数，求叶子节点的个数，获取k层节点的个数，树的高度，找到某个节点，检查两棵树是否相同，第二棵树是否是第一棵树的子树，翻转二叉树，判断一棵二叉树是否是平衡二叉树，对称二叉树
算法 - 查找算法（顺序、折半、红黑树、AVL树、B+树、散列）
暴力扬
07-21 983
本文一共讲解了以下查找算法： 1. 顺序查找 2. 折半查找（二分查找） 3. 分块查找 4. 二叉排序树查找 5. 平衡二叉树（AVL树）查找 6. 红黑树查找 7. B树查找 8. B+树查找 9. 散列查找 每种查找算法都包括了其查找原理、实现步骤、代码实现思路、C语言代码以及代码解释。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ღ星ღ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值