数据结构（五）、C++链表实现队列

已于 2022-12-02 15:00:16 修改
阅读量656 收藏 2
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构 c++
于 2022-11-21 11:47:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weijianjain/article/details/127961589
版权

链表实现队列

1、实现原理

通过操作数组的下标来实现队列结构。
栈数组结构体定义：

    template<class T>
    class Queue
    {
    public:
        struct node
        {
            node() :m_data(), m_next(nullptr) {}
            T m_data;
            node* m_next;
        };
        Queue() :m_front(nullptr), m_fear(nullptr) {}
    private:
        node* m_front;   // 头节点
        node* m_fear;    // 尾节点
    }

（1）、入队实操说明

  • 插入元素（1）
        /*
             队列链表m_stNode:
             m_front = m_fear = nullptr     temp节点    -----  m_next           
                                                        | 1 |----------> nullptr
                                                        -----    

                                       ||
                                       ||   m_front = m_fear = temp
                                       ||
                                      \\//

                                -----  m_next              
                                | 1 |----------> nullptr   
                                -----                      
                                |   |
                           m_front  m_fear        
        */
  • 插入元素（2）
        /*
             队列链表m_stNode:
                      -----  m_next                  
                      | 1 |----------> nullptr         temp节点    -----  m_next
                      -----                                        | 2 |----------> nullptr
                      |   |                                        -----
                 m_front  m_fear    

                                       ||
                                       ||   m_fear->m_next = temp;
                                       ||   m_fear = temp;        
                                      \\//

                     -----  m_next    -----  m_next
                     | 2 |----------> | 1 |----------> nullptr
                     -----            -----
                      |                |   
                    m_fear          m_front  
        */
  • 插入元素（3）
        /*
             队列链表m_stNode:
                 -----  m_next    -----  m_next
                 | 2 |----------> | 1 |----------> nullptr       temp节点    -----  m_next
                 -----            -----                                      | 3 |----------> nullptr
                  |                |                                         -----
                m_fear          m_front

                                       ||
                                       ||   m_fear->m_next = temp;
                                       ||   m_fear = temp;
                                      \\//

                   -----  m_next     -----  m_next    -----  m_next
                   | 3 |---------->  | 2 |----------> | 1 |----------> nullptr
                   -----             -----            -----
                      |                                 |
                    m_fear                           m_front
        */

（2）、出队实操说明

  • 移除首元素（1）
        /*
             队列链表m_stNode:
                   -----  m_next     -----  m_next    -----  m_next
                   | 3 |---------->  | 2 |----------> | 1 |----------> nullptr
                   -----             -----            -----
                      |                                 |
                    m_fear                           m_front

                                       ||
                                       ||   m_front = m_front->m_next
                                       ||   
                                      \\//

                   -----  m_next     -----  m_next    
                   | 3 |---------->  | 2 |----------> nullptr
                   -----             -----            
                      |                |
                    m_fear          m_front
        */
  • 移除首元素（2）
        /*
             队列链表m_stNode:
                   -----  m_next     -----  m_next
                   | 3 |---------->  | 2 |----------> nullptr
                   -----             -----
                      |                |
                    m_fear          m_front

                                       ||
                                       ||   m_front = m_front->m_next
                                       ||
                                      \\//

                   -----  m_next   
                   | 3 |----------> nullptr
                   -----           
                   |  |
               m_fear m_front
        */
  • 移除首元素（3）
        /*
             队列链表m_stNode:
                   -----  m_next
                   | 3 |----------> nullptr
                   -----
                   |  |
               m_fear m_front

                                       ||   m_fear = m_fear->m_next;
                                       ||   m_front = m_front->m_next
                                       ||
                                      \\//
             
                                    nullptr                               
        */

2、整体代码

#include <iostream>

namespace queue_list
{
        template<class T>
    class Queue
    {
    public:
        struct node
        {
            node() :m_data(), m_next(nullptr) {}
            T m_data;
            node* m_next;
        };
        Queue() :m_front(nullptr), m_fear(nullptr) {}

