双向链表(Doubly Linked List)

最新推荐文章于 2024-09-04 19:36:18 发布
最新推荐文章于 2024-09-04 19:36:18 发布
阅读量1.6w 收藏 25
点赞数 1
分类专栏： C++数据结构 文章标签： 数据结构 双向链表 双向链表的结点结构 双向链表的链接方式 双向链表的优缺点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/51301631
版权

双向链表(Doubly Linked List)

1. 双向链表的概念

1.1 双向链表的定义
  • 双向链表又称为双链表，是链表的一种。
1.2 双向链表的结点结构
  • 双向链表的结点包括三个部分：前驱指针域、数据域和后继指针域。
    (1)前驱指针域(lLink)，又称为左链指针，用于存放一个指针，该指针指向上一个结点的开始存储地址。
    (2)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。
    (3)后继指针域(rLink)，又称为右链指针，用于存放一个指针，该指针指向下一个结点的开始存储地址。
  • 双向链表的结点结构示意图：
    这里写图片描述
1.3 双向链表中各结点的链接方式
  • 双向链表常采用带附加头结点的循环链表的链接方式。
  • 一个双向链表有一个附加头结点，由链表的头指针first指示，它的data域或者不放数据，或者存放一个特殊要求的数据，它的lLink指向链表的尾结点(即最后一个结点)，它的rLink指向链表的首元结点(即第一个结点)。
  • 双向链表的首元结点的左链指针lLink和尾结点的右链指针rLink都指向附加头结点first。
  • 从双向链表中的任意一个结点开始，就可以直接访问它的前驱结点和后继结点。
  • 双向链表(带附加头结点的)中各结点的链接方式示意图示意图：
    这里写图片描述

2. 双向链表的实现

2.1 链表的结点结构定义

  • 文件：LinkNode.h

    
#ifndef LINK_NODE_H_


#define LINK_NODE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *lLink; //指针域——前驱指针
    LinkNode<T> *rLink; //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* lptr = NULL, LinkNode<T>* rptr = NULL){ lLink = lptr; rLink = rptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* lptr = NULL, LinkNode<T>* rptr = NULL){ data = value; lLink = lptr; rLink = rptr;}
};


#endif /* LINK_NODE_H_ */
2.2 双向链表的类定义及其操作的实现(带附加头结点)

  • 文件：DoublyLinkedList.h

    
#ifndef DBL_LINKED_LIST_H_


#define DBL_LINKED_LIST_H_



#include "LinkNode.h"


template <class T>
class DblLinkedList//带附加头结点
{
public:
    DblLinkedList();                                //构造函数
    DblLinkedList(const DblLinkedList<T>& L);       //拷贝构造函数
    ~DblLinkedList();                               //析构函数
public:
    int Length()const;                                      //计算链表的结点总数(除附加头结点)
    LinkNode<T>* Search(const T& x)const;                   //搜索数据值为x的结点并返回
    LinkNode<T>* Locate(int i, bool isLtoR = true)const;    //获取第i个结点并返回，遍历方向默认是从左往右
    bool GetData(int i, T& x, bool isLtoR = true)const;     //获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右
    bool SetData(int i, const T& x, bool isLtoR = true);    //修改第i个结点的数据值为x，遍历方向默认是从左往右
    bool Insert(int i, const T& x, bool isLtoR = true);     //在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右
    bool Remove(int i, T& x, bool isLtoR = true);           //删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右
    bool IsEmpty()const;                                    //判断表是否为空
    bool IsFull()const;                                     //判断表是否为满
    void Sort();                                            //表排序——冒泡排序
    void InputFront(const T& endTag);                       //前插法建立链表
    void InputRear(const T& endTag);                        //后插法建立链表
    void Output()const;                                     //输出所有结点的数据值
    void Reverse();                                         //链表逆置
    void MakeEmpty();                                       //清空链表(保留附加头结点)
    DblLinkedList<T>& operator=(const DblLinkedList<T>& L); //链表间赋值操作——重载等号运算符
public:
    LinkNode<T>* GetHead()const;                            //返回附加头结点的地址
    T get_value(string& s_value);                           //返回输入的结点数据值
public:
    static bool IsNumber(const string& s_num);  //判断输入的字符串每个字符是否都是数值0~9
    static T StrToTtype(const string& s_num);   //类型转换——将string型转为模板类型T
private:
    LinkNode<T> *first; //链表的头结点
};

