C++ 封装链表类、模板封装链栈、链式队列

已于 2022-11-25 18:54:19 修改
阅读量464 收藏 2
点赞数 1
分类专栏： C语言 文章标签： 链表 c++ 数据结构
于 2022-11-22 20:23:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43030270/article/details/127989387
版权

1、链表类

#include <iostream>
using namespace std;

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


class linklist
{
private:
    
    node* head;
public:
    linklist();
    linklist(const linklist &obj);
    ~linklist();
    //判空，求长，增删改查排，倒置，打印
    int linklist_is_empty();
    int get_length_linklist();
    void insert_by_pos_linklist(int pos,int data);
    int delete_by_pos_linklist(int pos);
    int delete_by_data_linklist(int data);
    node* search_by_pos_linklist(int pos);
    node* search_by_data_linklist(int data);
    node* sort_linklist();
    node* reverse_linklist(); 
    void print_linklist();

};

int main()
{
    linklist list;
    // linklist list1(list);
    linklist list1 = list;
    cout<<list1.linklist_is_empty()<<endl;
    cout<<list.linklist_is_empty()<<endl;
    cout<<list.get_length_linklist()<<endl;
    for (int i = 1; i <= 10; i++)
    {
        list.insert_by_pos_linklist(i,i);
    }
    cout<<list.get_length_linklist()<<endl;
    list.print_linklist();
    
    list.insert_by_pos_linklist(5,99);
    list.print_linklist();
    
    list.delete_by_pos_linklist(5);
    list.print_linklist();
    
    list.delete_by_data_linklist(10);
    list.print_linklist();
    
    list.reverse_linklist();
    list.print_linklist();

    cout<<list.search_by_pos_linklist(3)->next->data<<endl;
    cout<<list.search_by_data_linklist(7)->next->data<<endl;
    
    
    return 0;
}

linklist::linklist()//构造函数，在堆区申请空间，初始化头节点
{   
    head = new (nothrow) node;
    head->next = nullptr;
}

linklist::linklist(const linklist &obj)
{
    this->head = new node;
}

linklist::~linklist()//析构函数，清理堆区空间,需要逐个清除
{
    node* p = nullptr;
    while (head != nullptr)
    {
        p = head;
        head = head->next;
        delete p;       
    }
}

int linklist::linklist_is_empty()
{
    return (head->next == nullptr)?1:0;
}

int linklist::get_length_linklist()
{
    node* p = head;
    int count = 0;
    while(p->next != nullptr)
    {
        count++;
        p = p->next;
    }
    return count;
}

void linklist::insert_by_pos_linklist(int pos,int data)
{
    // if(pos < 0 || pos >= get_length_linklist())
    // {
    //     cout<<"pos error"<<endl;
    //     return ;
    // }
    node* p = head;
    while(--pos)
    {
        p = p->next;
    }
    node* new_node = new (nothrow) node;
    if(new_node == nullptr)
    {
        return ;
    }
    new_node->next = p->next;
    new_node->data = data;
    p->next = new_node;
}

int linklist::delete_by_pos_linklist(int pos)
{
    if(linklist_is_empty() == 1)
    {
        return -1;
    }
    if(pos < 0 || pos > get_length_linklist())
    {
        cout<<"pos error"<<endl;
        return -1;
    }
    node* p = head;
    while(--pos)
    {
        p = p->next;
    }
    node* q = p->next;
    p->next = q->next;
    delete q;
    return 0;
}

int linklist::delete_by_data_linklist(int data)
{
    node* p = head;
    while (p->next->data != data)
    {
        p = p->next;
    }
    node* q = p->next;
    p->next = q->next;
    delete q;
    return 0;
}

node* linklist::search_by_pos_linklist(int pos)
{
    if(linklist_is_empty() == 1)
    {
        return nullptr;
    }
    if(pos < 0 || pos > get_length_linklist())
    {
        cout<<"pos error"<<endl;
        return nullptr;
    }
    node* p = head;
    while(pos--)
    {
        p = p->next;
    }
    return p;
}

