双链表

【1】双链表

双链表即双向链表，双链表的节点结构定义如下：

typedef int Elemtype;
 
// 双链表节点结构定义
typedef struct dNode 
{
    Elemtype data; /*数据域*/
    struct dNode *prev;  /*指向前驱节点的指针域*/
    struct dNode *next;  /*指向后继节点的指针域*/
}*pDLinkNode, *DLinkList;

双链表节点结构如下图示：

 

双链表节点比单链表多一个前驱指针域。

【2】C语言版双链表

1、无环双链表。实现部分代码如下：

// C语言实现无环双链表
#include <stdio.h>
#include <memory.h>
#include <assert.h>
#include <stdlib.h>

// 循环双链表的节点结构
typedef struct DOUBLE_LINK_NODE
{  
    int data;  // 数据域
    struct DOUBLE_LINK_NODE* prev;  // 前向指针域  
    struct DOUBLE_LINK_NODE* next;  // 后向指针域
} DLINK_NODE;

// 创建双链表的节点
DLINK_NODE* create_link_node(int value)
{  
    DLINK_NODE* pDLinkNode = NULL;
    pDLinkNode = (DLINK_NODE*)malloc(sizeof(DLINK_NODE));
    assert(NULL != pDLinkNode);
    memset(pDLinkNode, 0, sizeof(DLINK_NODE));
    pDLinkNode->data = value;
    return pDLinkNode;
}  

// 递归删除双链表的所有节点（包括头节点）
void delete_all_link_node(DLINK_NODE** pDLinkNode)  
{  
    DLINK_NODE* pNode = NULL;  
    if (NULL == *pDLinkNode)  
        return;  
  
    pNode = *pDLinkNode;  
    *pDLinkNode = pNode->next;
    free(pNode);

    delete_all_link_node(pDLinkNode);  
}  

// 在双链表中查询数据
DLINK_NODE* find_data_in_link(const DLINK_NODE* pDLinkNode, int data)  
{  
    DLINK_NODE* pNode = NULL;  
    if (NULL == pDLinkNode)  
        return NULL;  
  
    pNode = (DLINK_NODE*)pDLinkNode;
    while (NULL != pNode)
    {  
        if (data == pNode->data)  
            return pNode;

        pNode = pNode ->next;  
    }  
      
    return NULL;
}  