//构造函数
template<class T>
DblLinkedList<T>::DblLinkedList()
: first(new LinkNode<T>)
{
    first->lLink = first;
    first->rLink = first;
    cout << "$ 执行构造函数" << endl;
}

//拷贝构造函数
template<class T>
DblLinkedList<T>::DblLinkedList(const DblLinkedList<T>& L)
{
    cout << "$ 执行拷贝构造函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (L.GetHead() != srcptr->rLink)
    {
        srcptr = srcptr->rLink;
        destptr->rLink = new LinkNode<T>(srcptr->data);
        destptr->rLink->lLink = destptr;
        destptr = destptr->rLink;
    }
    first->lLink = destptr;
    destptr->rLink = first;
}

//析构函数
template<class T>
DblLinkedList<T>::~DblLinkedList()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}

//计算链表的结点总数(除附加头结点)
template<class T>
int DblLinkedList<T>::Length()const
{
    int count = 0;
    LinkNode<T> *curNode = first->rLink;
    while (first != curNode)
    {
        curNode = curNode->rLink;
        count++;
    }
    return count;
}

//搜索数据值为x的结点并返回
template<class T>
LinkNode<T>* DblLinkedList<T>::Search(const T& x)const
{
    LinkNode<T> *curNode = first->rLink;
    while ((first != curNode) && (x != curNode->data))
    {
        curNode = curNode->rLink;
    }
    if (first == curNode)
    {
        curNode = NULL;
    }
    return curNode;
}

//获取第i个结点并返回，遍历方向默认是从左往右
template<class T>
LinkNode<T>* DblLinkedList<T>::Locate(int i, bool isLtoR)const
{
    if (i < 0)
    {
        return NULL;
    }
    if ((first == first->rLink) || (0 == i))
    {
        return first;
    }
    int location = 1;
    LinkNode<T> *curNode = NULL;
    if (true == isLtoR)
    {
        curNode = first->rLink;
    }
    else
    {
        curNode = first->lLink;
    }
    while ((location < i) && (first != curNode))
    {
        if (true == isLtoR)
        {
            curNode = curNode->rLink;
        }
        else
        {
            curNode = curNode->lLink;
        }
        location++;
    }
    if (first == curNode)
    {
        curNode = NULL;
    }
    return curNode;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右
template<class T>
bool DblLinkedList<T>::GetData(int i, T& x, bool isLtoR)const
{
    LinkNode<T> *curNode = Locate(i, isLtoR);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    x = curNode->data;
    return true;
}

//修改第i个结点的数据值为x，遍历方向默认是从左往右
template<class T>
bool DblLinkedList<T>::SetData(int i, const T& x, bool isLtoR)
{
    LinkNode<T> *curNode = Locate(i, isLtoR);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    curNode->data = x;
    return true;
}

//在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右
template<class T>
bool DblLinkedList<T>::Insert(int i, const T& x, bool isLtoR)
{
    LinkNode<T> *curNode = Locate(i, isLtoR);
    if (NULL == curNode)
    {
        return false;
    }
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        cerr << "* 存储分配错误" << endl;
        exit(1);
    }
    if (true == isLtoR)
    {
        newNode->lLink = curNode;
        newNode->rLink = curNode->rLink;
        curNode->rLink->lLink = newNode;
        curNode->rLink = newNode;
    }
    else
    {
        newNode->lLink = curNode->lLink;
        newNode->rLink = curNode;
        curNode->lLink->rLink = newNode;
        curNode->lLink = newNode;
    }
    return true;
}

//删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右
template<class T>
bool DblLinkedList<T>::Remove(int i, T& x, bool isLtoR)
{
    LinkNode<T> *delNode = Locate(i, isLtoR);
    if ((NULL == delNode) || (first == delNode))
    {
        return false;
    }
    delNode->rLink->lLink = delNode->lLink;
    delNode->lLink->rLink = delNode->rLink;
    x = delNode->data;
    delete delNode;
    return true;
}

//判断表是否为空
template<class T>
bool DblLinkedList<T>::IsEmpty()const
{
    return (first == first->rLink) ? true : false;
}

