数据结构c++实现——线性表的链式结构

最新推荐文章于 2024-07-07 15:50:59 发布
最新推荐文章于 2024-07-07 15:50:59 发布
阅读量524 收藏 3
点赞数 1
分类专栏： 数据结构 数据结构c++实现 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40117099/article/details/89077332
版权

1.全部基于c++模板实现。

2.实现了

  • 单向链表（link_list.h）
  • 循环链表（c_link_list.h）
  • 双向链表（d_link_list.h）

//-----------------------------------------------------------------------------------------

  • link_list.h
#ifndef LINK_LIST_H
#define LINK_LIST_H

#include <string>

template<typename T>
class Link_list;

template<typename T>
class Node
{
    friend class Link_list<T>;
public:
    Node(){}
    Node(T d, Node* ptr):
        data(d), next(ptr){}
    ~Node(){}

private:
    T data;
    Node* next;
};

template<typename T>
class Link_list
{
public:
    Link_list():count(0) {
        head = new Node<T>();
        head->next = nullptr;
    }
    Link_list(size_t cnt, Node<T>* _head):
        count(cnt), head(_head){}
    ~Link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, Node<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);

private:
    size_t count;
    Node<T>* head;
    //找到当前节点
    Node<T>* find_curr(size_t);
};

#endif // LINK_LIST_H


template<typename T>
size_t Link_list<T>::size()
{
    return count;
}

template<typename T>
bool Link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T Link_list<T>::get(size_t sz)
{
    Node<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void Link_list<T>::insert(size_t sz, Node<T>* node)
{
    Node<T>* curr_node_ptr = find_curr(sz);
    if(curr_node_ptr)
    {
        node->next = curr_node_ptr->next;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void Link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    Node<T>* pre_node_ptr = find_curr(sz-1);

    pre_node_ptr->next = pre_node_ptr->next->next;
    --count;
}

template<typename T>
void Link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t Link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
Node<T>* Link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    Node<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}
  • c_link_list.h
#ifndef C_LINK_LIST_H
#define C_LINK_LIST_H

#include <string>

template<typename T>
class C_link_list;

template<typename T>
class CNode
{
    friend class C_link_list<T>;
public:
    CNode(){}
    CNode(T d, CNode* ptr):
        data(d), next(ptr){}
    ~CNode(){}

private:
    T data;
    CNode* next;
};

template<typename T>
class C_link_list
{
public:
    C_link_list():count(0) {
        head = new CNode<T>();
        //改动此处即可,让链表构成循环
        head->next = head;
    }
    C_link_list(size_t cnt, CNode<T>* _head):
        count(cnt), head(_head){}
    ~C_link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, CNode<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);

private:
    size_t count;
    CNode<T>* head;
    //找到当前节点
    CNode<T>* find_curr(size_t);
};

#endif // C_LINK_LIST_H

template<typename T>
size_t C_link_list<T>::size()
{
    return count;
}

