c++数据结构：线性表实现之双链表

最新推荐文章于 2022-02-15 15:11:44 发布
最新推荐文章于 2022-02-15 15:11:44 发布
阅读量408 收藏 1
点赞数
分类专栏： c++ 文章标签： c++ 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chiling_1024/article/details/78167382
版权

原型：单链表；
与单链表节点结构差异：单链表仅有一个指针域指向下一个节点，双链表有两个指针域分别指向其上一个和下一个节点；
实现操作差异：主要是上链（插入）与脱链（删除）操作，其中双链表上链时的指针重导向需注意相对顺序（不能颠倒）

节点结构：

#pragma once

template< typename T>
class Node {
public:
    T data;
    Node *next;   //向后指针
    Node *prior;  //向前指针    相对单链表新增的指针域
};

双链表类模板实现：

#pragma once
#include"Node.h"
#include<iostream>
#include<string>
using namespace std;

template <typename T>
class doubleLink
{
public:
    doubleLink(T a[],int n);
    ~doubleLink();
    int Length();         //返回单链表的长度
    T Get(int i);           //按位查找，查找第i个节点的元素
    int Locate(T x);        //按值查找，查找链表中第一个值为x的元素，并返回序号
    bool Insert(int i, T x);   //插入元素，在第i个位置插入值x
    bool Delete(int i);       //删除节点,删除第i个节点
    bool InsertHead(T x);    //头插法插入节点
    bool InsertTail(T x);    //尾插法插入节点
    void ListTraverse();      //遍历节点
    T priorOne(int i);      //返回节点的上一个节点
    T nextOne(int i);     //返回节点的下一个节点
private:
    Node<T> *first;        //设置头指针
    int m_Length;  //设置链的长度计数器
};
template<typename T>
doubleLink<T>::doubleLink(T a[], int n)
{
    m_Length = 0;
    first = new Node<T>;
    first->next = NULL;
    first->prior = NULL;
    for (int i = 0; i < n; i++)    //头插法插入元素
    {
        Node<T> *s = new Node<T>;
        s->data = a[i];
        if (first->prior == NULL) {
            s -> next = first;
            s->prior = first;
            first->next = s;
            first->prior = s;
            m_Length++;
        }
        else {
            s->next = first->next;
            first->next->prior = s;
            s -> prior = first;
            first->next = s;
            m_Length++;
        }

    }
    //尾插法插入元素
    /*for (var i = 0; i < n;i++) {      
        Node<T> *s = new Node<T>;
        s->data = a[i];
        if (first->prior == NULL) {
            s->next = first;
            s->prior = first;
            first->next = s;
            first->prior = s;
            Length++;
        }
        else {
            s->prior = first->prior;
            s->next = first;
            first->prior->next = s;
            first->prior = s;
            m_Length++;
        }
    }*/
}
template<typename T>
doubleLink<T>::~doubleLink()
{
    while (first->next!=first->prior)
    {
        //临时指针，存储即将释放的节点的指针
        Node<T> *temp = first;
        //脱链
        first->prior->next = first->next;
        first->next -> prior = first->prior;
        //头指针后移
        first = first->next;
        //释放内存
        delete temp;
    }
    delete first;
}

template<typename T>
int doubleLink<T>::Length() {
    return m_Length;
}
template<typename T>
T doubleLink<T>::Get(int i) {
    if (i > m_Length || i <= 0)
    {
        throw string("调用函数Get()时位置出错！");
    }
    else {
        Node<T> *p = first;
        for (int j = 0; j < i;j++) {
            p = p->next;
        }
        return p->data;
    }
}
template<typename T>
int doubleLink<T>::Locate(T x) {
    Node<T> *p = first->next;
    int count = 1;
    for (int i = 0; i < m_Length; i++) {
        if (p->data == x)
        {
            return count;
        }
        p = p->next;
        count++;
    }
    if (p->next == first)
    {
        return -1;    /*个人认为此处不应该抛出错误，所以并没有throw*/
    }
}
template<typename T>
bool doubleLink<T>::Insert(int i, T x) {
    if (i > m_Length || i <= 0) {   //判断要插入的位置是否在合理范围
        throw string("调用函数Insert()时位置出错");
    }
    Node<T> *p = first;     
    Node<T> *s = new Node<T>;
    if (s == NULL) {
        return false;
    }
    s->data = x;
    int count = 0;
    while (p->next!=first&&count < i) {
        p = p->next;
        count++;
    }
    s->next = p;
    s->prior = p->prior;
    p->prior->next = s;
    p->prior = s;
    m_Length++;
    return true;
}
template<typename T>
bool doubleLink<T>::Delete(int i) {
    if (i > m_Length || i < 0)
    {
        throw string("调用函数Delete()时位置出错");
    }
    int count = 0;
    Node<T> *p = first;
    while (p->next != first&&count < i) {
        p = p->next;
        count++;
    }
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;
    m_Length--;
    return true;
}
template<typename T>
bool doubleLink<T>::InsertHead(T x) {
    Node<T> *s = new Node<T>;
    if (s == NULL) {
        return false;  //内存申请失败要不要throw出来？em......母鸡
    }
    s->data = x;
    s->next = first->next;
    s->prior = first;
    first->next->prior = s;
    first->next = s;
    m_Length++;
    return true;
}
template<typename T>
bool doubleLink<T>::InsertTail(T x) {
    Node<T> *s = new Node<T>;
    if (s == NULL) {
        return false;
    }
    s->data = x;
    s->next = first;
    s->prior = first->prior;
    first->prior->next = s;
    first->prior = s;
    m_Length++;
    return true;
}
template<typename T>
void doubleLink<T>::ListTraverse() {
    Node<T> *p = first->next;
    cout << endl;
    for (int i = 0; i < m_Length;i++) {
        cout << p->data << ",";
        p = p->next;
    }
}