//判断表是否为满
template<class T>
bool DblLinkedList<T>::IsFull()const
{
    return false;
}

//表排序——冒泡排序
template<class T>
void DblLinkedList<T>::Sort()
{
    LinkNode<T> *curNode = first->rLink;
    while (first != curNode)
    {
        LinkNode<T> *nextNode = curNode->rLink;
        while (first != nextNode)
        {
            if (curNode->data < nextNode->data)
            {
                T temp = curNode->data;
                curNode->data = nextNode->data;
                nextNode->data = temp;
            }
            nextNode = nextNode->rLink;
        }
        curNode = curNode->rLink;
    }
}

//前插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void DblLinkedList<T>::InputFront(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = NULL;
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);
        if (NULL == newNode)
        {
            cerr << "* 存储分配错误" << endl;
            exit(1);
        }
        if (first->rLink == first)
        {
            lastNode = newNode;
        }
        newNode->lLink = first;
        newNode->rLink = first->rLink;
        first->rLink->lLink = newNode;
        first->rLink = newNode;
        value = get_value(s_value);
    }
    first->lLink = lastNode;
    lastNode->rLink = first;
}

//后插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void DblLinkedList<T>::InputRear(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = first;
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);
        if (NULL == newNode)
        {
            cerr << "* 存储分配错误" << endl;
            exit(1);
        }
        newNode->lLink = lastNode;
        newNode->rLink = lastNode->rLink;
        lastNode->rLink = newNode;
        lastNode = newNode;
        value = get_value(s_value);
    }
    first->lLink = lastNode;
    lastNode->rLink = first;
}

//输出所有结点的数据值
template<class T>
void DblLinkedList<T>::Output()const
{
    LinkNode<T> *curNode = first->rLink;
    while (first != curNode)
    {
        cout << "curNode->data = " << curNode->data << endl;
        curNode = curNode->rLink;
    }
}

//链表逆置
template<class T>
void DblLinkedList<T>::Reverse()
{
    LinkNode<T> *prevNode = first;
    LinkNode<T> *curNode = first->rLink;
    LinkNode<T> *nextNode = curNode->rLink;
    while (first != curNode) 
    {
        curNode->rLink = prevNode;
        curNode->lLink = nextNode;
        prevNode = curNode;
        curNode = nextNode;
        nextNode = curNode->rLink;
    }
    first->lLink = nextNode;
    first->rLink = prevNode;
}

//清空链表(保留附加头结点)
template<class T>
void DblLinkedList<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (first != first->rLink)       //当链表不为空时，删去链表中所有结点
    {
        curNode = first->rLink;         //保存被删结点
        first->rLink = curNode->rLink;  //将链表附加头结点中指针域的指针指向被删结点的下一个结点
        delete curNode;                 //从链表上摘下被删结点
    }
}

//链表间赋值操作——重载等号运算符
template<class T>
DblLinkedList<T>& DblLinkedList<T>::operator=(const DblLinkedList<T>& L)
{
    cout << "$ 执行赋值操作函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (L.GetHead() != srcptr->rLink)
    {
        srcptr = srcptr->rLink;
        destptr->rLink = new LinkNode<T>(srcptr->data);
        destptr->rLink->lLink = destptr;
        destptr = destptr->rLink;
    }
    first->lLink = destptr;
    destptr->rLink = first;
    return *this;
}

//返回附加头结点的地址
template<class T>
LinkNode<T>* DblLinkedList<T>::GetHead()const
{
    return first;
}

//返回输入的结点数据值
template <class T>
T DblLinkedList<T>::get_value(string& s_value)
{
    cout << "newNode->data = ";
    cin >> s_value;
    return StrToTtype(s_value);
}

//判断输入的字符串每个字符是否都是数值0~9
template <class T>
bool DblLinkedList<T>::IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T DblLinkedList<T>::StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}


#endif /* DBL_LINKED_LIST_H_ */
2.3 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "DblLinkedList.h"  //带附加头结点



#define EXIT 0              //退出


#define CONSTRUCT_COPY 1    //拷贝构造链表


#define LENGTH 2            //计算链表的结点总数


#define SEARCH 3            //搜索数据值为x的结点并返回


#define LOCATE 4            //获取第i个结点并返回，遍历方向默认是从左往右


#define GETDATA 5           //获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右