        /**
         * @brief 尾插
         */
        void push(T m_pdata)
        {
            node* temp = new node;
            temp->m_data = m_pdata;
            temp->m_next = nullptr;

            if (m_front == nullptr)         // 插入第一个元素时，让头尾节点都指向temp这块内存
            {
                m_front = temp;
                m_fear = temp;
            }
            else
            {
                m_fear->m_next = temp;    // 将temp节点赋值到尾指针的下一个指针，因为头尾节点都指向同一块内存，所以头节点保存全部队列节点
                m_fear = temp;            // 将temp赋值给m_fear尾节点，方便下一次插入操作
            }
        }

        /**
         * @brief 头删
         */
        void pop()
        {
            if (m_front == nullptr)       // 头节点为空，表示队列为空
            {
                std::cout << "queue is empty" << std::endl;
            }
            else
            {
                node* temp = m_front;             // 先保存头节点
                if (m_front == m_fear)            // 当队列只剩下一个元素时，操作尾节点的下一个指针为空
                {
                    m_fear = m_fear->m_next;
                }
                m_front = m_front->m_next;        // 头节点指向头节点原来的下一个指针
                delete temp;
            }
        }

        /**
         * @brief 打印
         */
        void print_queue()
        {
            node* temp = m_front;
            while (temp != nullptr)
            {
                std::cout << temp->m_data << " ";
                temp = temp->m_next;
            }
            std::cout << std::endl;
        }

    private:
        node* m_front;   // 头节点
        node* m_fear;    // 尾节点
    };

    void test_queue_list()
    {
        queue_list::Queue<int> m_queue;
        m_queue.push(1);
        m_queue.push(2);
        m_queue.push(3);
        m_queue.print_queue();       // 1 2 3

        m_queue.pop();
        m_queue.print_queue();       // 2 3

        m_queue.pop();
        m_queue.print_queue();       // 3

        m_queue.pop();
        m_queue.print_queue();
    }

}// namespace queue_list