node* linklist::search_by_data_linklist(int data)
{
    node* p = head->next;
    while(p != nullptr && p->data != data)
    {
        p = p->next;
    }
    return p;
}
node* linklist::sort_linklist()
{
    node* p = head->next;
    head->next = nullptr;
    node *q,*r;
    while (p != nullptr)
    {
        q = p->next;
        r = head;
        while (r != nullptr && r->next->data < p->data)
        {
            r = r->next;
        }     
        p->next = r->next;
        r->next = p->next;
        p = q;    
    }
    return head;
}

node* linklist::reverse_linklist()
{
    node* p = head->next;
    node* q = nullptr;
    head->next = nullptr;
    while(p != nullptr)
    {
        q = p->next;
        p->next = head->next;
        head->next = p;
        p = q;
    }
    return head;
}


void linklist::print_linklist()
{
    node* p = head->next;
    while (p != nullptr)    
    {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;  
}

 2、模板链式栈

#include <iostream>
using namespace std;

template<typename T>
struct  Node
{   
    T data;
    struct Node* next;
};


template<typename T>
class Linkstack{
    private:
        Node<T>* top;

    public:
        Linkstack();
        ~Linkstack();

    public:
    bool linkstack_is_empty();
    int get_length_linkstack();
    void linkstack_push(T data);
    T linkstack_pop();
};

int main()
{
    Linkstack<char> stack;
    cout << stack.linkstack_is_empty() << endl;
    for (int i = 0; i < 10; i++)
    {
        stack.linkstack_push('A' + i);
    }
    cout << stack.get_length_linkstack() << endl;

    for (int  i = 0; i < 10; i++)
    {
        cout << stack.linkstack_pop() << " ";
    }
    cout << endl;
    cout << stack.linkstack_is_empty() << endl;
    return 0;
}


template<typename T>
bool Linkstack<T>::linkstack_is_empty()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    return ((top->next == nullptr)?true:false);
}

template<typename T>
int Linkstack<T>::get_length_linkstack()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    int count = 0;
    Node<T>* p = top->next;
    while(p != nullptr)
    {
        count++;
        p = p->next;
    }
    return count;
}


template<typename T>
void Linkstack<T>::linkstack_push(T data)
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    Node<T>* newptr = new Node<T>;
    newptr->data = data;
    newptr->next = top->next;
    top->next = newptr;
}

template<typename T>
T Linkstack<T>::linkstack_pop()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    T temp;
    Node<T>* p = top->next;
    // if(p == nullptr)
    // {
    //     return 0;
    // }
    top->next = p->next;
    temp = p->data;
    delete p;
    return temp;
}

template<typename T>
Linkstack<T>::Linkstack()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    top = new Node<T>;
    top->next = nullptr;
}

template<typename T>
Linkstack<T>::~Linkstack()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    while (this->linkstack_is_empty() != 1)
    {
        this->linkstack_pop();
    }  
    delete top;
}

 3、模板链式队列

#include <iostream>
using namespace std;


template<typename T>
struct  Node
{   
    T data;
    struct Node* next;
};

// template<typename T>
// struct Queue
// {
//     Node<T>* front;
//     Node<T>* rear;
// };


template<typename T>
class Linkqueue{
    private:
        Node<T>* head;
        Node<T>* front;
        Node<T>* rear;
    public:
        Linkqueue();
        ~Linkqueue();

    public:
        int linkqueue_is_empty();
        int get_length_linkqueue();
        void print_linkqueue();
        void linkqueue_en(T data);
        T linkqueue_de();
};