template<typename T>
bool C_link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T C_link_list<T>::get(size_t sz)
{
    CNode<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void C_link_list<T>::insert(size_t sz, CNode<T>* node)
{
    CNode<T>* curr_node_ptr = find_curr(sz);
    if(curr_node_ptr)
    {
        node->next = curr_node_ptr->next;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void C_link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    CNode<T>* pre_node_ptr = find_curr(sz-1);

    pre_node_ptr->next = pre_node_ptr->next->next;
    --count;
}

template<typename T>
void C_link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t C_link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
CNode<T>* C_link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    CNode<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}
  • d_link_list.h
#ifndef D_LINK_LIST_H
#define D_LINK_LIST_H

#include <string>

template<typename T>
class D_link_list;

template<typename T>
class DNode
{
    friend class D_link_list<T>;
public:
    DNode(){}
    DNode(T d, DNode* n_ptr = nullptr, DNode* p_ptr = nullptr):
        data(d), next(n_ptr), prior(p_ptr){}
    ~DNode(){}
    //延迟初始化
    void init(DNode &n1, DNode &n2, DNode &n3){
        n1.next = &n2;
        n1.prior = nullptr;
        n1.data = "i";

        n2.next = &n3;
        n2.prior = &n1;
        n2.data = "like";

        n3.next = nullptr;
        n3.prior = &n2;
        n3.data = "this";
    }

private:
    T data;
    DNode* next;
    DNode* prior;
};


template<typename T>
class D_link_list
{
public:
    D_link_list():count(0) {
        head = new DNode<T>();
        head->next = nullptr;
        head->prior = nullptr;
    }
    D_link_list(size_t cnt, DNode<T>* _head):
        count(cnt), head(_head){}
    ~D_link_list(){}

    //链表长度
    size_t size();
    //是否为空
    bool empty();

    //获取元素
    T get(size_t);
    //插入元素
    void insert(size_t, DNode<T>*);
    //删除元素
    void remove(size_t);

    //遍历
    void print();

    //查找节点数据位置
    size_t find(T);
private:
    size_t count;
    DNode<T>* head;
    DNode<T>* find_curr(size_t);
};

#endif // D_LINK_LIST_H


template<typename T>
size_t D_link_list<T>::size()
{
    return count;
}

template<typename T>
bool D_link_list<T>::empty()
{
    return count == 0;
}

template<typename T>
T D_link_list<T>::get(size_t sz)
{
    DNode<T>* result_node_ptr = find_curr(sz);
    return result_node_ptr->data;
}

template<typename T>
void D_link_list<T>::insert(size_t sz, DNode<T>* node)
{
    DNode<T>* curr_node_ptr = find_curr(sz);
    //在末尾插入
    if(curr_node_ptr->next == 0)
    {
        curr_node_ptr->next = node;
        node->prior = curr_node_ptr;
        node->next = nullptr;
        ++count;
    }
    //在中间插入
    else
    {
        node->prior = curr_node_ptr;
        node->next = curr_node_ptr->next;
        curr_node_ptr->next->prior = node;
        curr_node_ptr->next = node;
        ++count;
    }
}

template<typename T>
void D_link_list<T>::remove(size_t sz)
{
    //找到插入处的前驱节点
    DNode<T>* pre_node_ptr = find_curr(sz-1);
    //在末尾删除
    if(pre_node_ptr->next->next == 0)
    {
        pre_node_ptr->next = nullptr;
        --count;
    }
    //在中间删除
    else
    {
        pre_node_ptr->next->next->prior = pre_node_ptr;
        pre_node_ptr->next = pre_node_ptr->next->next;
        --count;
    }
}

template<typename T>
void D_link_list<T>::print()
{
    for(size_t i = 1; i <= count; ++i)
    {
        auto curr_node = find_curr(i);
        std::cout<<i<<" :"
                 <<curr_node<<" "
                 <<curr_node->data<<std::endl;
    }
}

template<typename T>
size_t D_link_list<T>::find(T t)
{
    for(size_t i = 1; i <= count; ++i)
    {
        if(find_curr(i)->data == t)
            return i;
    }
    std::cout<<"no found."<<std::endl;
    return -1;
}

template<typename T>
DNode<T>* D_link_list<T>::find_curr(size_t sz)
{
    size_t temp = 0;
    DNode<T>* curr_node_ptr = head;
    while(temp != sz)
    {
        ++temp;
        curr_node_ptr = curr_node_ptr->next;
    }
    return curr_node_ptr;
}
  • main.cpp
#include <iostream>
#include "link_list.h"
#include "c_link_list.h"
#include "d_link_list.h"
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
//------------------------------------------------------------------------------------------------
//link_list.h
//    Node<string> n3("this", NULL), n2("like", &n3), n1("i", &n2);
//    Link_list<string> l1;

//    l1.insert(0, &n1);
//    l1.insert(1, &n2);
//    l1.insert(2, &n3);

//    l1.print();
//    cout<<"---------------------"<<endl;
//    cout<<l1.empty()<<endl;
//    cout<<l1.get(2)<<endl;
//    cout<<l1.find("like")<<endl;
//    cout<<l1.size()<<endl;
//    cout<<"---------------------"<<endl;
//    l1.remove(3);
//    l1.print();

//------------------------------------------------------------------------------------------------
//c_link_list.h
//    CNode<string> n3("this", NULL), n2("like", &n3), n1("i", &n2);
//    C_link_list<string> l1;

//    l1.insert(0, &n1);
//    l1.insert(1, &n2);
//    l1.insert(2, &n3);

//    l1.print();
//    cout<<"---------------------"<<endl;
//    cout<<l1.empty()<<endl;
//    cout<<l1.get(2)<<endl;
//    cout<<l1.find("like")<<endl;
//    cout<<l1.size()<<endl;
//    cout<<"---------------------"<<endl;
//    l1.remove(3);
//    l1.print();

//------------------------------------------------------------------------------------------------
//d_link_list.h
    DNode<string> n3, n2, n1;
    n1.init(n1, n2, n3);
    D_link_list<string> l1;

    l1.insert(0, &n1);
    l1.insert(1, &n2);
    l1.insert(2, &n3);

    l1.print();
    cout<<"---------------------"<<endl;
    cout<<l1.empty()<<endl;
    cout<<l1.get(2)<<endl;
    cout<<l1.find("like")<<endl;
    cout<<l1.size()<<endl;
    cout<<"---------------------"<<endl;
    l1.remove(3);
    l1.print();

    return 0;
}
光羽隹
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++线性表链式存储结构
LLLCSDN的博客
12-11 2190
本来想要在头结点的数据域存放链表长度，结果后来这样反而出了一些麻烦#include using namespace std; #define MAXSIZE 123 typedef int ElemType;//为复杂的声明定义简单的别名 struct Node { ElemType date; Node *next; Node(ElemType elem); }; Node::N
C++版数据结构-----线性表
Johnor的博客
01-05 984
数据结构线性表，析构函数未实现
数据结构——线性表(C++)
dahulihuli的博客
03-04 1140
数据结构在逻辑结构上分为线性和非线性，例如链表、顺序表、串、数组都是线性的，他们的特点就是一对一，而非线性结构比如图和二叉树，他们的对应关系是一对多、多对多，这里介绍线性表的顺序表和链表、循环链表和双向链表，还有双向循环链表。链表尤其重要，很多结构都是以链表作为基础的，比如栈和队列。先写头文件，然后是功能实现的cppprivate:int length;return;i < n;
数据结构——线性表（C++）
DaMercy的博客
11-10 967
线性表一、线性表的定义二、线性表的抽象数据类型三、线性表的顺序存储1. 顺序存储定义2.顺序存储的实现方式四、线性表的链式存储五、其他线性表参考 一、线性表的定义 线性表：零个或多个数据元素的有限序列。 线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。 线性表包括顺序表和链表。 顺序表（其实就是数组）里面元素的地址是连续的， 链表里面节点的地址不是连续的，是通过指针连起来的。 二、线性表的抽象数据类型 线性表的抽象数据类型定义如下： ADT
C++实现的一个简单链表
05-20
单链表的实现。以前都是用C语言实现的，今天用C++练一练手，做出来了。
数据结构实验一线性表的基本操作.docx
03-28
数据结构实验一线性表的基本操作 一、线性表的概念和类型 ...数据结构实验一线性表的基本操作的实验结果证明了线性表的基本操作的实现，并且实现了多项式相加的功能。实验结果表明了线性表的重要性和实用性。
数据结构——线性表类模板
12-19
在`Chapter3`文件中，可能会进一步探讨线性表的其他高级特性，如链式存储、排序操作、合并与分割等，这些都是数据结构和算法课程中的重要内容。学习这些知识有助于提升解决实际问题的能力，特别是在设计和优化算法时...
C++与数据结构 第一次上机实验——线性表.pdf
11-07
本文主要讨论了C++编程中关于数据结构中的线性表，包括线性表的定义、顺序存储结构和链式存储结构的特点，以及如何通过C++实现线性表的相关操作，如插入、删除和查找等。 线性表是一种数据结构，其中的元素之间存在...
C++与数据结构 第一次上机实验——线性表.docx
11-07
【线性表】是计算机科学中一种基本的数据结构，它由有限个相同类型元素构成的序列，元素之间存在一对一的线性关系。线性表可以采用两种主要的存储方式：顺序存储结构和链式存储结构。 **顺序存储结构**是指用一组...
《数据结构》——线性表的操作
11-20
用C++语言实现了对线性表的操作，有对线性表的顺序存储和链式存储，可根据需要适当扩充。本程序有三个类：SeqList、LinkList、Function。前面两个类实现了相同的功能（线性表中的常用功能），一个是顺序存储，一个是...
数据结构-线性表代码实现
03-20
线性表顺序存储代码实现
C++ 链式线性表 类方式实现
07-29
C++ 链式线性表，以类的方式实现
c++实现链式结构的栈
lalala
04-16 1080
链式结构的栈的主题是一个单向链表，因为只有一个可访问的头并且可以轻松在头部进行插入和删除，因为栈的操作也都是在顶部，所以可以根据这一特性用链表的头部表示栈的顶部实现一个链式结构的栈，并且不存在大小的限制。更多栈的特性不做过多描述。         我们使用带头结点的链表，头结点的数据区就储存栈的元素个数，然后实现链表的头部插入函数模拟栈的push，实现链表的删除头部元素模拟栈的pop。
数据结构学习：c++实现队列的链式存储结构（链队列）
每天进步一点点
10-18 1833
前面一篇博客实现了如何使用c++实现队列的链式存储结构，参见链接：c++ 实现队列的顺序存储结构 我自己认为无论是线性表、栈还是队列等等结构，链式结构总是要比顺序结构难一点，因为顺序存储结构就是玩数组嘛，数组大家都能玩的转; 但链式结构肯定就有指针，而有了指针，程序必将变得复杂，所以实现起来可能稍微有点困难，但是换句话说，链式不就是玩指针嘛，相信大家指针也一定都一定能玩的转. 话不多说，进入正题：...
数据结构：链式表ADT的实现
Viadimir的博客
09-23 1427
链表适用于插入或删除操作频繁，存储空间需求不定的情形。链表分很多种，有单链表、双链表、循环链表等，这里我以单链表为例，实现单链表的ADT。 单链表是一种最简单的链表表示，也叫作线性链表。用它来表示线性表时，用指针表示节点间的逻辑关系。因此单链表的一个存储节点包含两部分： ...
c++实验3 链式存储线性表
weixin_30371875的博客
03-26 408
1、线性表链式存储结构及基本操作算法实现 (1)单链表存储结构类的定义： #include <iostream> using namespace std; template <class T> class LinList { private: ListNode <T> *head; //...
链式表的实现（C++）
ThetaQing的博客
09-06 1165
linklist.cpp文件 主要包括基本操作，初始化、销毁链表等。 #include <iostream> # include"linklist.h" using namespace std; /****************************** * 链式表 * * */ /* *初始化链式表 */ void InitLinkList(LinkLi...
6、Redis系统-数据结构-06-跳表
最新发布
qq_29434541的博客
07-07 421
在 Redis 中，跳表通过高效的多级链表结构，实现了有序集合的快速插入、删除和查询操作，适用于需要有序数据存储的场景。跳表通过多级链表的形式实现，每一级链表都跳过一些元素，从而在查询时能够快速跳过不必要的元素。跳表的每个节点包含一个或多个前进指针，这些前进指针指向不同级别的节点，使得跳表具有高效的查询性能。删除节点时，通过查找操作确定节点位置，然后在每一级链表中移除该节点，并调整相关节点的前进指针和跨度。插入新节点时，首先确定新节点的级别，然后在每一级链表中找到插入位置，将新节点插入到相应的位置。
U201614532 吕鹏泽2
08-08
这篇文档是吕鹏泽同学的一份数据结构实验报告，主要探讨了基于不同存储结构的线性表、二叉树以及图的实现。以下是各部分的详细知识点： 1. 基于顺序存储结构的线性表实现 - 问题描述：使用动态分配的顺序表来实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值