54. 实现对 有头双向链表的基本操作 创建，插入，查找，删除，遍历，排序，销毁

#include <stdio.h>
#include <stdlib.h>

typedef struct _dnode
{
    int data;
    struct _dnode *pre;
    struct _dnode *next;
}Dnode;

//创建空链表     //让头结点指向自己，方便以后的操作。
int createDlist(Dnode** head)
{
    *head = (Dnode*)malloc(sizeof(Dnode));
    if(head == NULL)
        return -1;
    (*head)->next = *head;
    (*head)->pre = *head;
    return 0;
}

//插入新节点，头插
//创建链表时让头结点指向自己目的是 :
//功能上不只为一层。为了让多层同样式代码通用化。比如方便实现插入的功能代码。循环要写成通用形式比较难。所以在创建链表时让头节点指向自己，这样可以让空链表状态的插入的功能代码与有节点链表状态的插入的 功能代码一样。
void insertDlist(Dnode *head,int data)
{

    Dnode *newNode = (Dnode*)malloc(sizeof(Dnode));
    newNode->data = data;

    /*插入三步曲，*/
    //先处理新节点指向 ,连上左右两边的节点
    newNode->next = head->next;
    newNode->pre = head;

    head->next = newNode;//再处理左节点指向,连上新节点
    newNode->next->pre = newNode;//再处理右节点，连上新节点
}

//求链表长度
int getLenDlist(Dnode* head)
{
    Dnode* cur = head->next;
    int len = 0;
    while(cur != head)
    {
        len++;
        cur = cur->next;
    }
    return len;
}

//查找
//单向查找
Dnode* searchDlist(Dnode* head,int find)
{
    Dnode* cur = head->next;
    while(cur != head)
    {
        if(cur->data == find)
            return cur;
    }
    return NULL;
}


//双向查找
/*分别从两头往中找，结束时可能会遇见两种情况
情况1 碰头了之后再判断一次，如果仍没找到，停止 。找到直接返回
情况2 交错之后，如果仍没找到，停止。



实现循环中的代码的通用性，就这三条路
实现方式1   让情况1为主包含情况2     无法实现
实现方式2   让情况2为主包含情况1      可以实现   逻辑是 擦肩而过之前一定会相遇
实现方式3   同时包含情况1情况2 ，两种情况平行       使用while(1)把这个也实现下
（把这个实现循环通用化的思想好好总结一下，感觉特别重要，常常会遇见写循环时需要实现有多种情况通用化的合体代码）
*/

//实现方式2
Dnode* searchDlist2(Dnode* head,int find)
{
    Dnode* clock = head->next;
    Dnode* unclock = head->pre;

    while(clock != unclock->next)//也可以while(unclock != clock->pre) //以情况2为主
    {
        if(clock->data == find)
            return clock;
        if(unclock->data == find)
            return unclock;

        if(clock == unclock)//以情况1为次
            break;

        clock = clock->next;
        unclock = unclock->pre;
    }
    return NULL;
}
//实现方式3    //感觉不对劲，虽然测对了
Dnode* searchDlist3(Dnode* head,int find)
{
    Dnode* clock = head->next;
    Dnode* unclock = head->pre;

    while(1)
    {
        if(clock->data == find)
            return clock;
        if(unclock->data == find)
            return unclock;

        if(clock == unclock || clock == unclock->next)
            break;


        clock = clock->next;
        unclock = unclock->pre;
    }
    return NULL;

}

//删除
//不用像单链表那样找前驱了，双链表可以直接访问到前驱。
void deleteDlistNode(Dnode *deleteNode)
{
    deleteNode->pre->next = deleteNode->next;
    deleteNode->next->pre = deleteNode->pre;
    free(deleteNode);

}

//销毁   //包括头结点一起销毁，另需将头指针指向NULL
//方式1
void destroyDlist1(Dnode** head)
{
    Dnode* cur = (*head)->next;
    while(cur != *head)
    {
        Dnode* temp = cur;
        cur = cur->next;
        free(temp);
    }
    free(*head);
    *head = NULL;
}
//方式2，先把双向链表废成单向链表，再一一删除
void destroyDlist2(Dnode** head)
{
    (*head)->pre->next = NULL;
    while(*head)//遍历完后*head==NULL
    {
        Dnode* temp = *head;
        *head = (*head)->next;
        free(temp);
    }
}

//排序


//对数据域进行交换
//用冒泡排序实现
void bubbleSortDlistData(Dnode* head)
{
    int len = getLenDlist(head);
    Dnode* pcur = head;
    Dnode* pnext;
    int i,j;
    for(i = 0; i < len-1;i++)
    {
        pcur = head->next;
        pnext = pcur->next;
        for(j = 0;j<len-1-i;j++)
        {

            if(pcur->data > pnext->data)
            {
                pcur->data ^= pnext->data;
                pnext->data ^= pcur->data;
                pcur->data ^= pnext->data;
            }

            pcur = pcur->next;
            pnext = pcur->next;
        }
    }
}

//用选择排序实现
void selectSortDlistData(Dnode* head)//升序
{
    int len = getLenDlist(head);
    Dnode* pcur;
    Dnode* pnext;

    for(pcur = head->next; pcur->next != head ;pcur = pcur->next)
    {
        for(pnext = pcur->next;pnext != head;pnext = pnext->next)
        {
            if(pcur->data > pnext->data)
            {
                pcur->data ^= pnext->data;
                pnext->data ^= pcur->data;
                pcur->data ^= pnext->data;
            }
        }
    }


}


//对指针域进行交换
//不再像单链表那样专门记录前驱节点地址，因为有pre成员


//使用冒泡排序实现
void bubbleSortDlistPointer(Dnode* head)//升序
{
    int len = getLenDlist(head);
    Dnode* pcur;
    Dnode* pnext;

    int i,j;
    for(i = 0;i<len-1;i++)
    {
        pcur = head->next;
        pnext = pcur->next;
        for(j=0;j<len-1-i;j++)
        {
            if(pcur->data > pnext->data)
            {
                pcur->pre->next = pnext;
                pnext->pre = pcur->pre;

                pcur->next = pnext->next;
                pnext->next->pre = pnext;

                pnext->next = pcur;
                pcur->pre = pnext;



                pcur = pcur->pre;
            }
            pcur = pcur->next;
            pnext = pcur->next;
        }
    }
}


//使用选择排序实现
//待补

//遍历

//遍历节点，向前
void traverseDlistNext(Dnode* head)
{
    Dnode* phead = head->next;
    while(phead != head)
    {
        printf("%d ",phead->data);
        phead = phead->next;
    }
    putchar(10);
}

//遍历节点，向后
void traverseDlistPre(Dnode* head)
{
    Dnode* phead = head->pre;
    while(phead != head)
    {
        printf("%d ",phead->data);
        phead = phead->pre;
    }
    putchar(10);
}