数据结构进阶：使用链表实现栈和队列详解与示例（C, C#, C++）

news2024/9/23 21:32:08

文章目录

  • 1、 栈与队列简介
    • 栈（Stack）
    • 队列（Queue）
  • 2、使用链表实现栈
    • C语言实现
    • C#语言实现
    • C++语言实现
  • 3、使用链表实现队列
    • C语言实现
    • C#语言实现
    • C++语言实现
  • 4、链表实现栈和队列的性能分析
    • 时间复杂度
    • 空间复杂度
    • 性能特点
    • 与其他实现的比较
  • 总结

在这里插入图片描述

在软件开发中，数据结构是不可或缺的一部分。本文将详细介绍如何使用链表来实现栈和队列这两种基本的数据结构，并提供C、C#和C++三种语言的示例代码。

1、 栈与队列简介

栈（Stack）

栈是一种后进先出（Last In First Out, LIFO）的数据结构。栈的基本操作包括：

  1. push：将元素压入栈顶。
  2. pop：移除栈顶元素。
  3. peek：查看栈顶元素。

队列（Queue）

队列是一种先进先出（First In First Out, FIFO）的数据结构。队列的基本操作包括：

  1. enqueue：在队列尾部添加元素。
  2. dequeue：移除队列头部元素。
  3. peek：查看队列头部元素。

2、使用链表实现栈

链表是一种灵活的数据结构，非常适合实现栈。

C语言实现

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

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

typedef struct Stack {
    Node* top;
} Stack;

void initStack(Stack* stack) {
    stack->top = NULL;
}

void push(Stack* stack, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = stack->top;
    stack->top = newNode;
}

int pop(Stack* stack) {
    if (stack->top == NULL) {
        printf("栈为空\n");
        return -1;
    }
    Node* temp = stack->top;
    int data = temp->data;
    stack->top = stack->top->next;
    free(temp);
    return data;
}

int peek(Stack* stack) {
    if (stack->top == NULL) {
        printf("栈为空\n");
        return -1;
    }
    return stack->top->data;
}

void destroyStack(Stack* stack) {
    while (stack->top != NULL) {
        Node* temp = stack->top;
        stack->top = stack->top->next;
        free(temp);
    }
}

int main() {
    Stack stack;
    initStack(&stack);
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);
    printf("栈顶元素：%d\n", peek(&stack));
    printf("出栈元素：%d\n", pop(&stack));
    printf("出栈元素：%d\n", pop(&stack));
    destroyStack(&stack);
    return 0;
}

C#语言实现

using System;

public class Node {
    public int Data { get; set; }
    public Node Next { get; set; }
}

public class Stack {
    private Node top;

    public void Push(int data) {
        Node newNode = new Node { Data = data, Next = top };
        top = newNode;
    }

    public int Pop() {
        if (top == null) {
            throw new InvalidOperationException("栈为空");
        }
        int data = top.Data;
        top = top.Next;
        return data;
    }

    public int Peek() {
        if (top == null) {
            throw new InvalidOperationException("栈为空");
        }
        return top.Data;
    }
}

class Program {
    static void Main() {
        Stack stack = new Stack();
        stack.Push(1);
        stack.Push(2);
        stack.Push(3);
        Console.WriteLine("栈顶元素：" + stack.Peek());
        Console.WriteLine("出栈元素：" + stack.Pop());
        Console.WriteLine("出栈元素：" + stack.Pop());
    }
}

C++语言实现

#include <iostream>

struct Node {
    int data;
    Node* next;
};

class Stack {
public:
    Stack() : top(nullptr) {}

    ~Stack() {
        while (top != nullptr) {
            Node* temp = top;
            top = top->next;
            delete temp;
        }
    }

    void push(int data) {
        Node* newNode = new Node{data, top};
        top = newNode;
    }

    int pop() {
        if (top == nullptr) {
            throw std::runtime_error("栈为空");
        }
        Node* temp = top;
        int data = temp->data;
        top = top->next;
        delete temp;
        return data;
    }

    int peek() const {
        if (top == nullptr) {
            throw std::runtime_error("栈为空");
        }
        return top->data;
    }

private:
    Node* top;
};

