数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现

最新推荐文章于 2023-12-20 13:35:53 发布
最新推荐文章于 2023-12-20 13:35:53 发布
阅读量416 收藏 13
点赞数 5
文章标签： 数据结构与算法 c/c++

0. 数据结构图文解析系列

数据结构系列文章
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
数据结构图文解析之：栈的简介及C++模板实现
数据结构图文解析之：队列详解与C++模板实现
数据结构图文解析之：树的简介及二叉排序树C++模板实现.
数据结构图文解析之：AVL树详解及C++模板实现
数据结构图文解析之：二叉堆详解及C++模板实现

1. 线性表简介

线性表是一种线性结构，它是由零个或多个数据元素构成的有限序列。线性表的特征是在一个序列中，除了头尾元素，每个元素都有且只有一个直接前驱，有且只有一个直接后继，而序列头元素没有直接前驱，序列尾元素没有直接后继。
数据结构中常见的线性结构有数组、单链表、双链表、循环链表等。线性表中的元素为某种相同的抽象数据类型。可以是C语言的内置类型或结构体，也可以是C++自定义类型。

2. 数组

数组在实际的物理内存上也是连续存储的，数组有上界和下界。C语言中定义一个数组：
610439-20160129211728583-2081927870.png

数组下标是从0开始的，a[0]对应第一个元素。其中，a[0]称为数组a的下界，a[6]称为数组a的上届。超过这个范围的下标使用数组，将造成数组越界错误。
数组的特点是：数据连续，支持快速随机访问。
数组分为固定数组与动态数组。其中固定数组的大小必须在编译时就能够确认，动态数组允许在运行时申请数组内存。复杂点的数组是多维数组，多维数组实际上也是通过一维数组来实现的。在C语言中，可以通过malloc来分配动态数组，C++使用new。另外，C++的标准模板库提供了动态数组类型vector以及内置有固定数组类型array。

3. 单向链表

单向链表是链表的一种。链表由节点所构成，节点内含一个指向下一个节点的指针，节点依次链接成为链表。因此，链表这种数据结构通常在物理内存上是不连续的。链表的通常含有一个头节点，头节点不存放实际的值，它含有一个指针，指向存放元素的第一个节点。

610439-20160129211741349-177122051.png

3.1 单向链表的节点结构

//节点结构
template <typename T>
class Node
{
public :
    T _value;
    Node* _next;
public:
    Node() = default;
    Node(T value, Node * next)
        : _value(value), _next(next){}
};
  1. _value: 节点的值
  2. _next： 指针，指向下一个节点

3.2 单向链表的抽象数据结构

//单链表
template <typename T>
class SingleLink
{
public:
    typedef Node<T>*  pointer;
    SingleLink();
    ~SingleLink();
 
    int size();                         //获取长度
    bool isEmpty();                     //判空
 
    Node<T>* insert(int index, T t); //在指定位置进行插入
    Node<T>* insert_head(T t);         //在链表头进行插入
    Node<T>* insert_last(T t);         //在链表尾进行插入
 
    Node<T>*  del(int index);         //在指定位置进行删除
    Node<T>*  delete_head();         //删除链表头
    Node<T>*  delete_last();         //删除链表尾
 
    T get(int index);                 //获取指定位置的元素
    T get_head();                     //获取链表头元素
    T get_last();                     //获取链表尾元素
 
    Node<T>* getHead();                 //获取链表头节点
 
private :
    int count;
    Node<T> * phead;                
 
private :
    Node<T> * getNode(int index);      //获取指定位置的节点
};
  1. phead: 链表的头节点。
  2. count: 链表元素个数。

3.3 单链表添加节点

链表的插入元素操作时间复杂度O（1），只需要进行指针的指向修改操作。
610439-20160129211802552-1568099093.png

在2之后添加7：

  1. 为元素7构建节点 。
  2. 将节点2 的next指针指向节点7。
  3. 将节点7的next指向节点3。（节点3 的位置要先保留起来）
