一.双链表的引入和基本实现

1.双链表的结构

首先，我们要明白双链表并不是有两条链的链表，而是有两个遍历方向的链表，因此我们所说的双链表其实就是双向链表的简称。

2.有效数据+2个指针的节点（双链表）

(1)单链表的节点 = 有效数据 + 指针（指针指向后一个节点）

(2)双向链表的节点 = 有效数据 + 2个指针（一个指向后一个节点，另一个指向前一个节点）

(3)双链表的结构图如下：

==可以看出，图中的每一个节点都有一个有效数据和两个指针（前向指针pPrev和后向指针pNext）,分别指向该节点的前一个节点和后一个节点。头结点的pPrev和尾节点的pNext都指向NULL==

3.创建一个双链表节点的实现

根据上面的双链表的结构图，再结合前面学习的单链表，创建双链表的节点无疑依葫芦画瓢！

①.实现一个链表的首要任务就是构造节点，在c语言中构构造节点的方法就是定义一个结构体：

// 构建一个双链表的节点
struct node
{
    int data;               // 有效数据
    struct node *pPrev;     //指向上一个节点的指针
    struct node *pNext;     // 指向下一个节点的指针
};

②.使用堆内存创建一个节点

因为链表的内存要求比较灵活，不能用栈，也不能用data数据段。只能用堆内存
创建节点的过程：

①申请一个节点大小的堆内存

②检查堆内存是否申请成功

③清理申请到的堆内存

④填充节点中的数据

⑤节点中的两个指针域初始化为NULL；

4.代码的具体实现

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
    struct node *p = (struct node *)malloc(sizeof(struct node));
    if (NULL == p)
    {
        printf("malloc error.\n");
        return NULL;
    }
    // 清理申请到的堆内存
    bzero(p, sizeof(struct node));
    // 填充节点
    p->data = data;
    p->pPrev = NULL;//默认创建的节点的前向后向指针都指向NULL
    p->pNext = NULL;    

    return p;
}

二.双链表的算法之插入节点

1.尾部插入方式

==和单链表的插入方式基本一样，所以，对单链表的插入 遍历 删除 掌握ok,这里分析起来是很简单的。==

①.直接上手尾插入节点的链表分析图

尾部插入节点的任务分析：
==思路：将从链表尾部插入节点的任务分为两步：==

1.1.第一步.找到链表的尾节点

1.2.第二步.将新节点接到链表的尾节点后面成为新的尾节点

①.原来的尾节点的pNext指针指向新节点的首地址

②.新节点的pPrev指针指向原来的尾节点的首地址

1.3代码实现

// 将新节点new插入到链表pH的尾部
void insert_tail(struct node *pH, struct node *new)
{
    // 第一步先走到链表的尾节点
    struct node *p = pH;
    while (NULL != p->pNext)
    {
        p = p->pNext;           // 第一次循环走过了头节点
    }
    // 循环结束后p就指向了原来的最后一个节点
    // 第二步：将新节点插入到原来的尾节点的后面
    p->pNext = new;             // 后向指针关联好了。新节点的地址和前节点的next
    new->pPrev = p;             // 前向指针关联好了。新节点的prev和前节点的地址
                                // 前节点的prev和新节点的next指针未变动
}

/**************双链表插入节点***********************/
int main(void)
{
    struct node *pHeader = create_node(0);      // 头指针

    insert_tail(pHeader, create_node(11));//尾巴插入双链表节点
    insert_tail(pHeader, create_node(12));//尾巴插入双链表节点
    insert_tail(pHeader, create_node(13));//尾巴插入双链表节点

    // 遍历
    printf("node 1 data: %d.\n", pHeader->pNext->data);//通过pNext指针访问每个节点
    printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
    printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

    struct node *p = pHeader->pNext->pNext->pNext;      // p指向了最后一个节点
    printf("node 3 data: %d.\n", p->data);//通过pPrev指针逆向访问每个节点
    printf("node 2 data: %d.\n", p->pPrev->data);
    printf("node 1 data: %d.\n", p->pPrev->pPrev->data);

    return 0;
}
}

