【数据结构】—— 栈和队列

最新推荐文章于 2023-09-27 23:58:19 发布
最新推荐文章于 2023-09-27 23:58:19 发布
阅读量180 收藏
点赞数 1
分类专栏： OC C 数据结构 文章标签： 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50990189/article/details/120459961
版权
OC 同时被 3 个专栏收录
53 篇文章 2 订阅
订阅专栏
C
11 篇文章 0 订阅
订阅专栏
数据结构
3 篇文章 0 订阅
订阅专栏
本文深入探讨了数据结构中的栈和队列，详细介绍了它们的定义、特点以及在实际操作中的应用。栈是后进先出（LIFO）的数据结构，常用于表达式求值、递归等场景，文中给出了数组和链表两种实现方式。队列则是先进先出（FIFO）的数据结构，适用于任务调度、打印队列等，同样展示了循环队列和链表实现。此外，还提供了相关的操作示例代码，帮助读者理解这两种重要的数据结构。
摘要由CSDN通过智能技术生成

文章目录

栈

栈的定义

是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。
在这里插入图片描述
栈又称为*后进先出（Last In First Out）的线性表，简称LIFO结构。
在这里插入图片描述

有关栈的一些定义

  • 栈顶（top）：允许插入和删除的一端。
  • 栈底（bottom）：不允许插入和删除。
  • 空栈：不含任何数据元素的栈。
  • 压栈（入栈）：即在栈顶添加（插入）一个元素

栈的两种实现方式

栈的顺序存储结构

如用数组实现，栈底是：下标为0的一端：
在这里插入图片描述

demo：

//
//  main.c
//  栈
//
//  Created by haoqianbiao on 2021/9/25.
//

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

#define StackSize 5

typedef struct {
    int data[StackSize];
    int top;
}SeqStack;

void InitStack(SeqStack* S);
void Push(SeqStack* S, int x);
int Pop(SeqStack* S, int* ptr);
int GetTop(SeqStack* S, int* ptr);
int Empty(SeqStack* S);
int Print(SeqStack* S);


int main(int argc, const char * argv[]) {
    int x;
    SeqStack S;
    InitStack(&S);
    printf("对1～5执行入栈操作");
    for(int i = 1; i <= 5; i++) {
        Push(&S, i);
    }
    Print(&S);
    if(GetTop(&S, &x) == 1) {
        printf("当前栈顶元素为%d\n", x);
    }
    if (Pop(&S, &x) == 1) {
        printf("执行一次出栈操作，删除元素：%d\n", x);
    }
    if(GetTop(&S, &x) == 1) {
        printf("当前栈顶元素为：%d\n", x);
    }
    printf("请输入待入栈元素：");
    scanf("%d", &x);
    Push(&S, x);
    Print(&S);
    if (Empty(&S) == 1) {
        printf("栈为空\n");
    } else {
        printf("栈非空\n");
    }
    return 0;
}
void InitStack(SeqStack* S) {
    S->top = -1;
    printf("初始化成功！\n");
}

void Push(SeqStack* S, int x) {
    if (S->top == StackSize - 1) {
        printf("上溢错误，插入失败！\n");
    }
    S->data[++S->top] = x;
    printf("入栈成功！\n");
}

int Pop(SeqStack* S, int* ptr) {
    if (S->top == -1) {
        printf("下溢错误，删除失败！\n");
        return 0;
    }
    *ptr = S->data[S->top--];
    return *ptr;
}

int GetTop(SeqStack* S, int* ptr) {
    if (S->top == -1) {
        printf("下溢错误，取栈顶失败！\n");
        return 0;
    }
    *ptr = S->data[S->top];
    return 1;
}

int Empty(SeqStack* S) {
    if (S->top == -1) {
        return 1;
    } else {
        return 0;
    }
}

int Print(SeqStack* S) {
    printf("栈内元素：\n");
    for (int i = 0; i <= S->top; i++) {
        printf("%d ", S->data[i]);
    }
    printf("\n");
    return 1;
}

栈的链式存储结构

在这里插入图片描述

  • 入栈操作：

在这里插入图片描述

  • 出栈操作

在这里插入图片描述

demo：

//
//  main.c
//  栈之链式存储结构
//
//  Created by haoqianbiao on 2021/9/25.
//

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;

typedef struct Node {
    DataType data;
    struct Node* next;
}Node;