// 向双链表中添加数据
bool add_data_into_link(DLINK_NODE** ppDLinkNode, int data)  
{  
    DLINK_NODE* pNode = NULL;
    DLINK_NODE* pIndex = NULL;  
  
    if (NULL == ppDLinkNode)  
        return false;  
  
    if (NULL == *ppDLinkNode)
    {
        pNode = create_link_node(data);  
        assert(NULL != pNode);  
        *ppDLinkNode = pNode;  
        (*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;  
        return true;  
    }  
  
    if (NULL != find_data_in_link(*ppDLinkNode, data))  
        return false;  
  
    pNode = create_link_node(data);  
    assert(NULL != pNode);

    pIndex = *ppDLinkNode;  
    while (NULL != pIndex->next)  
        pIndex = pIndex->next;

    pNode->prev = pIndex;
    pNode->next = pIndex->next;
    pIndex->next = pNode;  
    return true;  
}  

// 从双链表中删除数据
bool delete_data_from_link(DLINK_NODE** ppDLinkNode, int data)  
{  
    DLINK_NODE* pNode = NULL;
    if (NULL == ppDLinkNode || NULL == *ppDLinkNode)
        return false;
  
    pNode = find_data_in_link(*ppDLinkNode, data); 
    if (NULL == pNode)
        return false;
  
    if (pNode == *ppDLinkNode)
    {
        if (NULL == (*ppDLinkNode)->next)
        {  
            *ppDLinkNode = NULL;
        }
        else
        {  
            *ppDLinkNode = pNode->next;
            (*ppDLinkNode)->prev = NULL;
        }
    }
    else
    {
        if (pNode->next != NULL)
        {
            pNode->next->prev = pNode->prev;
        }
        pNode->prev->next = pNode->next;
    }  
  
    free(pNode);
    return true;
}  

// 统计链表中数据个数
int count_number_in_link(const DLINK_NODE* pDLinkNode)  
{  
    int count = 0;  
    DLINK_NODE* pNode = (DLINK_NODE*)pDLinkNode;  
  
    while (NULL != pNode)
    {  
        if (pNode->data != -1)  // 头节点除外
        {
            ++count;  
        }
        pNode = pNode->next;
    }

    return count;
}  

// 打印双链表中数据
void print_link_node(const DLINK_NODE* pDLinkNode)  
{  
    printf("打印元素：
");
    DLINK_NODE* pNode = (DLINK_NODE*)pDLinkNode;  
  
    while (NULL != pNode)
    {
        if (pNode->data != -1)
        {
            printf("%d ", pNode->data);
        }
        pNode = pNode ->next;
    }  

    printf("
");
}  

void main()
{
    printf("测试无环有头双链表效果：
");
    DLINK_NODE* pHeadNode = NULL;
    add_data_into_link(&pHeadNode, -1);  // 头节点
    int nItems[10] = {12, 23, 34, 45, 56, 67, 78, 89, 99, 100};
    for (int i = 0; i < 10; ++i)
    {
        if (!add_data_into_link(&pHeadNode, nItems[i]))
        {
            break;
        }
    }

    int nCount = count_number_in_link(pHeadNode);
    printf("无环有头双链表元素个数：%d 
", nCount);

    print_link_node(pHeadNode);

    delete_data_from_link(&pHeadNode, 56);
    printf("删除56后
");
    print_link_node(pHeadNode);

    delete_all_link_node(&pHeadNode);
    printf("删除所有节点后");
    print_link_node(pHeadNode);

    printf("测试无环无头双链表效果：
");
    DLINK_NODE* pNode = NULL;
    int nItems2[10] = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
    for (int i = 0; i < 10; ++i)
    {
        if (!add_data_into_link(&pNode, nItems2[i]))
        {
            break;
        }
    }

    int nNoHeadCount = count_number_in_link(pNode);
    printf("无环无头双链表元素个数：%d 
", nNoHeadCount);

    print_link_node(pNode);

    delete_data_from_link(&pNode, 55);
    printf("删除55后
");
    print_link_node(pNode);

    delete_data_from_link(&pNode, 11);
    printf("删除11后
");
    print_link_node(pNode);

    delete_data_from_link(&pNode, 100);
    printf("删除100后
");
    print_link_node(pNode);

    delete_all_link_node(&pNode);
    printf("删除所有节点后");
    print_link_node(pNode);

    system("pause");
}

// run out
/*
测试无环有头双链表效果：
无环有头双链表元素个数：10
打印元素：
12 23 34 45 56 67 78 89 99 100
删除56后
打印元素：
12 23 34 45 67 78 89 99 100
删除所有节点后打印元素：

测试无环无头双链表效果：
无环无头双链表元素个数：10
打印元素：
11 22 33 44 55 66 77 88 99 100
删除55后
打印元素：
11 22 33 44 66 77 88 99 100
删除11后
打印元素：
22 33 44 66 77 88 99 100
删除100后
打印元素：
22 33 44 66 77 88 99
删除所有节点后打印元素：

请按任意键继续. . .
*/

2、循环双链表。实现部分代码如下：

// C语言实现循环双链表
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <assert.h>

typedef int Elemtype;
 
// 双链表节点结构定义
typedef struct dNode 
{
    Elemtype data; /*数据域*/
    struct dNode *prev;  /*指向前驱节点的指针域*/
    struct dNode *next;  /*指向后继节点的指针域*/
}*pDLinkNode, *DLinkList;
 
// 有头节点的空循环双链表
DLinkList GetEmptyDLink() 
{
    DLinkList head = (pDLinkNode)malloc(sizeof(struct dNode));
    head->data = 0;
    head->prev = head;
    head->next = head;
    return head;
}

// 由用户输入数据建立循环双链表
void DLink_create(DLinkList head, int n) 
{
    pDLinkNode p = head, r = head;
    for (int i = 0; i < n; ++i) 
    {
        p->next = (pDLinkNode)malloc(sizeof(dNode));/*为一个新节点分配空间*/
        scanf("%d", &p->next->data); /*从键盘输入值，并保存在新节点数据域中*/
        p = p->next; // p指向新节点
        p->prev = r;// 新节点的prev指向上一个节点
        r = p; // 上一个节点前进到新节点
    }
    p->next = head; // 指向头节点
    head->prev = p; // head的prev指向最后的节点
}

// 由数组创建双链表
void DLink_createByArray(DLinkList head, int* arrName, int n) 
{
    pDLinkNode p = head, r = head;
    for (int i = 0; i < n; ++i)
    {
        p->next = (pDLinkNode)malloc(sizeof(dNode));/*为一个新节点分配空间*/
        assert(NULL != p->next);
        p->next->data = arrName[i]; /*数据域*/
        p = p->next; /*p指向新节点*/
        p->prev = r; /*新节点的前驱指针域prev指向上一个节点*/
        r = p;       /*r保存新节点为下次添加做准备*/
    }
    // 处理循环条件
    p->next = head; /*最后节点的后驱指针域next指向头节点head*/
    head->prev = p; /*头结点head的前驱指针域prev指向最后节点*/
}

// 正向显示双链表数据
void Show(DLinkList head) 
{ 
    pDLinkNode p = head->next;
    while (p != head) 
    {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("
");
}

// 反向显示双链表数据
void ShowR(DLinkList head) 
{
    pDLinkNode p = head->prev;
    while (p != head) 
    {
        printf("%d ",p->data);
        p = p->prev;
    }
    printf("
");
}
 
// 删除循环双链表所有数据节点
void FreeList(DLinkList head) 
{ 
    pDLinkNode p = head->next;
    while (p != head) 
    {
        pDLinkNode pTemp = p;
        p = p->next;
        free(pTemp);
    }

    head->prev = head->next = head;
}

// 循环双链表中查找数据
pDLinkNode Find(DLinkList head, int nData)
{
    if (NULL == head || NULL == head->next)
        return NULL;

    pDLinkNode p = head->next;
    while (p != head) 
    {
        if (nData == p->data)
            return p;
        p = p->next;
    }

    return NULL;
}

// 从循环双链表中删除数据
void DeleteListData(DLinkList head, int nValue)
{
    if (NULL == head || NULL == head->next)
        return;

    pDLinkNode pNode = Find(head, nValue);
    if (NULL != pNode)
    {
        pNode->next->prev = pNode->prev;
        pNode->prev->next = pNode->next;
        free(pNode);
        pNode = NULL;
    }
}

// 在循环双链表中插入一个数据
void InsertListData(pDLinkNode pNode, int nValue)
{
    pDLinkNode pNewNode = (pDLinkNode)malloc(sizeof(dNode));
    assert(NULL != pNewNode);
    pNewNode->data = nValue;
    pNewNode->prev = pNode;
    pNewNode->next = pNode->next;
    pNode->next->prev = pNewNode;
    pNode->next = pNewNode;
}

void main() 
{
    printf("请输入10个整型数据：
");
    DLinkList head = GetEmptyDLink();
    DLink_create(head, 10);
    printf("输入数据创建双链表后，正向显示:
");
    Show(head);
    printf("反向显示:
");
    ShowR(head);

    printf("
由数组创建双链表：
");
    int nArray[10] = {12, 23, 34, 45, 56, 67, 78, 89, 99, 100};
    DLinkList head2 = GetEmptyDLink();
    DLink_createByArray(head2, nArray, 10);
    printf("正向显示:
");
    Show(head2);
    printf("反向显示:
");
    ShowR(head2);

    printf("删除45后，正向显示:
");
    DeleteListData(head2, 45);
    Show(head2);

    printf("插入666、888后，正向显示:
");
    InsertListData(head2, 666);
    InsertListData(head2, 888);
    Show(head2);

    printf("数据释放后，正向显示:
");
    FreeList(head2);
    Show(head2);

    system("pause");
}
// run out
/*
请输入10个整型数据：
1
2
3
4
5
6
7
8
9
10
输入数据创建双链表后，正向显示:
1 2 3 4 5 6 7 8 9 10
反向显示:
10 9 8 7 6 5 4 3 2 1

由数组创建双链表：
正向显示:
12 23 34 45 56 67 78 89 99 100
反向显示:
100 99 89 78 67 56 45 34 23 12
删除45后，正向显示:
12 23 34 56 67 78 89 99 100
插入666、888后，正向显示:
888 666 12 23 34 56 67 78 89 99 100
数据释放后，正向显示:

请按任意键继续. . .
*/

注意：双链表循环与无环的区别。

【3】C++版双链表

1、循环双链表，实现部分功能函数代码如下：

#pragma once
#include <iostream>
#include <assert.h>

template<class _Ty> class Iterator;
template<class _Ty> class List;

// 双链表节点结构
template<class _Ty>
class Node
{
    friend class List<_Ty>;
    friend class Iterator<_Ty>;
private:
    _Ty data;
    Node<_Ty>  *prev, *next;

public:
    typedef _Ty          value_type;
    typedef _Ty &        reference;
    typedef const _Ty &  const_reference;

public:
    Node(const _Ty &x=_Ty(),Node<_Ty> *p=NULL,Node<_Ty> *n=NULL);
    ~Node();

    reference Value();
    const_reference Value() const;

    Node<_Ty> *& Prev();
    Node<_Ty> * const & Prev() const;

    Node<_Ty> *& Next();
    Node<_Ty> * const & Next() const;
}; 

/////////////////////////////////////////////////////////////////
template<class _Ty>
Node<_Ty>::Node(const _Ty &x, Node<_Ty> *p, Node<_Ty> *n)
   : data(x)
   , prev(p)
   , next(n)
{}

template<class _Ty>
Node<_Ty>::~Node()
{}

template<class _Ty>
_Ty & Node<_Ty>::Value()
{
    return data;
}

template<class _Ty>
const _Ty &  Node<_Ty>::Value() const
{
    return data;
}

template<class _Ty>
Node<_Ty> *& Node<_Ty>::Prev()
{
    return prev;
}

template<class _Ty>
Node<_Ty> * const & Node<_Ty>::Prev() const
{
    return prev;
}
template<class _Ty>
Node<_Ty> * & Node<_Ty>::Next()
{
    return next;
}

template<class _Ty>
Node<_Ty> * const & Node<_Ty>::Next() const
{
    return next;
}

/////////////////////////////////////////////////////////////////
template<class _Ty>
class List
{
    friend class Iterator<_Ty>;
private:
    Node<_Ty>  *_Head;
    size_t     _Size;

    Node<_Ty> * Buynode(const _Ty& x = _Ty(), Node<_Ty>* p = NULL, Node<_Ty>* n = NULL)
    {
        Node<_Ty>* s = new Node<_Ty>(x);
        s->next = n == NULL ? s: n;
        s->prev = p == NULL ? s: p;
        return s;
    }

public:
    // 构造函数
    List():_Size(0), _Head(Buynode())    
    {}
    // 拷贝构造函数
    List(const List<_Ty> &Lt);
    // 赋值函数
    List<_Ty> & operator=(const List<_Ty> &Lt);
    // 析构函数    
    ~List(){}
/*****************************************
*函数名：size
*参数：void
*返回值类型：size_t
*功能：求双链表的长度
*实现思想：return _Size
*******************************************/
size_t  size() const 
{ 
    return _Size;
}
/********************************************
*函数名：empty
*参数：void
*返回值类型：bool
*功能：判空
*实现思想：_Size == 0
********************************************/  
bool empty() const
{ 
    return 0 == _Size;
}
/*******************************************
*函数名：front
*参数：void
*返回值类型:_Ty &
*功能：返回双链表中第一个数值
*实现思想： 1> 判空
           2> 返回第一个节点的值
*******************************************/
_Ty & front()
{
    assert(!empty());
    return _Head->next->data;
}
// const方法
const _Ty & front() const 
{
    assert(!empty());
    return _Head->next->data;
}
/*******************************************
*函数名：back
*参数：void
*返回值类型：_Ty  &
*功能：返回双链表最后一个节点的值
*实现思想： 1> 判空
           2> 返回最后一个节点的值
*******************************************/
_Ty & back()
{
    assert(!empty());
    return _Head->prev->data;
}
// const
const _Ty & back() const 
{
    assert(!empty());
    return _Head->prev->data;
}
/*****************************************
*函数名：push_front
*参数：const _Ty& x
*返回值类型：void
*功能：在双链表最前面插入一个数值
*实现思想: 1> 构建节点
          2> 衔接节点
          3> 重定长度
*****************************************/
void push_front(const _Ty& x)
{
    Node<_Ty>* s = Buynode(x, _Head, _Head->next);
    _Head->next = s;
    s->next->prev = s; 
    ++_Size; 
}
/***************************************
*函数名：pop_front
*参数：void
*返回值类型：void
*功能：弹出双链表中最前面的一个数值
*实现思想： 1> 锁定（判空）第一个节点
           2> 移出节点
           3> 删除节点
           4> 重定长度
****************************************/
void pop_front()
{
    Node<_Ty>* s = _Head->next;
    if (s != NULL)
    {
        _Head->next = s->next;
        s->next->prev = _Head;
        delete s;
    }
    --_Size;
}
/**************************************
*函数名：push_back
*参数：const _Ty& x
*返回值类型：void
*功能：在双链表中的末尾插入一个数值
*实现思想： 1> 构建一个节点
           2> 衔接节点
           3> 重定长度
***************************************/
void push_back(const _Ty& x)
{
    Node<_Ty>* s = Buynode(x, _Head->prev, _Head);
    _Head->prev = s;
    s->prev->next = s;
    ++_Size;
}
/***************************************
*函数名：pop_back
*参数：void
*返回值类型：void
*功能：弹出双链表中的最后一个数值
*实现思想： 1> 锁定(判空)最后一个节点
           2> 移出节点
           3> 删除节点
           4> 重定长度
***************************************/
void pop_back()
{
    Node<_Ty>* s = _Head->prev;
    if (s != NULL)
    {
        _Head->prev = s->prev; 
        s->prev->next = _Head;
        delete s;
    }
    --_Size;

}
/**********************************************
*函数名：findvalue
*参数：const _Ty &x
*返回值类型：Node<_Ty> *
*功能：在双链表中找到某一个值的节点指针
*实现思想： 1> 初始化
           2> 循环定位
           3> 返回值
***********************************************/
Node<_Ty> * findvalue(const _Ty &x)
{
    Node<_Ty>* p = _Head->next;
    while (p != _Head && p->data != x) //防止重复循环
    {
        p = p->next;
    }
    return (p == _Head) ? NULL : p;
}
/******************************************
*函数名：prefindvalue
*参数：const _Ty &x
*返回值类型：Node<_Ty> *
*功能：在双链表中按值查找其节点前驱
*实现思想： 1> 初始化
           2> 循环定位
           3> 返回值
******************************************/
Node<_Ty> * prefindvalue(const _Ty &x)
{
    Node<_Ty>* r = findvalue(x);
    return (NULL == r) ? NULL : r->prev;
}
/*******************************************
*函数名：findpos
*参数：int pos
*返回值类型：Node<_Ty> *
*功能：在双链表中按位置求节点指针
*实现思想： 1> 无效pos
           2> 有效pos 循环初始化
           3> 循环定位
*******************************************/
Node<_Ty>* findpos(size_t pos)
{
    if (0 == pos) 
        return _Head;
    if (pos < 0 || pos >= _Size)
        return NULL;

    size_t j = 0;
    Node<_Ty>* p = _Head;
    while (j < pos)
    {
        ++j;
        p = p->next;
    }
    return p;
}
/*********************************************
*函数名：findpos
*参数：int  pos
*返回值类型：Node<_Ty> *
*功能：在双链表中按位置求节点指针
*实现思想： 1> 无效pos
           2> 有效pos ,循环初始化
           3> 循环定位
*********************************************/
/*
Node<_Ty>* findpos(int pos)
{
    if (pos < -1 || pos >= _Size) 
        return NULL;
    if (-1 == pos) 
        return _Head;

    int j = 0; 
    Node<_Ty>* p = _Head->next;
    while (j < pos) 
    {
        ++j;
        p = p->next;
    }
    return p;
}
*/
/********************************************
*函数名：insert
*参数：const int pos,const _Ty &x
*返回值类型：void
*功能：在双链表中的指定位置插入数值
*实现思想： 1> 锁定位置的前驱
           2> 构建节点
           3> 衔接节点
           4> 重定长度
********************************************/
void insert(const int pos, const _Ty &x)
{
    Node<_Ty>* p = findpos(pos - 1); // 前驱
    if (NULL == p)
        return;

    Node<_Ty>* s = Buynode(x, p, p->next);
    p->next = s;
    s->next->prev = s;
    ++_Size;
}
/*****************************************
*函数名：remove
*参数：const _Ty &x
*返回值类型：void
*功能：从单链表中删除某个值
*实现思想： 1> 按值锁定节点
           2> 移出节点
           3> 删除节点
           4> 重定长度
******************************************/
void remove(const _Ty &x)
{
    Node<_Ty>* p = findvalue(x);
    if (p != NULL)
    {
        p->prev->next = p->next;
        p->next->prev = p->prev;
        delete p;
        --_Size;
    }
}
/******************************************
*函数名：removeall
*参数：const _Ty &x
*返回值类型：void
*功能：删除双链表中所有出现的某一值
*实现思想： 1> 初始化
           2> 循环逐个判断
*******************************************/
void removeall(const _Ty &x)
{
    Node<_Ty>* p = prefindvalue(x);
    if (NULL == p)
      return;

    while (p->next != _Head)
    {
        if (p->next->data == x)
        {
            remove(x);
        }
        else
        {
            p = p->next;
        }
    }
}
/*********************************************
*函数名：erase
*参数：const int pos
*返回值类型：void
*功能：从双链表中按位置删除
*实现思想： 1> 锁定该位置的节点
           2> 移出节点
           3> 删除节点
           4> 重定长度
**********************************************/
void erase(const int pos)
{
    Node<_Ty>* p = findpos(pos);
    if (NULL != p && p != _Head)
    {
        p->prev->next = p->next;
        p->next->prev = p->prev;
        delete p;
        --_Size;
    }
}
/***********************************/
// 清空链表
void clear()
{
    _Head->next = _Head;
    _Head->prev = _Head;
}
/***********************************
*函数名：sort
*参数：void
*返回值类型：void
*功能：对双链表中的值进行排序
*实现思想：快速排序
***********************************/
void sort()
{   
    Node<_Ty> *s = NULL, *p = NULL, *min = NULL;
    _Ty temp;
    s = _Head->next;
    while (s != _Head)
    {
        min = s;
        p = s->next;
        while (p != _Head)
        {
            if (min->data > p->data)
            {
                temp = min->data;
                min->data = p->data;
                p->data = temp;
            }
            p = p->next ;
        }
        s = s->next;
    }
}
/************************************
*函数名：print
*参数：void
*返回值类型：void
*功能：输出链表中每个结点数据
*实现思想：循环输出
************************************/
void print()
{
    Node<_Ty> *p = _Head->next;
    while (p != _Head)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
/************************************
*函数名：reverse
*参数：void
*返回值类型：void
*功能：重置链表数据
*实现思想：调换每个节点的prev和next
************************************/
void reverse()
{
    Node<_Ty> *r = NULL, *p = _Head;
    for (size_t i = 0; i <= _Size; ++i)
    {
        p = p->next;
        r = p->next;
        p->next = p->prev;
        p->prev = r;
    }
}
};
//////////////////////////////////////////////////////////////
template<class _Ty> class Iterator
{
private:
    List<_Ty> &list;
    Node<_Ty> *Ptr;
public:
    Iterator(List<_Ty> &Lt): list(Lt), Ptr(NULL)
    {}

    ~Iterator()
    {}

    void First()
    {
        Ptr = list._Head->next;
    }

    bool IsDone()  const
    {
        return Ptr == list._Head;
    }

    _Ty & operator*()
    {
        return Ptr->data;
    }

    _Ty * operator->()
    {
        return &(Ptr->data);
    }

    Iterator & operator++()
    {
        Ptr = Ptr->next;
        return *this;
    }

    Iterator & operator--()
    {
        Ptr = Ptr->prev;
        return *this;
    }
};

2、测试程序如下：

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

int sum(List<int> &Lt)
{
    Iterator<int> it(Lt);
    int ret = 0;
    it.First();
    while (!it.IsDone())
    {
        ret += *it;
        ++it;
    }
    return ret;
}

void main()
{
    List<int> mylist;
    int i = 0;
    for (i = 12; i > 0; --i)
    {
        mylist.push_back(i); // 方法1
    }
    cout << sum(mylist) <<endl;

    mylist.push_back(2);   // 方法1
    mylist.print();   // 方法2

    mylist.sort();    // 方法3
    mylist.print();

    mylist.reverse();   // 方法4
    mylist.print();
    
    mylist.insert(2, 30); // 方法5
    mylist.insert(4, 30);
    mylist.insert(5, 30);
    mylist.insert(8, 30);
    mylist.print();

    mylist.push_front(11); // 方法6
    mylist.print();

    mylist.remove(3); // 方法7
    mylist.print();
    
    mylist.removeall(30); // 方法8
    mylist.print();

    mylist.erase(7);// 方法9
    mylist.print();

    cout << mylist.size() << endl; // 方法10

    mylist.clear();   // 方法11
    mylist.print();
    system("pause");
}

// 备注：
// 数据结构双链表实现代码
// 整理于2013-11-27
// 双链表的节点结构为：前驱~数据~后驱 （三部分）
// 该双链表是有头结点的
// 该双链表的头结点索引为0，第一个数据节点为1，以此类推。
// 尤其注意findpos函数的pos为size_t类型
// 认真琢磨双链表的功能实现函数

循环双链表的应用很广，此例测试程序很简单。

【4】双链表的分类

1、不带头节点的循环非空双链表

2、带头节点的循环双链表

示例1：

示例2：

示例3：

示例4：

 

3、带头节点的无环双链表

示例1：

示例2：

 

4、无环与循环双链表的区别

5、双链表分类

6、各种表的对比图

【5】双链表中插入节点

（1）插入节点代码描述：

// 在循环双链表中插入一个数据
void InsertListData(pDLinkNode pNode, int nValue)
{
    pDLinkNode pNewNode = (pDLinkNode)malloc(sizeof(dNode));
    assert(NULL != pNewNode);

    pNewNode->data = nValue;
    pNewNode->prev = pNode;
    pNewNode->next = pNode->next;
    pNode->next->prev = pNewNode;
    pNode->next = pNewNode;
}

（2）思路分析：

步骤1、新节点的前驱

步骤2、新节点的后驱

步骤3、新节点后一个节点的前驱

步骤4、新节点前一个节点的后驱

（3）为了更形象的理解这个过程，搜集如下逻辑结构示意图：

图1：

图2：

图3：

图4：

图5：

图6：

【6】双链表中删除节点

（1）双链表删除节点代码：

// 从循环双链表中删除数据
void DeleteListData(DLinkList head, int nValue)
{
    if (NULL == head || NULL == head->next)
        return;

    pDLinkNode pNode = Find(head, nValue);
    if (NULL != pNode)
    {
        pNode->next->prev = pNode->prev;
        pNode->prev->next = pNode->next;
        free(pNode);
        pNode = NULL;
    }
}

（2）删除节点的思路分析：

步骤1、找到即将被删除的节点 pNode

步骤2、将 pNode 的后继的前驱指向 pNode 的前驱，即 pNode->next->prev = pNode->prev;

步骤3、将 pNode 的前驱的后继指向 pNode 的后继，即 pNode->prev->next = pNode->next;

步骤4、删除节点 pNode, 即 free(pNode);

（3）为了更形象的理解这个过程，搜集如下逻辑结构示意图：

图1：

图2：

图3：

图4：

图5：

图6：

【7】单链表与双链表的区别

单链表: 结构简单，存储空间小，但是只能向前访问节点，如果需要访问之前的节点，需要建立循环链表。
双链表: 存储前一节点和后一节点地址，可以自由访问各个节点，存储空间比单链要大。

 

Good  Good  Study,  Day  Day  Up.

顺序  选择  循环  总结