#define SETDATA 6           //修改第i个结点的数据值为x，遍历方向默认是从左往右


#define INSERT 7            //在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右


#define REMOVE 8            //删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右


#define ISEMPTY 9           //判断表是否为空


#define ISFULL 10           //判断表是否为满


#define SORT 11             //表排序——冒泡排序


#define INPUTFRONT 12       //前插法建立链表


#define INPUTREAR 13        //后插法建立链表


#define OUTPUT 14           //输出所有结点的数据值


#define REVERSE 15          //链表逆置


#define MAKEEMPTY 16        //清空链表


#define OPERATOR_COPY 17    //链表间赋值操作——重载等号运算符


#define GETHEAD 18          //返回头结点的地址


void print_description()
{
    cout << "------------------------------>双向链表<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 拷贝构造链表" << endl;
    cout << "#2： 计算链表的结点总数" << endl;
    cout << "#3： 搜索数据值为x的结点并返回" << endl;
    cout << "#4： 获取第i个结点并返回，遍历方向默认是从左往右" << endl;
    cout << "#5： 获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右" << endl;
    cout << "#6： 修改第i个结点的数据值为x，遍历方向默认是从左往右" << endl;
    cout << "#7： 在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右" << endl;
    cout << "#8： 删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右" << endl;
    cout << "#9： 判断表是否为空" << endl;
    cout << "#10：判断表是否为满" << endl;
    cout << "#11：表排序——冒泡排序" << endl;
    cout << "#12：前插法建立链表" << endl;
    cout << "#13：后插法建立链表" << endl;
    cout << "#14：输出所有结点的数据值" << endl;
    cout << "#15：链表逆置" << endl;
    cout << "#16：清空链表" << endl;
    cout << "#17：链表间赋值操作——重载等号运算符" << endl;
    cout << "#18：返回头结点的地址" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//输入结点编号
template <class T>
int get_item()
{
    cout << "> 请输入结点编号，item = ";
    string s_item;
    cin >> s_item;
    while (false == DblLinkedList<T>::IsNumber(s_item))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_item;
    }
    return atoi(s_item.c_str());
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return DblLinkedList<T>::StrToTtype(s_data);
}

//输入结束标志位
template <class T>
T get_endtag()
{
    cout << "请输入结束标志值，endTag = ";
    string s_endTag;
    cin >> s_endTag;
    return DblLinkedList<T>::StrToTtype(s_endTag);
}

//输入遍历方向，是否从左往右，是输入1，否输入0
template <class T>
bool get_dir()
{
    cout << "> 请输入遍历方向，是否从左往右，是输入1，否输入0，isLtoR = ";
    string s_dir;
    cin >> s_dir;
    while (false == DblLinkedList<T>::IsNumber(s_dir))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_dir;
    }
    return atoi(s_dir.c_str()) ? true : false;
}

//构造双向链表
template <class T>
DblLinkedList<T>* construct_dbllinkedList()
{
    cout << "\n==> 创建双向链表" << endl;
    DblLinkedList<T> *dbllinkedList = new DblLinkedList<T>;
    return dbllinkedList;
}

//析构双向链表
template <class T>
void destory_dbllinkedList(DblLinkedList<T>* dbllinkedList)
{
    cout << "\n==> 释放双向链表在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete dbllinkedList;
    dbllinkedList = NULL;
}

//拷贝构造链表
template <class T>
void construct_copy(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行拷贝构造链表函数" << endl;
    DblLinkedList<T> cpy_linkedlist = *dbllinkedList;
    cpy_linkedlist.Output();
}

//计算链表的结点总数
template <class T>
void length(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行计算链表的结点总数函数，Length = " << dbllinkedList->Length() << endl;
}

//搜索数据值为x的结点并返回
template <class T>
void search(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行搜索数据值为x的结点并返回函数" << endl;
    T data = get_data<T>();
    LinkNode<T> *node = dbllinkedList->Search(data);
    if (NULL == node)
    {
        cout << "* 搜索失败" << endl;
        return;
    }
    cout << "* 搜索成功，data = " << node->data << endl;
}   