/*
在指定位置插入新节点
*/
template <typename T>
Node<T>* SingleLink<T>::insert(int index, T t)
{
    Node<T> * preNode = getNode(index);
    if (preNode)
    {
        Node<T> *newNode = new Node<T>(t,preNode->_next);
        preNode->_next = newNode;
        count++;
        return newNode;
    }
    return nullptr;
};
/*
从头部插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_head(T t)
{
    return insert(0, t);
};
/*
从尾部进行插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_last(T t)
{
    return insert(count, t);
};

3.4 单链表删除节点

单链表的删除操作同样是一个时间复杂度O（1）的操作，它也只需要修改节点的指针指针后即可销毁被删除节点。
例如我们删除链表元素7：

610439-20160129211816786-1957915729.png

相应的代码：

/*
删除链表指定位置元素
*/
template <typename T>
Node<T>* SingleLink<T>::del(int index)
{
    if (isEmpty())
        return nullptr;
    Node<T>* ptrNode = getNode(index);
    Node<T>* delNode = ptrNode->_next;
    ptrNode->_next = delNode->_next;
    count--;
    delete delNode;
    return ptrNode->_next;
};
/*
删除头节点
*/
template<typename T>
Node<T>* SingleLink<T>::delete_head()
{
    return del(0);
};
/*
删除尾节点
*/
template<typename T>
Node<T>*SingleLink<T>::delete_last()
{
    return del(count);
};

3.5 单链表代码测试

int main()
{
    SingleLink<int> link;
    for (int i = 0; i < 10; i++)
    {
        link.insert(i, i);
    }
    cout << link.size() << endl;
 
    link.insert_head(1111);
    link.insert_last(2222);
 
    SingleLink<int>::pointer ptr = link.getHead();
    while (ptr != nullptr)
    {
        cout << ptr->_value << endl;
        ptr = ptr->_next;
    }
 
    getchar();
    return 0;
}

测试结果：

10
1111
0
1
2
3
4
5
6
7
8
9
2222

其他的操作较为简单，不在这里贴出代码，文章底部有完整链表类的代码链接。

4. 双向链表

单链表的节点链接是单方向的，要得到指定节点的前一个节点，必须从头遍历链表。
双向链表是链表的一种。与单链表一样，双向节点由节点链接而成，每个节点含有两个指针，分别指向直接前驱与直接后继。从双向链表的任何一个节点开始都能够遍历整个链表。
我们将双向链表实现为双向循环链表，也即是最后一个元素的后继将指向头节点，整个链表形成一个循环
例如，我们为元素1，2，3，4，5 构建一个双向循环链表
610439-20160129211829474-2026702975.png

在图中：
表头为空。
表头的前驱节点是节点5，表头的后继节点是节点1；
节点1的前驱节点是表头，节点1的后继节点是节点2；
节点2的前驱节点是节点1，节点2的后继节点是节点3；
...

4.1 双向链表节点结构

双向循环的节点中，比单向链表中多了一个指向直接前驱的指针

/*
双向链表的节点结构
*/
template <typename T>
struct Node
{
public:
    Node()= default;
    Node(T value, Node<T>* preptr, Node<T>* nextptr)
        :_value(value), pre_ptr(preptr), next_ptr(nextptr){}
 
public:
    T _value;
    Node<T>* pre_ptr;
    Node<T>* next_ptr;
};
  1. _value: 节点元素的值
  2. pre_ptr:指向直接前驱的指针
  3. next_ptr:指向直接后继的指针

4.2 双向链表的抽象数据结构

双向链表类的定义与单链表相似。

/*
* 双向链表类
*/
template<typename T>
class DoubleLink
{
public:
    typedef Node<T>* pointer;
public:
    DoubleLink();
    ~DoubleLink(){};
public:
    Node<T>* insert(int index, T value);
    Node<T>* insert_front(T value);
    Node<T>* insert_last(T value);
 
    Node<T>* del(int index);
    Node<T>* delete_front();
    Node<T>* delete_last();
 
    bool isEmpty();
    int size();
 
    T get(int index);
    T get_front();
    T get_last();
    Node<T>* getHead();
 
private:
    Node<T>* phead;
    int count;
private :
    Node<T>* getNode(int index);
};