int main() {
    Stack stack;
    stack.push(1);
    stack.push(2);
    stack.push(3);
    std::cout << "栈顶元素：" << stack.peek() << std::endl;
    std::cout << "出栈元素：" << stack.pop() << std::endl;
    std::cout << "出栈元素：" << stack.pop() << std::endl;
    return 0;
}

3、使用链表实现队列

队列是另一种常见的数据结构，同样可以通过链表来实现。

C语言实现

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

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

typedef struct Queue {
    Node* front;
    Node* rear;
} Queue;

void initQueue(Queue* queue) {
    queue->front = queue->rear = NULL;
}

void enqueue(Queue* queue, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    if (queue->rear == NULL) {
        queue->front = queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

int dequeue(Queue* queue) {
    if (queue->front == NULL) {
        printf("队列为空\n");
        return -1;
    }
    Node* temp = queue->front;
    int data = temp->data;
    queue->front = queue->front->next;
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    free(temp);
    return data;
}

int peekQueue(Queue* queue) {
    if (queue->front == NULL) {
        printf("队列为空\n");
        return -1;
    }
    return queue->front->data;
}

void destroyQueue(Queue* queue) {
    while (queue->front != NULL) {
        Node* temp = queue->front;
        queue->front = queue->front->next;
        free(temp);
    }
    queue->rear = NULL;
}

int main() {
    Queue queue;
    initQueue(&queue);
    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);
    printf("队首元素：%d\n", peekQueue(&queue));
    printf("出队元素：%d\n", dequeue(&queue));
    printf("出队元素：%d\n", dequeue(&queue));
    destroyQueue(&queue);
    return 0;
}

C#语言实现

using System;

public class Node {
    public int Data { get; set; }
    public Node Next { get; set; }
}

public class Queue {
    private Node front;
    private Node rear;

    public void Enqueue(int data) {
        Node newNode = new Node { Data = data };
        if (rear == null) {
            front = rear = newNode;
        } else {
            rear.Next = newNode;
            rear = newNode;
        }
    }

    public int Dequeue() {
        if (front == null) {
            throw new InvalidOperationException("队列为空");
        }
        int data = front.Data;
        front = front.Next;
        if (front == null) {
            rear = null;
        }
        return data;
    }

    public int Peek() {
        if (front == null) {
            throw new InvalidOperationException("队列为空");
        }
        return front.Data;
    }
}

class Program {
    static void Main() {
        Queue queue = new Queue();
        queue.Enqueue(1);
        queue.Enqueue(2);
        queue.Enqueue(3);
        Console.WriteLine("队首元素：" + queue.Peek());
        Console.WriteLine("出队元素：" + queue.Dequeue());
        Console.WriteLine("出队元素：" + queue.Dequeue());
    }
}

C++语言实现

#include <iostream>

struct Node {
    int data;
    Node* next;
};

class Queue {
public:
    Queue() : front(nullptr), rear(nullptr) {}

    ~Queue() {
        while (front != nullptr) {
            Node* temp = front;
            front = front->next;
            delete temp;
        }
    }

    void enqueue(int data) {
        Node* newNode = new Node{data, nullptr};
        if (rear == nullptr) {
            front = rear = newNode;
        } else {
            rear->next = newNode;
            rear = newNode;
        }
    }

    int dequeue() {
        if (front == nullptr) {
            throw std::runtime_error("队列为空");
        }
        Node* temp = front;
        int data = temp->data;
        front = front->next;
        if (front == nullptr) {
            rear = nullptr;
        }
        delete temp;
        return data;
    }

    int peek() const {
        if (front == nullptr) {
           throw std::runtime_error("队列为空");
        }
        return front->data;
    }

private:
    Node* front;
    Node* rear;
};

int main() {
    Queue queue;
    queue.enqueue(1);
    queue.enqueue(2);
    queue.enqueue(3);
    std::cout << "队首元素：" << queue.peek() << std::endl;
    std::cout << "出队元素：" << queue.dequeue() << std::endl;
    std::cout << "出队元素：" << queue.dequeue() << std::endl;
    return 0;
}

4、链表实现栈和队列的性能分析

时间复杂度

栈（Stack）

  • push（入栈）操作：O(1)

在链表实现的栈中，每次入栈操作只需要在链表头部插入一个新节点，这是一个常数时间操作。

  • pop（出栈）操作：O(1)

出栈操作涉及移除链表头部的节点，这同样是一个常数时间操作。

  • peek（查看栈顶元素）操作：O(1)

查看栈顶元素只需要返回链表头部的节点值，不需要遍历链表。

队列（Queue）

  • enqueue（入队）操作：O(1)

在链表实现的队列中，每次入队操作通常在链表尾部插入一个新节点，这也是一个常数时间操作。

  • dequeue（出队）操作：O(1)

出队操作涉及移除链表头部的节点，在链表实现的队列中，通常需要保持一个指向链表尾部的指针，以便于在尾部进行插入操作。为了使出队操作达到O(1)，我们可以使用双端链表（或两个指针分别指向头部和尾部），这样出队时只需要更新头部指针。

  • peek（查看队首元素）操作：O(1)

与栈类似，查看队首元素只需要返回链表头部的节点值。

空间复杂度

  • 栈和队列：O(n)

链表实现栈和队列的空间复杂度是线性的，其中n是栈或队列中元素的数量。每个元素都需要一个节点来存储。

性能特点

  1. 动态大小：链表实现的栈和队列可以根据需要动态地增长和收缩，不需要预先分配固定大小的存储空间。
  2. 无内存碎片：与数组实现相比，链表实现不会产生内存碎片，因为它们通过指针连接，不需要连续的内存空间。
  3. 插入和删除效率：链表的插入和删除操作不需要移动其他元素，只需改变指针，因此效率较高。
  4. 内存开销：链表实现需要额外的内存来存储节点间的指针，这可能比数组实现需要更多的内存。

与其他实现的比较

与数组实现的栈和队列比较：

  1. 数组实现的栈和队列在内存使用上可能更高效，因为它们不需要额外的指针字段。
  2. 数组实现的栈和队列可能需要预先分配固定大小的空间，这可能导致空间浪费或需要动态扩容，而链表实现则可以更加灵活地处理大小变化。

与平衡二叉搜索树（如AVL树、红黑树）实现的栈和队列比较：

  1. 使用平衡二叉搜索树实现的栈和队列在理论上可以达到O(log n)的时间复杂度，但是这在实际中很少见，因为这种实现过于复杂且在实践中不太必要。

总的来说，链表实现的栈和队列在大多数情况下提供了良好的性能，尤其是在元素数量变化较大或者内存使用需要优化时。然而，具体选择哪种实现方式还需要根据实际应用场景和性能需求来决定。

总结

本文通过C、C#和C++三种不同的编程语言，详细介绍了如何使用链表来实现栈和队列这两种基本的数据结构。每种实现都包括了初始化、添加元素、移除元素、查看顶部元素和销毁数据结构的完整操作。

链表由于其灵活性和动态性，是实现栈和队列的理想选择。通过本文的示例，我们可以看到，虽然不同的语言在语法和细节上有所不同，但核心概念和实现逻辑是相似的。

在实际应用中，理解这些数据结构的实现对于编写高效和可靠的应用程序至关重要。无论是进行算法设计、数据处理还是系统开发，掌握栈和队列的实现都是每个程序员的基本技能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1929751.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

VBA学习(21)：遍历文件夹（和子文件夹）中的文件

VBA学习(21)：遍历文件夹（和子文件夹）中的文件

很多时候&#xff0c;我们都想要遍历文件夹中的每个文件&#xff0c;例如在工作表中列出所有文件名、对每个文件进行修改。VBA给我们提供了一些方式&#xff1a;&#xff08;1&#xff09;Dir函数&#xff1b;&#xff08;2&#xff09;File System Object。 使用Dir函数 Dir…
阅读更多...
31.RAM-IP核的配置、调用、仿真全流程

31.RAM-IP核的配置、调用、仿真全流程

&#xff08;1&#xff09;RAM IP核简介 RAM是随机存取存储器&#xff08;Random Access Memory&#xff09;的简称&#xff0c;是一个易失性存储器&#xff0c;其工作时可以随时对任何一个指定地址写入或读出数据。&#xff08;掉电数据丢失&#xff09; &#xff08;2&#…
阅读更多...
Spring Cloud Gateway 入门与实战

Spring Cloud Gateway 入门与实战

一、网关 在微服务框架中&#xff0c;网关是一个提供统一访问地址的组件&#xff0c;它充当了客户端和内部微服务之间的中介。网关主要负责流量路由和转发&#xff0c;将外部请求引导到相应的微服务实例上&#xff0c;同时提供一些功能&#xff0c;如身份认证、授权、限流、监…
阅读更多...
【企业级监控】Zabbix监控MySQL主从复制

【企业级监控】Zabbix监控MySQL主从复制

Zabbix自定义监控项与触发器 文章目录 Zabbix自定义监控项与触发器资源列表基础环境前言四、监控MySQL主从复制4.1、部署mysql主从复制4.1.1、在两台主机&#xff08;102和103上安装&#xff09;4.1.2、主机102当master4.1.3、主机103当slave 4.2、MySQL-slave端开启自定义Key值…
阅读更多...
JMeter案例分享：通过数据验证的错误，说说CSV数据文件设置中的线程共享模式

JMeter案例分享：通过数据验证的错误，说说CSV数据文件设置中的线程共享模式

前言 用过JMeter参数化的小伙伴&#xff0c;想必对CSV Data Set Config非常熟悉。大家平时更关注变量名称&#xff0c;是否忽略首行等参数&#xff0c;其余的一般都使用默认值。然而我最近遇到一个未按照我的预想读取数据的案例&#xff0c;原因就出在最后一个参数“线程共享模…
阅读更多...
摄像头 RN6752v1 视频采集卡

摄像头 RN6752v1 视频采集卡

摄像头 AHD倒车摄像头比较好&#xff0c;AHD英文全名Analog High Definition&#xff0c;即模拟高清&#xff0c;拥有比较好的分辨率与画面质感。 RN6752v1 GQW AKKY2 usb 采集卡 FHD&#xff08;1080p&#xff09;、HD&#xff08;720p&#xff09;和D1&#xff08;480i&am…
阅读更多...
开始Linux之路

开始Linux之路

人生得一知己足矣&#xff0c;斯世当以同怀视之。——鲁迅 Linux操作系统简单操作指令 1、ls指令2、pwd命令3、cd指令4、mkdir指令(重要)5、whoami命令6、创建一个普通用户7、重新认识指令8、which指令9、alias命令10、touch指令11、rmdir指令 及 rm指令(重要)12、man指令(重要…
阅读更多...
C# Winform的三态CheckBox，以及批量修改Panel中的控件

C# Winform的三态CheckBox，以及批量修改Panel中的控件

在C# WinForms中&#xff0c;如果你想批量修改一个Panel容器内的所有CheckBox控件的状态&#xff0c;你可以使用foreach循环来遍历Panel的Controls集合。下面是一个示例&#xff0c;展示了如何将一个Panel内所有的CheckBox控件设为选中状态&#xff08;Checked true&#xff0…
阅读更多...
借助 Aspose.Words，在 C# 中将 Word 转换为 JPG

借助 Aspose.Words，在 C# 中将 Word 转换为 JPG

有时我们需要将 Word 文档转换为图片&#xff0c;因为 DOC 或 DOCX 文件在不同设备上的显示可能会有所不同&#xff0c;但图像&#xff08;例如 JPG 格式&#xff09;在任何地方看起来都一样。 Aspose.Words 是一种高级Word文档处理API&#xff0c;用于执行各种文档管理和操作…
阅读更多...
超声波眼镜清洗机哪个牌子好？2024年超全热门眼镜清洗机推荐

超声波眼镜清洗机哪个牌子好？2024年超全热门眼镜清洗机推荐

夏天来了&#xff0c;在户外活动不到几分钟就已经大汗淋漓&#xff01;特别是汗珠一滴滴的挂在眼皮上往下坠落简直让戴眼镜的人苦不堪言&#xff01;虽说戴眼镜在现如今来看是非常普遍的一件事情&#xff0c;但是人们一直深受眼镜清洗的困扰&#xff01;很多朋友看到这里可能会…
阅读更多...
C++学习日记 | Lecture 9 类基础

C++学习日记 | Lecture 9 类基础

资料来源&#xff1a;南科大 余仕琪 C/C Program Design LINK&#xff1a; CPP/week09 at main ShiqiYu/CPP GitHub9.1-classes-and-objects_哔哩哔哩_bilibili9.2-constructors-and-destructors_哔哩哔哩_bilibili9.3-this-pointer_哔哩哔哩_bilibili9.4-const-and-static…
阅读更多...
好用的《身份证工具》插件，解锁6大实用功能

好用的《身份证工具》插件，解锁6大实用功能

在数据处理领域&#xff0c;超级处理器插件凭借其强大的功能和高效的性能&#xff0c;一直是Excel和WPS用户的心头好。而今&#xff0c;这一优秀插件再次迎来革新——身份证工具功能现已支持单独安装使用&#xff0c;为用户带来前所未有的便利与灵活性。 超级处理器下载与安装…
阅读更多...
matlab入门学习

matlab入门学习

一、什么是matlab MATLAB&#xff08;matrix laboratory矩阵实验室&#xff09;是一款商用数学软件&#xff0c;主要面对科学计算、可视化以及交互式程序设计的高科技计算环境。可用于数据分析、深度学习、图像处理与计算机视觉、量化金融与风险管理等领域。 二、matlab和pyt…
阅读更多...
快速在springboot项目中应用EasyExcel

快速在springboot项目中应用EasyExcel

目录 ​编辑一、介绍 二、准备工作 三、初始化项目 3.1 创建项目 3.2 引入依赖 3.3 创建数据库和数据表 3.4 编写application.properties文件 四、开始编写 4.1 目录结构 4.2 MyBatis配置类 4.3 用户实体类 4.4 mapper接口 4.5 编写数据操作文件 4.6 编写Service 业…
阅读更多...
静态链接——编译和链接

静态链接——编译和链接

一、编译和链接的过程 1、GCC生成可执行文件的总体过程 在日常的开发过程中&#xff0c;IDE总是会帮我们将编译和链接合并&#xff0c;一键式的执行,即使在liunx中&#xff0c;使用命令行来编译一个源文件也只是简单的一句"gcc hello.c"。我们并没有过多的关注编译和…
阅读更多...
linux的学习（五）：shell编程中的变量，运算符，条件判断

linux的学习（五）：shell编程中的变量，运算符，条件判断

简介&#xff1a; shell编程的基本概念&#xff0c;定义变量&#xff0c;运算符&#xff0c;条件判断的基本使用 shell编程 把多个命令写到一个文件里&#xff0c;这个文件就是脚本&#xff0c;里面还有很多的流程控制 基本概念 脚本的后缀名是.sh 脚本的执行&#xff1a;…
阅读更多...
全面理解Spring6框架到熟悉与掌握

全面理解Spring6框架到熟悉与掌握

个人笔记梳理&#xff0c;仅供参考 Spring是一款主流的JavaEE轻量级开源框架 Spring的狭义和广义 广义的Spring&#xff1a;Spring技术栈 泛指以Spring Framework为核心的Spring技术栈 经过十多年的发展&#xff0c;Spring已经不再是一个单纯的应用框架&#xff0c;而是逐…
阅读更多...
EasyAnimate-v3版本支持I2V及超长视频生成

EasyAnimate-v3版本支持I2V及超长视频生成

阿里云人工智能平台&#xff08;PAI&#xff09;自研开源的视频生成项目EasyAnimate正式发布v3版本&#xff1a; 支持 图片&#xff08;可配合文字&#xff09; 生成视频 支持 上传两张图片作为起止画面 生成视频 最大支持720p&#xff08;960*960分辨率&#xff09; 144帧视…
阅读更多...
量化投资基础（一）之均值方差模型一

量化投资基础（一）之均值方差模型一

点赞、关注&#xff0c;养成良好习惯 Life is short, U need Python 量化投资基础系列&#xff0c;不断更新中 1. 投资组合收益率与风险 假设市场有 N N N 个资产&#xff0c;其随机收益率分别为 R 1 , R 2 , … , R N R_1,R_2,\dots,R_N R1​,R2​,…,RN​ &#xff0c;对应…
阅读更多...
蓝桥 双周赛算法赛【小白场】

蓝桥 双周赛算法赛【小白场】

博客主页&#xff1a;誓则盟约系列专栏&#xff1a;IT竞赛 专栏关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ 蓝桥第14场小白入门赛T1/T2/T3 题目&#xff1a; T1照常还是送分题无需多…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023