2.头部插入方式

2.1.头结点插入的重要四个步骤：

①.新节点的pNext指向原来的第一个节点的首地址，即图中的新节点pNext和原来的第一个节点的首地址相连

②.原来第1个有效节点的prev指针指向新节点的首地址

③.头节点的pNext指针指向新节点的首地址

④.头节点的pNext指向新节点的首地址，即图中头结点的首地址和新节点的pPrev相连

2.2.思考:四个步骤①②③④是否可以交换一下顺序？（可参考单链表头部插入）

==答案显然是不能的，因为由上图可知，如果交换①和③的步骤，③是可以完成的，但是执行步骤①时就会发现，原来的第一个有效节点的地址已经丢失了，由图中知道，我们原来第一个节点的首地址是在头结点的pNext指针中保存的，因为先执行了步骤③，故原来第一个节点的有效地址丢失了。且②必须放在①③中间，具体原因和上面一致。==

2.3.代码实现

// 将新节点new前头插入链表pH中。
// 算法参照图示进行连接，一共有4个指针需要赋值。注意的是顺序。
void insert_head(struct node *pH, struct node *new)
{
    // 新节点的next指针指向原来的第1个有效节点的地址
    new->pNext = pH->pNext;

    // 原来第1个有效节点的prev指针指向新节点的地址
    if (NULL != pH->pNext)
    //因为当只有头结点和头指针时，即ph->pNext=NULL;
   // 而pH->pNext->pPrev，则会报段错误
        pH->pNext->pPrev = new;

    // 头节点的next指针指向新节点地址
    pH->pNext = new;

    // 新节点的prev指针指向头节点的地址
    new->pPrev = pH;
}

需要注意的是，第二步中，当链表如果只有一个头结点，即没有有效节点时，

②.原来第1个有效节点的prev指针指向新节点的首地址

这个步骤则会报段错误，因为当只有头结点和头指针时，即ph->pNext=NULL;而pH->pNext->pPrev，则会报段错误

==故解决方法就是添加这条if (NULL != pH->pNext)语句，判断是否为链表头结点，如果是，则不做任何操作。==

三.双链表的算法之遍历节点

==(1)双链表是单链表的一个父集。双链表中如何完全无视pPrev指针，则双链表就变成了单链表。这就决定了双链表的正向遍历（后向遍历）和单链表是完全相同的。==

==(2)双链表中因为多了pPrev指针，因此双链表还可以前向遍历（从链表的尾节点向前面依次遍历直到头节点）。但是前向遍历的意义并不大，主要是因为很少有当前当了尾节点需要前向遍历的情况。==

1.正向遍历

1.1因为正向遍历和单链表的过程相同，这里不再赘述。

遍历方法：==从头指针+头节点开始，顺着链表挂接指针依次访问链表的各个节点，取出这个节点的数据，然后再往下一个节点，直到最后一个节点，结束返回。==

1.2正向遍历双链表遍历节点过程分析图(cp的单链表分析)

1.3代码实现

//正向遍历(后向遍历)双链表，ph为指向单链表的头指针，将遍历的节点数据打印出来
void bianli(struct node *ph)
{
    struct node *p=ph; //头指针的后面是头节点
    printf("---------正向遍历----------\n");
    printf("---------start----------\n");
    while(NULL!=p->pNext)// 是不是最后一个节点
    {
        p=p->pNext;// 走到下一个节点，也就是循环增量
        printf("node data: %d.\n",p->data);
    }
    printf("------------end----------\n");
}

2.反向遍历

==反向遍历节点(即从尾节点开始前向遍历)的逻辑和正向遍历差不多，通过p=p->pPrev来向前移动，依次访问节点。==