4.3 双向链表添加节点

与单链表一样，双向链表添加节点的时间复杂度为O（1），它也只需要修改相关指针的指向。

610439-20160129211844927-167005435.png

/*
*将新节点插到第一个位置
*/
template <typename T>
Node<T>* DoubleLink<T>::insert_front(T value)
{
    Node<T>* newNode = new Node<int>(value, phead, phead->next_ptr);
    phead->next_ptr ->pre_ptr= newNode;
    phead->next_ptr = newNode;
    count++;
    return newNode;
};
/*
*将新节点插到链表尾部
*/
template <typename T>
Node<T>* DoubleLink<T>::insert_last(T value)
{
    Node<T> * newNode = new Node<int>(value, phead->pre_ptr, phead);
    phead->pre_ptr->next_ptr = newNode;
    phead->pre_ptr = newNode;
    count++;
    return newNode;
};
/*
*将节点位置插到index位置之前
*/
 
template <typename T>
Node<T>* DoubleLink<T>::insert(int index, T value)
{
    if (index == 0)
        return insert_front(value);
 
    Node<T>* pNode = getNode(index);
    if (pNode == nullptr)
        return nullptr;
    Node<T>* newNode = new Node<T>(value, pNode->pre_ptr, pNode);
    pNode->pre_ptr->next_ptr = newNode;
    pNode->pre_ptr = newNode;
    count++;
 
    return newNode;
};

4.4 双向链表删除节点

双向链表的删除操作时间复杂度为O（1）.我们删除节点7：
610439-20160129211855802-449700803.png

/*
*删除链表第一个节点
*返回删除后链表第一个节点
*/
template<typename T>
Node<T>* DoubleLink<T>::delete_front()
{
    if (count == 0)
    {
        return nullptr;
    }
    Node<T>* pnode = phead->next_ptr;
    phead->next_ptr = pnode->next_ptr;
    pnode->next_ptr->pre_ptr = phead;
    delete pnode;
    count--;
    return phead->next_ptr;
};
/*
*删除链表的末尾节点
*返回删除后链表尾部元素
*/
template<typename T>
Node<T>* DoubleLink<T>::delete_last()
{
    if (count == 0)
    {
        return nullptr;
    }
    Node<T>*pnode = phead->pre_ptr;
    pnode->pre_ptr->next_ptr = phead;
    phead->pre_ptr = pnode->pre_ptr;
    delete pnode;
    count--;
    return phead->pre_ptr;
}
/*
*删除指定位置的元素
*
*/
template <typename T>
Node<T>* DoubleLink<T>::del(int index)
{
    if (index == 0)
        return delete_front();
    if (index == count - 1)
        return delete_last();
    if (index >= count)
        return nullptr;
    Node<T>* pnode = getNode(index);
    pnode->pre_ptr->next_ptr = pnode->next_ptr;
    pnode->next_ptr->pre_ptr = pnode->pre_ptr;
 
    Node<T>* ptemp = pnode->pre_ptr;
    delete pnode;
    count--;
    return ptemp;
};

其他的接口实现都很简单，这里不再讲解。下面有提供完整的工程项目及源代码。

4.5 双向链表代码测试


int main()
{
    DoubleLink<int> dlink;
    //插入测试
    for (int i = 0; i < 10; i++)
    {
        dlink.insert(0, i+10);
    }
    dlink.insert(0,  100);
    dlink.insert_last(1000);
    cout <<"链表长度:"<< dlink.size() << endl;
 
    //删除测试
    dlink.delete_front();
    dlink.delete_last();
    dlink.del(3);
 
 
    DoubleLink<int>::pointer ptr = dlink.getHead();
    ptr = ptr->next_ptr;
    while (ptr != dlink.getHead())
    {
        cout << ptr->_value<<endl;
        ptr = ptr->next_ptr;
    }
 
    getchar();
    return 0;
}

测试结果：

链表长度:12
19
18
17
15
14
13
12
11
10

5. 单链表、双向链表源代码