int main()
{
    Linkqueue<char> lqueue;

    cout << lqueue.linkqueue_is_empty() << endl;
    lqueue.get_length_linkqueue();
    for (int i = 0; i < 10; i++)
    {
        lqueue.linkqueue_en('A'+i);
    }
    // lqueue.print_linkqueue();
    cout << lqueue.get_length_linkqueue() << endl;
    for (int i = 0; i < 10; i++)
    {
        cout << lqueue.linkqueue_de() <<" ";
    }
    cout << endl;
    cout << lqueue.get_length_linkqueue() << endl;

    return 0;
}


template<typename T>
int Linkqueue<T>::linkqueue_is_empty()
{
    // cout << __func__ <<":"<< __LINE__ << endl; 
    return front == rear;
}

template<typename T>
int Linkqueue<T>::get_length_linkqueue()
{
    cout << __func__ <<":"<< __LINE__ << endl;
    Node<T>* p = front;
    int count = 0;
    while(p->next != nullptr)
    {
        count++;
        p = p->next;
    }
    return count;
}


template<typename T>
void Linkqueue<T>::print_linkqueue()
{
    cout << __func__ <<":"<< __LINE__ << endl;
    Node<T>* p = front;
    while (p->next != nullptr)
    {
        cout << p->next->data <<" ";
    }
    cout << endl;
    
}


template<typename T>
void Linkqueue<T>::linkqueue_en(T data)
{
    cout << __func__ <<":"<< __LINE__ << endl;
    Node<T>* newnode = new Node<T>;
    newnode->data = data;
    newnode->next = NULL;
    rear->next = newnode;
    rear = newnode;
    return;
}

template<typename T>
T Linkqueue<T>::linkqueue_de()
{
    // cout << __func__ <<":"<< __LINE__ << endl;
    if(this->linkqueue_is_empty() == 1)
    {
        return 0;
    }
    T temp = front->next->data;
    Node<T>* p = front;
    front = p->next;
    delete p;
    return temp;
}


template<typename T>
Linkqueue<T>::Linkqueue()
{
    cout << __func__ <<":"<< __LINE__ << endl;
    Node<T>* head = new Node<T>;
    head->next = nullptr;
    front = head;
    rear = head;
}

template<typename T>
Linkqueue<T>::~Linkqueue()
{
    cout << __func__ <<":"<< __LINE__ << endl;
    // while(this->linkqueue_is_empty() != 1)
    // {
    //     this->linkqueue_de();
    // }
    // delete head;
    // delete front;
    // delete rear;
}

 