//反向遍历(前向遍历)双链表，ph为指向单链表的头指针，将遍历的节点数据打印出来
void fanxiang_bianli(struct node *pTail)
{
    struct node *p=pTail; //头指针的后面是头节点
    printf("---------反向遍历----------\n");
    printf("---------start----------\n");
    while(NULL!=p->pPrev)// 是不是最后一个节点
    {
        printf("node data: %d.\n",p->data);/*若printf与下面交换程序，则把尾节点的数据舍弃了，并没有打印出来，所以，遍历节点一定的注意顺序！*/
        p=p->pPrev;// 走到下一个节点，也就是循环增量

    }
    printf("------------end----------\n");
}

/**************双链表之遍历节点***********************/
int main(void)
{
    struct node *pHeader = create_node(0);      // 头指针

    insert_tail(pHeader, create_node(11));//尾插入双链表节点
    insert_tail(pHeader, create_node(12));//尾插入双链表节点
    insert_tail(pHeader, create_node(13));//尾插入双链表节点


    bianli(pHeader);//正向遍历双链表
    struct node *p=pHeader->pNext->pNext->pNext;//p指向最后一个节点
    fanxiang_bianli(p);//反向遍历双链表

    /*// 手动遍历
    printf("node 1 data: %d.\n", pHeader->pNext->data);//通过pNext指针访问每个节点
    printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
    printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

    struct node *p = pHeader->pNext->pNext->pNext;      // p指向了最后一个节点
    printf("node 3 data: %d.\n", p->data);//通过pPrev指针逆向访问每个节点
    printf("node 2 data: %d.\n", p->pPrev->data);
    printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
    */
    return 0;
}

四.双链表的算法之删除节点

1.为什么要删除节点？

(1)一直在强调，链表到底用来干嘛的？==用来存储数据==

(2)有时候链表节点中的数据不想要了，因此要删掉这个节点。

2、删除节点的2个步骤

(1)第一步：找到要删除的节点；第二步：删除这个节点。

3、如何找到待删除的节点

(1)通过遍历来查找节点。从头指针+头节点开始，顺着链表依次将各个节点拿
出来，按照一定的方法比对，找到我们要删除的那个节点。

4、如何删除一个节点（分两种情况）(这里就和单链表不同)

(1)待删除的节点是尾节点的情况:

==这种情况要删除节点2就需要断开①.②.这两条指针的链接，然后释放free(p)==

步骤1.首先把把待删除的尾节点的前一个节点的pNext指针存放的待删除尾节点的首地址清除，然后把待删除的尾节点的前一个节点的pNext指针指向null（这时候就相当于原来尾节点前面的一个节点变成了新的尾节点），即图中①

步骤2.然后再将待删除尾节点的pPrev指针存放的上一个节点的地址断开链接，即图②

步骤3.最后再将这个摘出来的节点free掉即可。。 (因为最终是要释放尾节点的，所以，第②步可以省略)

==p表示当前节点地址，p->pNext表示后一个节点地址，p->pPrev表示前一个节点的地址

故步骤①表示为：p->pPrev->pNext = NULL;

步骤②表示为p->pPrev = NULL;

(2)待删除的节点不是尾节点的情况：

==这种情况要删除节点1就需要断开①.②.③.④这四条指针的链接，然后释放free(p)==

步骤如下：

步骤①.首先把待删除节点的前一个节点的pNext指针指向待删除节点的后一个节点的首地址（这样就把这个节点从链表中摘出来了），

步骤②.当前待删除的节点的prev和next指针置为NULL，但这里可以不用管，因为后面会整体销毁整个节点

步骤③.待删除节点的后一个节点的prev指针指向待删除节点的前一个节点的首地址

步骤④.最后再将这个摘出来的节点free掉即可。(因为最终是要释放尾节点的，所以，第②步可以省略)

==p表示当前节点地址，p->pNext表示后一个节点地址，p->pPrev表示前一个节点的地址==

故步骤①为前一个节点的next指针指向后一个节点的首地址