int main()
{
    queue_list::test_queue_list();
    return 0;
}
牛马不分
关注
专栏目录
C++链表实现队列
woshidage687的博客
06-13 571
//queue.hpp #pragma once #include <iostream> using namespace std; template <class T> class Node { public: Node<T>* next; T data; }; template <class T> class Queue { public: Queue(); ~Queue(); bool isEmpty(); int size();
c++链表队列的实现
09-01
c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现
使用链表实现队列C++
weixin_43010548的博客
10-16 1482
要求 \quad使用链表实现队列，需要能够实现插入、删除元素，输出当前队列长度. 分析 使用链表作为实现队列的数据结构，按照先入先出的原则，插入元素在链表尾部插入，然后更新链表尾部指针，出队列时，在链表头部输出对应元素，然后更新头链表指针。为实现以上操作需要定义两个指针变量，ListNode* head指向链表头，ListNode* tail指向链表尾。 在出队列过程中，一边出队列，一边回收开辟的内存。 ListNode 数据结构 class ListNode { public: // 链表 Li
17.队列：使用链表实现队列
最新发布
weixin_51437378的博客
09-11 494
不是已经有数组实现队列了么？为什么还要用链表实现呢？没事找事？傻b！大家不妨思考一个问题：数组队列只能存这会导致：多的队列的存不下队列用不完浪费内存空间。要队列，那就换个扩充数组容量，也就是换个更大的数组，这时候又要把数组中所有内容全部拷贝到新数组，复杂度为取决于数组内队列元素N的个数，太麻烦了!那么能不能有线性的队列呢？队列多的情况能容纳，少的情况又可以不浪费内存空间。
C++队列实现（链表）
jerryhao0216的博客
03-19 687
通俗的说，队列类似于我们日常生活中的排队，这个数据结构与栈不同，栈是先进后出（类似于弹匣），而队列是先进先出。此处引用百度百科对于队列的定义：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
队列的链表实现方式（C++版）
weixin_42295110的博客
07-06 1441
队列基于链表有两种实现方式:一种是带头结点的实现方式，一种是不带头结点的实现方式。 带头结点的实现方式： 基础代码: #include<stdio.h> #include<stdlib.h> #define ElemType int #define null NULL typedef struct LNode{ //链表结点 ElemType data; struct LNode *next; }LNode; typedef struct QNod
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
总的来说，这个C++数据结构算法集提供了对基本数据结构和算法的实现，包括堆栈、队列和链表，这对于学习和理解数据结构及其在实际编程中的应用非常有帮助。掌握这些基础知识将有助于提升编程能力，解决更复杂的问题...
C++利用链表模板类实现简易队列
08-26
在C++中，链表是一种常用的数据结构，链表模板类是指使用模板类来实现链表的结构体。链表模板类的优点是可以根据需要自定义数据类型，并且可以轻松地实现链表的操作。 知识点二：队列的实现 队列是一种先进先出的...
C++ 循环队列和链式队列的实现 数据结构 类模板
02-04
1. Queue.hpp是队列的基类，只定义基本操作，具体实现在另外两个hpp文件中 2. seqQueue.hpp是循环队列的实现 3. linkQueue.hpp是链式队列的实现 4. test.cpp是简单的测试文件，main函数在这里面
C++ 数据结构链表的实现代码
08-31
链表是一种重要的数据结构，它在计算机科学中广泛用于存储和操作动态集合。与数组不同，链表的元素不是在连续的内存位置上，而是通过...在实际编程中，链表常用于动态存储，例如队列、栈、哈希表等复杂数据结构的实现。
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
c++队列链表实现
狗蛋的博客
10-18 482
#include <iostream> #include <stdlib.h> using namespace std; //定义节点 typedef struct node{ char data; struct node * next; }node; //定义队列（保存队首和队尾指针） typedef struct queue_link{ node * front; node * rear; }que; //初始化队列 que * InitQ
c++链表实现队列
fuli1215的专栏
04-13 670
<br />template<class T><br />class LinkedQueue;<br />template<class T><br />class Node<br />{<br /> friend LinkedQueue<T>;<br />private:<br /> T data;<br /> Node<T>* link;<br />};<br />template<class T><br />class LinkedQueue<br />{<br />public:<br /> Link
用链表实现队列
yuhai8702的专栏
09-09 1061
<br />/*2010-09-09*/<br />/*用链表实现队列*/<br />#include <stdio.h><br />#include <stdlib.h><br />#include <string.h><br />#ifdef D<br />    #define DEBUG(format, ...) printf(format,##__VA_ARGS__)<br />#else<br />    #define DEBUG(format, ...) do{}while(0)<br />
使用链表实现队列
xupeng1644的博客
09-28 1391
使用链表实现队列和堆栈不一样的地方在于： 需要另外的一个指针指向队列尾部。 每次Push()在链表尾部进行。 每次Pop()则在链表头部进行。 同样，在查看队列头尾元素时（Front()、Back()），对队列进行判空操作 由调用者进行。 源代码 MyQueue.h #include struct ListNode { int nData; ListNode* pN
C++数据结构--队列（链表实现）
海到无边天作岸 山登绝顶我为峰
04-07 1571
测试代码 #include<iostream> using namespace std; template<class datatype> struct node{ datatype data; node<datatype> *next; }; template<class datatype> class queue{ public: que...
C++链式队列实现
Alexon Xu的博客
01-17 829
链式队列具有内存动态分配，内存利用率高的特点，在一些无法预先估计所需队列大小的场合使用链式队列是一个十分好的选择。下面是我最近学习链式队列的代码。注意这里的头结点不存储数据。 首先，要实现链式队列，首先要构造相应的数据结构，这里考虑使用两个指针分别指向队列的队头和队尾，队列使用单链表实现。代码如下：#include #include #include
利用链表实现队列
weixin_43824601的博客
11-14 703
队列是一种只允许在表的前端进行删除操作，而在表的后端进行插入操作的线性数据结构 我们可以利用链表来实现队列，具体实现代码如下： import java.util.NoSuchElementException; /** * 用链表实现队列 * @author Victor Gong * * @param <Item> 队列中元素类型 */ public class LinkedQueue<Item> { private Node first; //头结点 priva
C++数据结构：链表与队列实现
"本资源是一份关于C++数据结构的课后作业，涵盖了链表和队列的概念与实现。在作业中，需要建立一个链表类来存储登录信息，并编写一个队列类来模拟排队过程。课程内容包括链表、栈和队列的基础知识，特别是链表的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值