template<typename T>
T doubleLink<T>::priorOne(int i) {
    if (i > m_Length || i <= 0)
    {
        throw string("调用函数prior时位置出错");
    }
    else {
        Node<T> *p = first;
        for (int j = 0; j < i; j++) {
            p = p->next;
        }
        if (i == 1) {
            return p->prior->prior->data;
        }
        else {
            return p->prior->data;
        }
    }
}
template<typename T>
T doubleLink<T>::nextOne(int i) {
    if (i > m_Length || i <= 0)
    {
        throw string("调用函数nextone时位置出错");
    }
    else {
        Node<T> *p = first;
        for (int j = 0; j < i; j++) {
            p = p->next;
        }
        if (i==m_Length) {
            return p->next->next->data;
        }
        else {
            return p->next->data;
        }
    }
}

函数调用测试：

#include<iostream>
#include"doubleLink.h"
#include<string>
using namespace std;

int main() {
    int a[5] = { 1,2,3,4,5 };
    try{
        doubleLink<int> MyList(a, 5);
        MyList.ListTraverse();      //测试遍历函数是否成功
        cout << endl << "链表长度为：" << MyList.Length() << endl;        //测试返回长度函数是否成功
        cout << "第1个节点的元素为：" << MyList.Get(1);     //测试查找位置元素的函数是否成功
        MyList.Delete(1);
        cout << endl << "删除第一个节点后:";
        MyList.ListTraverse();
        MyList.Insert(1, 5);
        cout <<endl<< "插入元素5到第一个节点后：" ;
        MyList.ListTraverse();
        MyList.InsertHead(2);
        cout << endl << "头插法插入元素2：";
        MyList.ListTraverse();
        MyList.InsertTail(8);
        cout << endl << "尾插法插入元素8";
        MyList.ListTraverse();
        cout << endl << "元素8所在的位置为：" << MyList.Locate(8);
        cout << endl << "第二个节点的后一个节点元素为：" << MyList.nextOne(2);
        cout << endl << "第二个节点的前一个节点元素为：" << MyList.priorOne(2);
    }
    catch (string &aval) {
        cout << aval << endl;
    }
    return 0;
}

合法数据调用结果：
合法数据调用结果

部分非法数据调用结果：

Get(i)传入的参数非法时：
非法数据输入
Delete(i)传入的参数非法时：
非法数据输入

在准备选择双链表时，应先看看单链表是否能够满足需求，因为双链表多了一个指针域，数据量大时可能会浪费存储空间，而且双链表操作比单链表繁琐一点。
额。。。
暂时只能挤这么多。。
Bye