阿巴阿巴z
关注
专栏目录
C++封装栈（模板）
m0_63093015的博客
11-24 1750
c++，数据结构，栈
链表类模板封装链表操作
10-25
用模板实现链表的建立删除等操作，可以根据具体情况稍作修改即可实现链表操作，或直接使用，我在链表的学习和类模板的学习和以后的编程时这种链表构造思想觉得挺好的，有点面向对象的意思……粗浅的理解呵呵！
用类模板封装链表
蜗牛也是牛
06-05 581
闲来无聊，用类的模板封装的链表，记录下来，说不定哪天用得上那。 template class List { public: //定义节点类型 typedef struct Node { VALUE_TYPE data;    //数据域 struct Node *next;  //指针域：直接后继的指针 // struct Node *prior; //指针域：直接前驱的指针
封装链表类
xal87v5的博客
11-22 307
Demo(int val=0,int val1=0) : val1(val1) //使用初始化列表对成员变量val val1初始化。//right getmyval()是static方法，是类的成员。//right const对象可以调用const方法。//const成员是只读的，只能初始化，不能修改。int getval() const //const成员方法:不能修改类对象。//error obj是const对象，只能调用const方法。//static成员。
封装链表
qq_44442895的博客
02-01 590
封装链表 尾添加的效率低，非法下标的判断效率也很低 1、单链表 节点： ​ 数据域 ​ 指针域 数据项： ​ 头指针 ​ 尾指针 ​ 节点数量 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define TYPE int // 单链表的实现 // 设计节点 typedef struct Node { TYPE data; struct Node* next; }Node; Node* cr
单链表——封装了一个类(1)
u011836061的专栏
08-13 816
对单链表的相关介绍在这里。之前因为思维不太清晰，想尝试封装一个类来实现单链表的相关操作，但是失败了。现在补上，也算是练练笔吧。   类ListClass的成员函数与之前的各功能函数实现方法基本一致，链表头head则作为数据成员出现在了类中。此外还维护了尾结点指针tail，但是结点的插入仍然是在链表头部进行的，所以tail几乎没有用到。初始时刻，创建的空链表中，head与tail都指向头结点。List
C++利用链表模板类实现简易队列
08-26
C++利用链表模板类实现简易队列 本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，...
封装链表模板类的源代码
08-26
利用标准C++的语言，实现封装链表模板类，即List模板类
C++编程实例(c++封装链表、栈、队列).pdf
02-13
封装链表、栈和队列是C++编程中的基础数据结构，它们提供了对数据的高效管理。链表是一种动态数据结构，允许在任意位置插入和删除元素。栈是一种后进先出（LIFO）的数据结构，通常用于递归和表达式求值等场景。队列...
C++语言封装链表类
09-11
仅供大一参考联系， 利用C++中的类实现线性链表的常见操作
C++ 封装链表类
qq_57990061的博客
11-21 552
面向对象封装链表类
【链式栈】链式栈的封装<源代码>
春秋繁露
05-01 663
这里的代码 主要实现了链式栈的基本操作，包含初始化，入栈，出栈，释放。
数据结构-链式队列(用链表实现队列) 学习笔记
stre_2632的博客
06-04 408
文章目录前言1.链式队列函数模板源码分享二、测试主函数 和 效果1.主函数2.效果总结 前言 视频连接： 懒猫老师-数据结构-(11)链式队列(用链表实现队列) https://www.bilibili.com/video/av94576761 本人 看完懒猫老师教学视频后，写出来的代码，均实现相关功能 （自己测试是这样的 doge，如果有问题的话 记得B站@我 原罪Suntre CSDN可能不常在） 提示：以下是本篇文章正文内容，下面案例可供参考 1.链式队列函数模板源码分享 代码如下（示例）
数据结构----链式栈（结构体封装与二级指针封装）
qq_29941503的博客
09-21 453
栈代表一种先进后出的存储方式，在实际应用中，基本上有回退操作的都需要运用到栈。 一个栈需要实现的基本操作有：入栈 出栈和标记栈顶元素。 由于这种先进后出的存储结构和链表的头插法非常的相似，所以我们可以借鉴头插法写出一个链式栈。 以下是链式栈的具体代码（通过结构体再封装实现） #include<stdio.h> #include <stdlib.h> //栈：先进后出。 所有关于回退问题的都需要用到栈。 /*栈的基本操作：入栈 出栈 标记栈顶元素 由于栈是先...
c++封装模板单链表
ylh的博客
07-31 379
C++模板单链表的封装，适用于任意数据类型
数据结构复习（五）模板类封装带头结点的双向循环链表
曾几何时的博客
02-13 114
带头结点的双向循环链表实现构造、销毁、头删头插、尾删尾插、任意位置插入删除。
模板类封装(2)——顺序栈和链式栈
cos的博客
11-02 642
自封装模板类，包括各数据结构
双向循环链表的模板封装
最新发布
freex64的专栏
03-09 197
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
数据结构-链式队列及基本操作
有朋自远方来，不亦乐乎。
08-08 1073
链式队列的实现思想同顺序队列类似，只需创建两个指针（命名为 top 和 rear）分别指向链表中队列的队头元素和队尾元素。此时队列中没有存储任何数据元素，因此 top 和 rear 指针都同时指向头节点。...
C++实现链表、链栈、链队列类详解
"这篇文稿讨论了如何实现链表、链栈和链队列的数据结构，作者基于《数据结构（用面向对象方法与C++描述）》一书，但对原书的组织结构和实用性提出了批评。作者重新设计并提供了相关的类定义，以帮助读者更好地理解和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值