Node* InitStack(Node* top);
Node* Push(Node* top, DataType x);
Node* GetTop(Node* top, DataType* ptr);
void DestoryStack(Node* top);
Node* Pop(Node* top, DataType* ptr);
int Empty(Node* top);
void Print(Node* top);
int main(){
    DataType x = 0;
    Node * top = InitStack(top);
    printf("对0~4执行入栈操作:\n");
    for(int i = 0; i < 5; i++) {
        top = Push(top, i);
    }
    Print(top);
    top = GetTop(top, &x);
    printf("当前栈顶元素为：%d\n", x);
    top = Pop(top,&x);
    printf("执行一次出栈操作，删除元素：%d\n",x);
    top =GetTop(top,&x);
    printf("当前栈顶元素为：%d\n",x);
    printf("请输入待入栈元素：");
    scanf("%d",&x);
    top = Push(top,x);
    Print(top);
    if(Empty(top)==1)
        printf("栈为空\n");
    else
        printf("栈非空\n");
    DestoryStack(top);
    return 0;
}

//初始化
Node* InitStack(Node* top) {
    top = NULL;

    printf("初始化成功！");
    return top;
}

//入栈
Node* Push(Node* top, DataType x) {
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = x;
    s->next = top;
    top = s;
    printf("%d入栈成功！\n", x);
    return top;
}

Node* GetTop(Node* top, DataType* ptr) {
    if (top == NULL) {
        printf("下溢错误，取栈顶失败\n");
        return 0;;
    }
    *ptr = top->data;
    return top;
}

//销毁
void DestoryStack(Node* top) {
    Node* p = top;
    while (top != NULL) {
        top = top->next;
        free(p);
        p = top;
    }
}

Node* Pop(Node* top, DataType* ptr) {
    Node* p = top;
    if(top == NULL) {
        printf("下溢错误，删除失败\n");
        return 0;
    }
    *ptr = top->data;
    top = top->next;
    free(p);
    return top;
}

int Empty(Node* top) {
    if (top == NULL) {
        return 1;
    } else {
        return 0;
    }
}

void Print(Node* top) {
    Node* p = top;
    while(p) {
        printf("%d\n", p->data);
        p = p->next;
    }
}

队列

队列的定义：

只允许在一端插入数据操作，在另一端进行删除数据操作的特殊线性表；进行插入操作的一端称为队尾（入队列），进行删除操作的一端称为队头（出队列）；队列具有先进先出（FIFO）的特性。
请添加图片描述

demo:

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;

typedef struct Node {
    DataType data;
    struct Node* next;
}Node;

Node* InitStack(Node* top);
Node* Push(Node* top, DataType x);
Node* GetTop(Node* top, DataType* ptr);
void DestoryStack(Node* top);
Node* Pop(Node* top, DataType* ptr);
int Empty(Node* top);
void Print(Node* top);
int main(){
    DataType x = 0;
    Node * top = InitStack(top);
    printf("对0~4执行入栈操作:\n");
    for(int i = 0; i < 5; i++) {
        top = Push(top, i);
    }
    Print(top);
    top = GetTop(top, &x);
    printf("当前栈顶元素为：%d\n", x);
    top = Pop(top,&x);
    printf("执行一次出栈操作，删除元素：%d\n",x);
    top =GetTop(top,&x);
    printf("当前栈顶元素为：%d\n",x);
    printf("请输入待入栈元素：");
    scanf("%d",&x);
    top = Push(top,x);
    Print(top);
    if(Empty(top)==1)
        printf("栈为空\n");
    else
        printf("栈非空\n");
    DestoryStack(top);
    return 0;
}

//初始化
Node* InitStack(Node* top) {
    top = NULL;

    printf("初始化成功！");
    return top;
}

//入栈
Node* Push(Node* top, DataType x) {
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = x;
    s->next = top;
    top = s;
    printf("%d入栈成功！\n", x);
    return top;
}

Node* GetTop(Node* top, DataType* ptr) {
    if (top == NULL) {
        printf("下溢错误，取栈顶失败\n");
        return 0;;
    }
    *ptr = top->data;
    return top;
}

//销毁
void DestoryStack(Node* top) {
    Node* p = top;
    while (top != NULL) {
        top = top->next;
        free(p);
        p = top;
    }
}

Node* Pop(Node* top, DataType* ptr) {
    Node* p = top;
    if(top == NULL) {
        printf("下溢错误，删除失败\n");
        return 0;
    }
    *ptr = top->data;
    top = top->next;
    free(p);
    return top;
}

int Empty(Node* top) {
    if (top == NULL) {
        return 1;
    } else {
        return 0;
    }
}

void Print(Node* top) {
    Node* p = top;
    while(p) {
        printf("%d\n", p->data);
        p = p->next;
    }
}