//获取第i个结点并返回，遍历方向默认是从左往右
template <class T>
void locate(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行获取第i个结点并返回遍历方向默认是从左往右函数" << endl;
    int n_item = get_item<T>();
    bool isLtoR = get_dir<T>();
    LinkNode<T> *node = dbllinkedList->Locate(n_item, isLtoR);
    if ((NULL == node) || (dbllinkedList->GetHead() == node))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << node->data << endl;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右
template <class T>
void getdata(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行获取第i个结点的数据值保存至x并返回获取成功与否遍历方向默认是从左往右函数" << endl;
    T data;
    int n_item = get_item<T>();
    bool isLtoR = get_dir<T>();
    if (false == dbllinkedList->GetData(n_item, data, isLtoR))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << data << endl;
}

//修改第i个结点的数据值为x，遍历方向默认是从左往右
template <class T>
void setdata(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行修改第i个结点的数据值为x遍历方向默认是从左往右函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    bool isLtoR = get_dir<T>();
    if (false == dbllinkedList->SetData(n_item, data, isLtoR))
    {
        cout << "* 修改失败" << endl;
        return;
    }
    cout << "* 修改成功，item = " << n_item << "，data = " << data << endl;
}

//在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右
template <class T>
void insert(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行在第i个结点后插入数据值为x的新结点遍历方向默认是从左往右函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    bool isLtoR = get_dir<T>();
    if (false == dbllinkedList->Insert(n_item, data, isLtoR))
    {
        cout << "* 插入失败" << endl;
        return;
    }
    cout << "* 插入成功，item+1 = " << n_item+1 << "，data = " << data << endl;
}

//删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右
template <class T>
void remove(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行删除第i个结点并将被删结点的数据值保存至x遍历方向默认是从左往右函数" << endl;
    T data;
    int n_item = get_item<T>();
    bool isLtoR = get_dir<T>();
    if (false == dbllinkedList->Remove(n_item, data, isLtoR))
    {
        cout << "* 删除失败" << endl;
        return;
    }
    cout << "* 删除成功，item = " << n_item << "，data = " << data << endl;
}

//判断表是否为空
template <class T>
void isempty(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行判断表是否为空函数，IsEmpty = " << dbllinkedList->IsEmpty() << endl;
}

//判断表是否为满
template <class T>
void isfull(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行判断表是否为满函数，IsFull = " << dbllinkedList->IsFull() << endl;
}

//表排序——冒泡排序
template <class T>
void sort(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行表排序——冒泡排序函数" << endl;
    dbllinkedList->Sort();
}

//前插法建立链表
template <class T>
void inputfront(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行前插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    dbllinkedList->InputFront(endTag);
}

//后插法建立链表
template <class T>
void inputrear(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行后插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    dbllinkedList->InputRear(endTag);
}

//输出所有结点的数据值
template <class T>
void output(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行输出所有结点的数据值函数" << endl; 
    dbllinkedList->Output();
}

//链表逆置
template <class T>
void reverse(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行链表逆置函数" << endl;
    dbllinkedList->Reverse();
}

//清空链表
template <class T>
void make_empty(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行清空链表函数" << endl; 
    dbllinkedList->MakeEmpty();
}

//链表间赋值操作——重载等号运算符
template <class T>
void operator_copy(DblLinkedList<T>* dbllinkedList)
{
    cout << "$ 执行链表间赋值操作——重载等号运算符函数" << endl; 
    DblLinkedList<T> cpy_linkedlist;
    cpy_linkedlist = *dbllinkedList;//或cpy_linkedlist.operator=(*dbllinkedList);
    cpy_linkedlist.Output();
}

//返回头结点的地址
template <class T>
void gethead(DblLinkedList<T>* dbllinkedList)
{       
    LinkNode<T> *head = dbllinkedList->GetHead();
    cout << "$ 执行返回头结点的地址函数，&first = " << &head << endl;
}

//双向链表操作选择
template <class T>
void select_operation(DblLinkedList<T>* dbllinkedList)
{
    if (NULL == dbllinkedList)
    {
        cout << "* 没有构造双向链表，请先构造双向链表。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == DblLinkedList<T>::IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case CONSTRUCT_COPY://拷贝构造链表
            {
                construct_copy(dbllinkedList);
                break;
            }
            case LENGTH://计算链表的结点总数
            {
                length(dbllinkedList);
                break;
            }
            case SEARCH://搜索数据值为x的结点并返回
            {
                search(dbllinkedList);
                break;
            }
            case LOCATE://获取第i个结点并返回，遍历方向默认是从左往右
            {
                locate(dbllinkedList);
                break;
            }
            case GETDATA://获取第i个结点的数据值保存至x，并返回获取成功与否，遍历方向默认是从左往右
            {
                getdata(dbllinkedList);
                break;
            }
            case SETDATA://修改第i个结点的数据值为x，遍历方向默认是从左往右
            {
                setdata(dbllinkedList);
                break;
            }
            case INSERT://在第i个结点后插入数据值为x的新结点，遍历方向默认是从左往右
            {
                insert(dbllinkedList);
                break;
            }
            case REMOVE://删除第i个结点，并将被删结点的数据值保存至x，遍历方向默认是从左往右
            {
                remove(dbllinkedList);
                break;
            }
            case ISEMPTY://判断表是否为空
            {
                isempty(dbllinkedList);
                break;
            }
            case ISFULL://判断表是否为满
            {
                isfull(dbllinkedList);
                break;
            }
            case SORT://表排序——冒泡排序
            {
                sort(dbllinkedList);
                break;
            }
            case INPUTFRONT://前插法建立链表
            {
                inputfront(dbllinkedList);
                break;
            }
            case INPUTREAR://后插法建立链表
            {
                inputrear(dbllinkedList);
                break;
            }
            case OUTPUT://输出所有结点的数据值
            {
                output(dbllinkedList);
                break;
            }
            case REVERSE://链表逆置
            {
                reverse(dbllinkedList);
                break;
            }
            case MAKEEMPTY://清空链表
            {
                make_empty(dbllinkedList);
                break;
            }
            case OPERATOR_COPY://链表间赋值操作——重载等号运算符
            {
                operator_copy(dbllinkedList);
                break;
            }
            case GETHEAD://返回头结点的地址
            {
                gethead(dbllinkedList);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    DblLinkedList<int> *dbllinkedList = construct_dbllinkedList<int>();
    select_operation(dbllinkedList);
    destory_dbllinkedList(dbllinkedList);
    system("pause");
    return 0;
}

3. 双向链表的优缺点

3.1 优点
  • 没有空间限制，存储元素的个数无上限，基本只与内存空间大小有关。
  • 插入和删除元素速率高。
  • 只要知道表中任何一个结点的地址，就可以直接访问它的前驱结点和后继结点。
3.2 缺点
  • 占用额外的空间以存储指针(浪费空间)。
  • 随机存取元素速率低。
3.3 双向链表的适用情况
  • 适用于需要进行大量增添和删除元素操作而对访问元素无要求的，及预先无法确定表的大小的程序。

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第二章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章
[3] 百度搜索关键字：双向链表的优缺点

Cainv89
关注
专栏目录
C/C++ 双向链表Doubly Linked List算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-26 2338
双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。相比于单向链表，双向链表可以实现双向遍历。双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。相比于单向链表，双向链表可以实现双向遍历。双向链表（Doubly Linked List）是一种链表的数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。
PHP实现双向链表Doubly Linked List(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-21 15
PHP实现双向链表Doubly Linked List(附完整源码)
【数据结构】Doubly-Linked List双向链表（更新时间：2016-04-13）
KuroNeko黑猫
04-13 605
【数据结构】Doubly-Linked List双向链表（更新时间：2016-04-03） 啊哈，Doge 来补之前遗留下的关于链表的扩展的东西了 在学习了之前的单链表的基础上，Doge在这里再给大家介绍一下链表的一些拓展，主要是关于链表的指针域不同的连接方式会形成不同的链表类型。
数据结构——双向链表
最新发布
qq_63843346的博客
09-04 715
单向链表：若要删除一个节点或在某个节点后插入一个新节点，你需要访问该节点的前一个节点，这在没有头节点的情况下可能需要从头遍历链表。双向链表：由于可以双向遍历，删除节点或在节点后插入新节点时，可以直接访问到前一个节点，这使得插入和删除操作更加灵活和高效。在双向链表的最后一个节点（尾节点）中，这个指针通常为空，因为尾节点后面没有其他节点。双向链表：每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点，因此可以双向遍历。删除链表中的某个节点，需要更新被删除节点前后节点的指针。
数据结构：双向链表
2401_86551514的博客
08-03 752
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
doubly_linked_list.rar
05-10
该代码的主要功能是根据双向链表中的数据大小排序，排序方式是选择法和冒泡法两种，其中选择法是用交换指针来实现的。
10820
CSND12333的博客
06-01 205
就是欧拉函数的应用，求2-n的每个数的欧拉函数的2倍+1，用了三种方法，前两种是一个一个求，第一种卡着时间过的，第二种预处理之后就很快了， 第三种用的求连续的1-n内的每个数的欧拉函数的模版求的，非常快 //============================================================================ // Name...
数据结构与算法(四)-双向链表(DoublyLinkedList)
老男孩的博客
01-07 6698
双向链表(DoublyLinkedList)结构 一、双向链表的介绍 既可以从头遍历到尾，也可以从尾遍历到头。链表相连的过程是双向的。实现原理是一个节点既有向前连接的引用，也有一个向后连接的引用 单向链表的特性 只能从头遍历到尾或者从尾遍历到头（一般从头到尾） 链表相连的过程是单向的，实现原理是上一个节点中有指向下一个节点的引用 单向链表有一个比较明显的缺点：可以轻松到达下一个节点，但回到前一个节点很难，在实际开发中, 经常会遇到需要回到上一个节点的情况。 由于双向链表的节点指向是双向的，所以双向链表可以
带头节点 (非头指针) 双向链表 (doubly linked list)
既然选择了远方 便只顾风雨兼程 - 永强
03-14 1416
带头节点 (非头指针) 双向链表 (doubly linked list) 线性表是一种线性结构，它具有相同类型的 n (n≥0)n \ (n ≥ 0)n (n≥0) 个数据元素组成的有限序列。线性表：数组、单向链表、双向链表。 doubly (bidirectional) linked list：双向链表 1. 单向链表 (singly linked list) 单向链表是一种使用指针来存储值的数据结构。链表中的每个节点包含一个字段，用于指向链表的下一个节点。另外有一个独立的根指针指向
C++ 模板实现—双向链表： doubly linked list
学习-记录-分享创造价值
08-27 462
C++模板类实现双向链表
C语言实现双向链表Doubly Linked List(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-02 770
双向链表Doubly Linked Listlist结构体实现以下6个接口双向链表Doubly Linked List完整源码（定义，实现，main函数测试） list结构体 typedef struct list { double value; ///< value saved on each node struct list *next, *prev; ///< directing to other nodes or NULL } List;
MyDoublyLinkedList
10-31
Java实现的MyDoublyLinkedList，包含抽象数据类型MyList接口，MyDoublyLinkedList源码以及Junit测试case，能够帮助新手很好地学习双链表及其实现
C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码
03-24
C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码 1 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一...
C#，双向链表（Doubly Linked List）快速排序（Quick Sort）算法与源代码
03-24
C#，双向链表（Doubly Linked List）快速排序（Quick Sort）算法与源代码。双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始...
双向链表DoublyLinkedList类
kalinux的博客
08-22 2036
双向链表可以往前寻找数据项：单向链表寻值时若错过了值，需要从头开始。 双向链表多了一个tail值，尾巴； ***向双向链表插入一个值： this.insert=function(position,  element){ if(position&gt;=0&amp;&amp;position&lt;this.length){ var node=new Node(element);  // 先...
数据结构——Doubly_Linked_List的代码实现
KeLThuzAD57的博客
04-05 912
Reference Book: 《Data Structure and Program Design in C++》 --------------------------------------------------------------------------------------------------------------------------------------------
DoublyLinkedList
Sodino的专栏
03-16 831
package lab.sodino.linklist;public class LinkedNode { private Object value; private LinkedNode preNode; private LinkedNode nextNode; public LinkedNode(Object obj) { this.value = obj;
Doubly Linked List
qq_41998938的博客
12-11 221
Doubly Linked List 题目： Your task is to implement a double linked list. Write a program which performs the following operations: insert x: insert an element with key x into the front of the list. delet...
【ACM】Doubly Linked List（STL list）
( :3 )
01-19 242
题目链接：https://vjudge.net/problem/Aizu-ALDS1_3_C 这一题一开始的时候想的是用vector，超时 #include &lt;iostream&gt; #include &lt;stack&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;queue&gt; #inclu...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值