表示为：==p->pPrev->pNext = p->pNext;==

步骤②.③当前待删除的节点的prev和next指针置为NULL

==p->pPrev = NULL;==

==p->pNext = NULL;==

步骤④为后一个节点的prev指针指向前一个节点的首地址

表示为==p->pNext->pPrev = p->pPrev;==

==和待删除的节点是尾节点同样，最终都要释放free(p)，所以第②步和第③步可以省略。==

5、设计一个删除节点的算法

(1)删除节点的算法流程框图如下

(2)总结总体步骤如下：

①通过遍历链表来寻找需要删除的节点

②找到该节点又分为两种情况：一个是非尾节点，另一个是尾节点

③通过上面描述的待删除的节点不同处理方法处理：

6.代码实现

// 从双链表pH中删除节点，待删除的节点的特征是数据区等于data
// 返回值：当找到并且成功删除了节点则返回0，当未找到节点时返回-1
//struct node *ph：头指针
//int data：待删除节点的有效数据
int delete_node(struct node *ph,int data)
{
    struct node *p=ph; //头指针的后面是头节点
    printf("---------start----------\n");
    if(NULL==p)//这是为了防止没有头结点，报段错误
    {
        return -1;
    }
    while(NULL!=p->pNext)// 通过遍历节点，判断是不是尾节点
    {
        //p->pNext表示下一个节点的地址，即走到下一个节点
        p=p->pNext;

        //判断这个节点是否为我们要删除的节点
        if(p->data==data)
        {
            //处理找到的节点，分为两种情况
            if(NULL==p->pNext)//待删除的节点如果为尾节点，执行如下
            {
            //p表示当前节点地址，p->pNext表示后一个节点地址，
            //p->pPrev表示前一个节点的地址
            //把把待删除的尾节点的前一个节点的pNext指针存放的待删除尾节点的首地址清除，然后把待删除的尾节点的前一个节点的pNext指针指向null
                p->pPrev->pNext = NULL;

                //p->pPrev = NULL;//待删除的尾节点的前一个节点的pPrev指针指向null
                //这里可以省略这部，因为下面整个待删除节点都被销毁了

                free(p);//释放待删除的尾节点的内存
            }
            else  //待删除的节点如果为非尾节点，即普通节点，执行如下
            {
                // 待删除的节点的前一个节点的next
                //指针指向待删除的节点的后一个节点的首地址
                p->pPrev->pNext = p->pNext;

                // 当前节点的prev和next指针都不用管，因为后面会整体销毁整个节点

                p->pNext->pPrev = p->pPrev;//待删除的节点的后一个节点的prev指针指向前一个节点的首地址
                free(p);//释放待删除的尾节点的内存
            }   
            printf("------------end----------\n");
            return 0;//成功删除该节点，退出程序返回0
        }

    }   
    printf("-----------没有找到该待删除的节点----------\n");
    return -1;
}

/**************双链表之删除节点***********************/
int main(void)
{
    struct node *pHeader = create_node(0);      // 头指针

    insert_tail(pHeader, create_node(11));//尾插入双链表节点
    insert_tail(pHeader, create_node(12));//尾插入双链表节点
    insert_tail(pHeader, create_node(13));//尾插入双链表节点


    bianli(pHeader);//正向遍历双链表

    delete_node(pHeader, 12);//从链表pH中删除数据为33的节点
    printf("------------------删除该节点后-------------\n");  

    //再次正向遍历双链表各个节点的有效数据
    bianli(pHeader);

    /*// 手动遍历
    printf("node 1 data: %d.\n", pHeader->pNext->data);//通过pNext指针访问每个节点
    printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
    printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

    struct node *p = pHeader->pNext->pNext->pNext;      // p指向了最后一个节点
    printf("node 3 data: %d.\n", p->data);//通过pPrev指针逆向访问每个节点
    printf("node 2 data: %d.\n", p->pPrev->data);
    printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
    */
    return 0;
}