单链表github源代码：https://github.com/huanzheWu/Data-Structure/blob/master/singleList/singleList/singleList.h
双链表github源代码：https://github.com/huanzheWu/Data-Structure/blob/master/DoubleLink/DoubleLink/DoubleLink.h

另外声明：

  1. C++模板不支持分离编译，因此类定义与成员函数的实现都在.h文件中完成；
  2. 可以看到代码中new一个新节点之后，并没有使用(prt!=nullptr)来检查内存分配是否成功，这是因为new失败时直接抛出异常，不同于C语言malloc内存分配失败返回NULL。

原创文章，转载请注明出处：http://www.cnblogs.com/QG-whz/p/5170147.html

weixin_33713707
关注
数据结构与算法之美 | 单链表、双链表的增删改查（C++）
迈微AI研习社 · 号主
05-02 907
本系列内容专为课程面向笔/面试的《数据结构与算法》总结性精讲开设，以图文并茂的方式讲解数据结构，让大家打牢基础，促进对课程内容的掌握，最后做到题解大神，大厂offer拿到手软！ 单链表、双链表的增删改查0. 数据结构图文解析系列1. 线性表简介2. 单链表2.1 单向链表的节点结构2.2 单向链表的抽象数据结构2.3 单链表添加节点2.4 单链表删除节点2.5 单链表代码测试3. 双向链表3.1 ......
数据结构之折半插入排序图文详解及代码（C++实现）
热门推荐
qq_40159978的博客
07-11 1万+
问题： 对待排序的数组r[1..n]中的元素进行直接插入排序，得到一个有序的（从小到大）的数组r[1..n]。 算法思想： 1、设待排序的记录存放在数组r[1..n]中，r[1]是一个有序序列。 2、循环n-1次，每次使用折半查找法，查找r[i]（i=2，..，n）在已排好的序列r[1..i-1]中的插入位置，然后将r[i]插入表长为i-1的序列r[1..i-1]，直到将r[n]插入...
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
数据结构-顺序表与单链表的C++模板类实现
Alan_1550587588的博客
04-10 820
C++模板类实现顺序表 实现功能:  1.尾插，2.头插，3.显示，4.尾删，5.头删，6.按位置，7.插按值插，8.按位置删，9.按值删，10.按值查，11.求表长，12.清除数据，13.摧毁该顺序表，14.反转，15.冒泡排序。 顺序表模板类实现代码: //顺序表********************************************************
c++实现顺序表、单链表和双向链表
Sakuramyb马永博的博客
07-23 469
c++实现顺序表、单链表和双向链表1.顺序表//SeqList.h #pragma once#include<iostream> #include<assert.h> using namespace std;typedef int DataType;class SeqList { public: SeqList() :_array(NULL) ,_size(0
C++实现顺序表->单链表->双向链表
Quinn0918的博客
07-20 1373
C++实现顺序表Seqlist.h#pragma once typedef int DataType; #include<assert.h> class Seqlist { public: Seqlist()//构造函数 :_data(NULL) , _size(0) , _capa(0) { } ~Seqlist()//
（C++模板类）顺序表、双向链表
JS_Evey的博客
07-29 719
C++模板类实现顺序表和双向循环带头节点链表
数据结构之双向链表详解
最新发布
小源_ 的博客
12-20 3653
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
【图文详解】数组与链表的插入与读取
qq_51869518的博客
10-26 1222
这是一篇关于数组与链表的插入与读取文章，详细的通过图文结合的方式讲解知识点。通过例子的讲解，简洁易懂，了解并记住数组与链表的插入与读取的优劣对比。只需要这一篇文章就够了。如果看完对你有所帮助，希望你能动动你的小手，点个赞，点个收藏，点个关注支持一下。因为你的支持就是我创作的动力！
数据结构之直接插入排序图文详解及代码（C++实现）
qq_40159978的博客
07-11 1万+
问题： 对待排序的数组r[1..n]中的元素进行直接插入排序，得到一个有序的（从小到大）的数组r[1..n]。 算法思想： 1、设待排序的记录存放在数组r[1..n]中，r[1]是一个有序序列。 2、循环n-1次，每次使用顺序查找法，查找r[i]（i=2，..，n）在已排好的序列r[1..i-1]中的插入位置，然后将r[i]插入表长为i-1的序列r[1..i-1]，直到将r[n]插入表长为...
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
c语言的双链表，菜鸟必学
10-12
重点代码：Insert->prior = p ->prior; p ->prior->next = Insert; Insert->next = p; p->prior = Insert;
C++模板实现链表,顺序表
宇哲
08-29 1123
Seqlist.h#define _CRT_SECURE_NO_WARNINGS 1#include<iostream> #include<string> #include<cassert>using namespace std;template<typename T> class SeqList { public: SeqList(); ~SeqList(); SeqLis
C++模板实现简单的链表和顺序表
blight_888的博客
04-11 555
从最初学习C语言到C++，就有一个认识就是作为一个优秀的程序猿一定要学会 ”偷懒“ ，用程序员的话来说就是复用，在C的基础上开发的C++就深刻阐明了这一道理，因为这样有太多的好处，增加了代码的可移植性，提高了可维护性。C++的模板就很有用，可以大大提高写代码的效率，同时优秀的代码总是最简洁最有效的代码。下面我们来用模板实现链表和顺序表。 顺序表 SeqList.h文件 #define _CR
C++模板及用模板实现双向循环链表，顺序表
zhuohaiyy的博客
08-04 511
模板是泛型编程的基础。 所谓泛型编程就是编写与类型⽆关的逻辑代码，是⼀种复⽤的⽅式。 模板分为模板函数和模板类。函数模板格式: template <class 形参名1, class 形参名2, class 形参名n> 返回类型 函数名(参数列表) { ... } 模板形参的定义既可以使⽤class，也可以使⽤typename，含义是相同的。 注:模板未实例化时，代码内部的语法错误检测不
C++模板实现顺序表+双向链表+栈+队列
adorable_的博客
05-17 347
Vector.h #pragma once //类名 Vector //类型 Vector&amp;lt;T&amp;gt; template&amp;lt;class T&amp;gt; class Vector { public: Vector() //构造函数函数名与类名相同 :_start(NULL) , _finish(NULL) , _...
数组与链表（算法图解笔记2）
二郎银的博客
08-03 225
内存的工作原理 需要将数据储存到内存时，首先请求计算机提供储存空间， 计算机提供存储地址。就像逛超市时要存物品一样， 没有使用的柜子都可以存， 如果物品多就多用几个柜子。 数组 数组是一种内存处理方式， 数组核心的特征在于数据是连在一起的 。所以遇到要存储的数据超过计算机提供的空间时，需要重新提供更大的空间， 就得将全部数据移到其他地方。 （就像去饭店吃饭，中途又来了几个朋友， 你们必须坐在一起，所以必须换个大桌子）。 有同学会说计算机给某个数组预留充足的空间可以缓解这个问题 。但是预留仍然存在两个问题：
c++实现单链表,双向链表,顺序表的接口(非模板)
errors5835的博客
07-18 338
在以前使用c实现单链表的时候,没有使用函数的复用去完成相应的接口操作,这次使用尽量多的复用去完成链表和顺序表的操作(包括故意使用insert()去复用pushback()这个逻辑是错的,只是为了 体现复用的简便)单链表struct SListNode { SListNode* _next; DataType _data; SListNode(DataType x)
图解双向链表
吾竹清风2017
09-11 615
插入 删除 #ifndef _MY_DLINKLIST_H #define _MY_DLINKLIST_H typedef void DLinkList; typedef struct _tag_DLinkListNode { struct _tag_DLinkListNode *next; //后继指针 struct _tag_DLinkListNode *pre; //前驱指针 }DLinkListNode; //创建双向...
数据结构详解：栈的概念、实现与操作
"数据结构全部内容的图文总结，包括栈的概念、存储结构、运算规则以及顺序栈的实现，如初始化、清空、销毁、入栈和出栈操作的详细描述。" 在计算机科学中，数据结构是组织、管理和存储数据的重要方式，它影响着程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值