chiling_1024
关注
专栏目录
C++数据结构： 线性表之单链表
chiling_1024的博客
09-23 334
c++数据结构地线性表地存储结构之单链表
c/c++ 数据结构-线性表（单链表基本操作的实现）
Economic_shark的博客
02-09 2146
线性表–链式存储结构 单链表基本操作的实现
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
【c++数据结构之双链表】
m0_64037351的博客
02-15 729
双链表之数组模拟 爱因斯坦说：成功的背后是百分之99的努力，加上百分之1的勤奋 想要学好编程也是一样,共勉！
【数据结构】双链表C++
weixin_44378835的博客
11-13 392
#include<iostream> using namespace std; typedef int ElemType; struct DuLNode{ // 双向链表节点结构体 ElemType data; struct DuLNode* prior, * next; }; typedef DuLNode* DuLinklist; /******************************************************************/ /*初始化*/
数据结构C++实现——线性表之链表(双链表)
Wontoner的博客
12-29 165
/* 双链表(带头结点) */ #include <cstdio> #include <iostream> #include <cstdlib> using namespace std; #define ElemType int typedef struct DNode { ElemType data; struct DNode *prior,*next; }DNode, * DLinkList; //初始化 bool InitDLinkList(DLink.
c++实现线性表和双向链表
dancer_0405的博客
07-21 341
深浅拷贝：深浅拷贝主要解决的问题是同一块内存释放多次 浅拷贝 深拷贝 c++实现线性表 SeqList.h #define _CRT_SECURE_NO_WARNINGS #include #include #include #include #include using namespace std; typedef int DataType; class SeqList { pu
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
C++数据结构实验一：线性表的应用
03-29
3．了解循环链表、双(循环)链表的结构特点和在其上施加的插入、删除等操作。 4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种...
数据结构：线性表(链接存储).ppt
06-19
数据结构：线性表（链接存储） 一、线性表的链接存储 线性表的链接存储是一种存储方式，它可以克服顺序存储的缺点。顺序存储需要一块连续的存储空间，但是当顺序表很大时，系统可能无法分配这么大的一块连续存储...
利用C++实现以下经典数据结构算法：线性表、栈、队列、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法）、树.zip
最新发布
12-28
利用C++实现以下经典数据结构与算法：线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法...
算法与数据结构：线性表的实现
12-02
在C/C++编程中，实现这些数据结构和操作通常涉及指针操作和内存管理。理解指针的工作原理，掌握动态内存分配（如`malloc`和`free`）以及正确处理悬挂指针和内存泄漏是至关重要的。同时，良好的编程习惯，如编写清晰...
数据结构双向链表C++实现
Clown_pan的博客
05-22 852
#include <iostream> #include <stdio.h> #include <stdlib.h> #define OVERFLOW -3 #define true 1 #define false 0 #define ok 1 #define error -1 using namespace std; typedef struct DuLNo...
C++数据结构之双链表实现
zhouchao_0321的博客
09-18 274
双链表模版实现 功能： 1 创建 2 遍历 3 反转 4 插入 5 取值 6 修改某位置值 7 删除 。。。。 xxx.h 节点定义： #include &lt;iostream&gt;   template &lt;typename T&gt; struct duLink { T data; struct duLink *next; struct duLink...
数据结构 List（双链表实现）C++
cccccchao的博客
06-02 305
写在前面： 哈哈哈高产如我(✧◡✧) 简介： 双链表实现的List，相比于数组实现的List，插入和删除效率高，且不会溢出，但随机访问耗时长，且空间利用率较低（因为每个结点除了存data之外，还要存两个指针）。 因为链表本身没有根据下标访问这个功能，但List有，所以要人为地实现这个功能。 （首先应该知道，基于链表存储数据，应该设置一个“游标指针”——current） 有两个思路： ...
C++数据结构之双向链表
weixin_44568899的博客
10-19 206
#ifndef DLIST_H_INCLUDED #define DLIST_H_INCLUDED #include<iostream> using namespace std; template <class T> struct dListNode { T data; dListNode<T> *prior; dListNode&...
C++实现线性链表
boywgw的专栏
06-19 583
template struct LNode { T data; struct LNode *next; }; template class LinkList { private: LNode* m_pList; int m_ListLength; private: bool InitList(); bool GetNode(int position, LNode** node);
C/C++ 实现线性表中的双向链表
艾渃曼の博客
04-29 190
代码只进行了简单的测试 如果代码存在问题 欢迎各位带哥在评论区指出 数据结构 typedef struct LNode{ struct LNode *pre; ElemType data; //数据域 struct LNode *next; //指针域 }LNode, *DLinkList; 双向链表的原子操作实现 1.创建链表 Status ListCrea...
C++数据结构——链栈的实现
chiling_1024的博客
11-09 3340
链栈的实现，其实是针对栈的元素的个数变化量很大的一种情况，使用数组的话有可能造成很大的数组浪费空间，这时使用链栈来动态伸长链栈就变得很优秀了节点结构#pragma once template<typename T> class Node { public: T data; Node<T> *next; }; 类模板：#pragma once #include<iostream> #
C/C++数据结构实验：线性表操作与算法实现
"c/c++ 数据结构实验题及解答，涉及线性表的顺序和链式存储，包括单链表查找、插入、删除，顺序表操作，有序循环链表操作，线性表逆转，合并有序线性表去重，有序表插入，链表元素移动，Josephus问题等。" 实验题目...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值