队列的相关操作

  • 入队： 通常命名为push()
  • 出队： 通常命名为pop()
  • 求队列中元素个数
  • 判断队列是否为空
  • 获取队首元素

队列的两种实现方式

队列的顺序存储结构（循环队列）

数组作为底层数据结构时，一般讲队列实现为循环队列。这是因为队列在顺序存储上的不足：每次从数组头部删除元素（出队）后，需要将头部以后的所有元素往前移动一个位置，这是一个时间复杂度为O（n）的操作：
在这里插入图片描述

所谓的循环队列，可以把数组看出一个首尾相连的圆环，删除元素时将队首标志往后移动，添加元素时若数组尾部已经没有空间，则考虑数组头部的空间是否空闲，如果是，则在数组头部进行插入。在这里插入图片描述

demo（数组）

#include <stdio.h>

// 保存数据的数组
int arr[500];
// 队列的实际大小
int count;

// 将val添加到队列的末尾
void add(int val)
{
    arr[count++] = val;
}

// 返回“队列开头元素”
int front()
{
    return arr[0];
}

// 返回并删除“队列开头元素”
int pop()
{
    int i = 0;;
    int ret = arr[0];
    count--;
    while (i++ < count)
        arr[i - 1] = arr[i];
    return ret;
}

// 返回“队列”的大小
int size()
{
    return count;
}

// 返回“队列”是否为空
int is_empty()
{
    return count==0;
}

int main()
{
    int tmp = 0, i;
    
    // 将10, 20, 30 依次推入队列中
    add(10);
    add(20);
    add(30);
    
    for(i = 0;i < size(); i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 将“队列开头的元素”赋值给tmp，并删除“该元素”
    tmp = pop();
    printf("tmp=%d\n", tmp);

    // 只将“队列开头的元素”赋值给tmp，不删除该元素.
    tmp = front();
    printf("tmp = %d\n", tmp);

    add(40);

    // 打印队列
    printf("is_empty = %d\n", is_empty());
    printf("size = %d\n", size());
    while (!is_empty()) {
        printf("%d\n", pop());
    }
    return 0;
}

demo（数组+循环队列）：


#include <stdio.h>

// 保存数据的数组
int arr[50];
// 队列的实际大小
int count;

//队头和队尾下标
int front;
int tail;


int size()
{
    return tail-front;
}

// 返回“队列”是否为空
int is_empty()
{
    if(front == tail){
        return 1;
    }
    return 0;
}
// 返回“队列”是否为满
int is_full()
{
    if(front == (tail + 1) % 50) return 1;
    return 0;
}
// 将val添加到队列的末尾
void add(int val)
{
    if(!is_full())
    {
        arr[tail] = val;
        tail = (tail + 1) % 50;
    }
     else
    {
        printf("队列满\n");
    }
}

// 返回“队列开头元素”
int first()
{
    return arr[front];
}

// 返回并删除“队列开头元素”
int pop()
{
    int ret;
    if(!is_empty())
    {
        
        ret=arr[front] ;
        front=(front+1)%50;
    }
     else
    {
        printf("队列空\n");
    }
    return ret;
}

int main()
{
    int tmp = 0, i;
    // 将10, 20, 30 依次推入队列中
    add(10);
    add(20);
    add(30);
    
    for(i=0;i<size();i++) {
        printf("%d ",arr[i]);
    }
    printf("\n");

    // 将“队列开头的元素”赋值给tmp，并删除“该元素”
    tmp = pop();
    printf("tmp = %d\n", tmp);
    

    // 只将“队列开头的元素”赋值给tmp，不删除该元素.
    tmp = first();
    printf("tmp = %d\n", tmp);

    add(40);

    // 打印队列
    printf("is_empty()=%d\n", is_empty());
    printf("size()=%d\n", size());
    while (!is_empty())
    {
        printf("%d\n", pop());
    }
    return 0;
}

队列的链式存储结构

链式队列的实现思想同顺序队列类似，只需创建两个指针（命名为 top 和 rear）分别指向链表中队列的队头元素和队尾元素，如图 1 所示:
请添加图片描述

入队：
链队队列中，当有新的数据元素入队，只需进行以下 3 步操作：
将该数据元素用节点包裹，例如新节点名称为 elem；
与 rear 指针指向的节点建立逻辑关系，即执行 rear->next=elem；
最后移动 rear 指针指向该新节点，即 rear=elem；
请添加图片描述

出队：
当链式队列中，有数据元素需要出队时，按照 “先进先出” 的原则，只需将存储该数据的节点以及它之前入队的元素节点按照原则依次出队即可。这里，我们先学习如何将队头元素出队。

链式队列中队头元素出队，需要做以下 3 步操作：
通过 top 指针直接找到队头节点，创建一个新指针 p 指向此即将出队的节点；
将 p 节点（即要出队的队头节点）从链表中摘除；
释放节点 p，回收其所占的内存空间；

请添加图片描述

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

typedef struct QNode{
    int data;
    struct QNode * next;
}QNode;

QNode * initQueue(){
    QNode * queue=(QNode*)malloc(sizeof(QNode));
    queue->next=NULL;
    return queue;
}

QNode* enQueue(QNode * rear,int data){
    QNode * enElem=(QNode*)malloc(sizeof(QNode));
    enElem->data=data;
    enElem->next=NULL;
    //使用尾插法向链队列中添加数据元素
    rear->next=enElem;
    rear=enElem;
    return rear;
}

QNode* DeQueue(QNode * top,QNode * rear){
    QNode * p = NULL;
    if (top->next==NULL) {
        printf("\n队列为空");
        return rear;
    }
    p=top->next;
    printf("%d ",p->data);
    top->next=p->next;
    if (rear==p) {
        rear=top;
    }
    free(p);
    return rear;
}

int main() {
    QNode * queue,*top,*rear;
    queue=top=rear=initQueue();//创建头结点
    //向链队列中添加结点，使用尾插法添加的同时，队尾指针需要指向链表的最后一个元素
    rear=enQueue(rear, 1);
    rear=enQueue(rear, 2);
    rear=enQueue(rear, 3);
    rear=enQueue(rear, 4);
    //入队完成，所有数据元素开始出队列
    rear=DeQueue(top, rear);
    rear=DeQueue(top, rear);
    rear=DeQueue(top, rear);
    rear=DeQueue(top, rear);
    rear=DeQueue(top, rear);
    return 0;
}
轩墨️
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 -- 线性表、栈(双端栈)、队列(循环队列)的实现
mateng52的博客
09-20 256
数据结构–线性表的实现 定义一个List接口(线性表父接口)，如下： public interface List<E> { //获取线性表元素的个数（线性表的长度） //@return 线性表中的有效元素的个数 public int getSize(); /** 判断线性表是否为空 * @return 是否为空的布尔类型值 */ public boolean isEm...
用C++的数组和链表两种方法实现线性表，堆栈，队列等线性数据结构(面向对象思维)
weixin_42896310的博客
01-08 424
用C++的数组和链表两种方法实现线性表，堆栈，队列等线性数据结构 这里提供了使用C++来实现以上三种线性结构的代码，这三种结构都比较简单，相信读者很快就能明白。关于线性结构的知识点，推荐大家可以看看中国大学MOOC浙江大学开的《数据结构课程》，这里就不介绍了。 数组表示 线性表 #include<iostream> #define maxsize 100000 using namesp...
数据结构（线性表、栈与队列、树、图）
fly_Xiaoma的博客
06-10 3010
一、线性表 线性表是最常用且最简单的一种数据结构，它是n个数据元素的有限序列。 实现线性表的方式一般有两种： 使用数组存储线性表的元素，即用一组连续的存储单元依次存储线性表的数据结构 使用链表存储线性表的元素，即用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的） 数组实现 数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。虽然数组一旦创...
每日一课 | 栈与队列的存储结构与实现
sinat_32849897的博客
07-08 1334
05.栈与队列的存储结构与实现大家好，我是小C，上期给大家分享——栈与队列的定义本期分享内容：栈与队列的存储结构与实现本期小C邀请的是春晨溅雨·4位算法工程师为我们分享《数据结构算法面试...
栈和队列基本概念，顺序栈的表示和实现
qq_45918426的博客
02-15 663
文章目录栈队列顺序栈顺序栈的存储结构顺序栈的基本操作初始化入栈出栈取栈顶元素 栈 栈（stack）是限定仅在表尾进行插入或删除操作的线性表。其表尾称为栈顶（top），表头称为栈底（bottom）。不含元素的栈称为空栈。 假设栈S=（a1,a2,a3,…,an），a1则为栈底元素，an为栈顶元素，元素按a1,a2,a3,…,an的顺序进栈，按an,…,a3,a2,a1的顺序出栈，如上图所示，所以栈...
数据结构——栈和队列
最新发布
fax_player的博客
09-27 4560
本文详细介绍的栈和队列的实现方式，更是重点提到了4个关于栈和队列的OJ题：分别是设计循环队列，用栈实现队列，用队列实现栈，有效的括号。
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
数据结构期末通关——栈与队列PPT
08-16
在本课程中，我们将重点关注两种基本的数据结构：栈和队列，它们是许多复杂算法和程序设计的基础。 栈是一种被称为“后进先出”（LIFO，Last In First Out）的数据结构。它的操作主要包括压栈（Push）和弹栈（Pop）...
线性表、栈和队列的概述
weixin_42604175的博客
09-10 1456
1.线性表 线性表的定义：零个或多个元素的有序队列。 注意：首先它是一个序列。也就是说元素之间是有序的，如果存在多个元素，则第一个元素没有前驱，最后一个元素没有后继，其他元素则有且仅有一个前驱和一个后继。 线性表中元素的个数n定义为线性表的长度，当n=0时，则线性表为空表。 注意：通常我们用一维数组来实现线性表的顺序存储结构，那么我们就要注意区分数组长度和线性表的长度； 数组长度：...
堆栈——链表实现
weixin_34320724的博客
03-25 77
#include <iostream> #include <cstdio> #include <cstdlib> #include <ctime> using namespace std; using ElemType = int; // 堆栈结构 class Node { public: ElemType da...
队列和栈区别
Mielt的博客
08-03 1024
共同点： 栈： 是一种受限表的一端插入和删除数据的线性表，栈又称：后进先出，LIFO表 队列：同样是一种受限的线性表，只有在标的一端插入数据，另一端删除数据，先进先出的特性，FIFO表 栈：就如箱子装东西，只有后放入的才能最先拿出——后进先出 队列：就如一条路只有一个入口和出口，只有先进去的就能先出来——先进先出 主要区别： 特性不同： 栈：后进先出 队列：先进先出 数据操作插入和删除的不同： 栈：只能从栈顶插入和删除，就是表的一端进行插入和删除操作 队列：限定在表的一端插入，另一端.
链栈函数
双手敲键盘
04-20 354
链栈函数 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define TRUE 1 #define FLASE 0 #define OK 1 #define ERROR 0 typedef int ElempType; typedef struct LNode{ ElempType da...
【iOS开发】—— 图片转化成base64编码
weixin_50990189的博客
04-13 6025
一、图片转 Base64字符串 UIImage * image = [UIImage imageNamed:@"图片名称"]; NSData * imageData = UIImageJPEGRepresentation(image, 1); NSString * base64Str = [imageData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength]; 二、base64转化成图
【iOS开发】—— UICollectionView的介绍
weixin_50990189的博客
12-07 5386
UICollectionView的简单学习
【iOS开发】—— nil、Nil、NSNull和NULL
weixin_50990189的博客
04-17 3866
文章目录nilNilNULLNSNull分析 nil nil是用来表示一个对象是空对象，即想要表示此对象不存在。给对象赋值时一般会使用object = nil，表示我想把这个对象释放掉；或者对象引用计数器为0了，系统将这块内存释放掉，这个时候这个对象被置为nil。 Nil Nil是用来表示一个类是空类。比如：Class myClass = Nil;。和nil没有明确的区分，也就是说凡是使用nil的地方都可以用Nil来代替，反之亦然。约定俗成地将nil表示一个空对象，Nil表示一个空类。 NULL NULL是
【iOS开发】—— GCD
weixin_50990189的博客
03-19 3367
文章目录GCD概述什么是GCD？多线程编程GCD的APIDispatch Queuedispatch_queue_createMain Dispatch Queue/Global Dispatch Queuedispatch_set_target_queuedispatch_after GCD概述 什么是GCD？ GCD（Grand Center Dispatch）是异步执行任务的技术之一。开发者定义想执行的任务并且追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。 多线程
【Effective Objective-C】——接口与API设计
weixin_50990189的博客
01-22 2379
文章目录概述用前缀避免命名空间重复 概述 开源社区以及开源组件随着iOS开发而流行起来，所以我们 经常会在开发自己的应用程序时使用他人的代码。所以我们要把代码写的清晰一些，以便其他开发者能够迅速而方便的将其集成到他们的项目里。 用前缀避免命名空间重复 Object-C没有其他语言那种内置的命名空间机制，所以我们在起名时要设法避免潜在的命名冲突。如果发生命名冲突，那么应用程序的链接过程就会出错。 比无法链接更糟糕的情况是，在运行期载入了含有重名类的程序库。此时，“动态加载器”就遭遇了“重名符号错误”，很可能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值