1.引子

假如已經從A走到E了， 現在要求從E走到D,用時最短怎么辦？
傳統的循環鏈表只是從A->E->A->D, 但是現在明明可以只要E回退一步就到了D,何必那么麻煩呢  
這就需要用到一個指針 告訴E下一步需要走到D， 這個指針就是前驅指針.
也就引入了今天要介紹的雙向鏈表

雙向鏈表是在單鏈表的每個結點中，再設置一個指向其前驅結點的指針。

雙向鏈表

2.代碼

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;

typedef int ElementType;
typedef struct node {
    ElementType data;
    struct node *prior,*next;
} Node, *DoubleLinkList;


void InitDLLinkList(DoubleLinkList *list) {
    *list = (DoubleLinkList)malloc(sizeof(Node));
    (*list)->next = NULL;
    (*list)->prior = NULL;
}


void createDLinkList(DoubleLinkList list, int n) {
    DoubleLinkList p;
    p = list;
    for (int i = 1; i <= n; i++) {
        DoubleLinkList tempNode = (DoubleLinkList)malloc(sizeof(Node));
        tempNode->data = i;
        //將新結點的next和pror指針 與先后結點都建立關系
        p->next = tempNode;
        tempNode->prior = p;
        p = tempNode;
    }
    //將最后一個結點的next指向鏈表的頭部， 并將鏈表的前驅指針指向最后一個指針 形成雙向循環鏈表
    p->next = list;
    list->prior = p;
}

//求雙向鏈表的長度  - 最后一個結點不等于頭結點
int DLLinkLength(DoubleLinkList list) {
    int allCount = 0;
    DoubleLinkList moveNode = list->next;
    while (moveNode != list) {
        moveNode = moveNode->next;
        allCount++;
    }
    return allCount;
}

//遍歷 - 正序
void IteratorDLLinkList(DoubleLinkList list) {
    DoubleLinkList moveNode = list->next;
    int k = 0;
    while (moveNode != list) {
        printf("current is %d\n",moveNode->data);
        moveNode = moveNode->next;
        k++;
    }
}

//遍歷 - 倒序
void reverse_itemratorList(DoubleLinkList list) {
    DoubleLinkList move = list->prior;
    int k = 0;
    while (move != list) {
        printf("current is %d\n",move->data);
        move = move->prior;
        k++;
    }
}


/** 插入情況是考慮已經初始化和創建過鏈表了*/
Status insert_Node_DLList(DoubleLinkList list, int i, ElementType e) {
    int length = DLLinkLength(list);
    DoubleLinkList insertNode = malloc(sizeof(Node));
    insertNode->data = e;
    
    if (i < 0 || i > length+1) {
        return ERROR;
    }
    
    if (i == 0) {
        
        //1.將新結點的next指向 頭結點的next（即第一個存放數據的結點，此處可能為null）
        insertNode->next = list->next;
        //2.將頭結點下一個結點的前驅指針  指向當前的插入結點
        list->next->prior = insertNode;
        //3.將頭結點的next指針指向新結點
        list->next = insertNode;
        //4.將新節點的前驅指針指向頭結點
        insertNode->prior = list;
    } else if (i == length+1) {
        
        //0.通過鏈表的前驅結點找到最后一個結點
        DoubleLinkList currentLast = list->prior;
        //1.將最后一個結點的next指針指向新節點
        currentLast->next = insertNode;
        //2.將新結點的前驅指針 指向當前最后一個結點
        insertNode->prior = currentLast;
        //3.因為當前新節點成為了最后一個結點了， 所以新結點的next指針指向頭結點
        insertNode->next = list;
        //4.將頭結點的前驅指針 指向新結點
        list->prior = insertNode;
        
    } else {
        int currentIndex;
        DoubleLinkList currentNode = list;
        
        //0. 找到第i-1個位置的結點
        for (currentIndex = 1; currentIndex < i; currentIndex++) {
            currentNode = currentNode->next;
        }
        //1.將新結點的next指針  指向當前i位置的結點
        insertNode->next = currentNode->next;
        //2.將當前i位置結點的前驅指針 指向要插入的結點
        currentNode->next->prior = insertNode;
        //3.將第i-1個位置的next指針 指向新創建的結點
        currentNode->next = insertNode;
        //4.將新創建結點的前驅指針 指向第i-1個位置的結點
        insertNode->prior = currentNode;
    }
    return OK;
}


/** 刪除（i）結點 相當于直接將 (i-1)結點的指針直接指向第 (i+1)個結點*/
int delete_node(DoubleLinkList list, int k) {
    int allCount = DLLinkLength(list);
    if (k < 0 || allCount < k) {
        return ERROR;
    }
    
    DoubleLinkList moveNode = list;
    DoubleLinkList deleteNode = list->next;
    if (k == 0) {
        //頭結點的next指針 直接指向刪除結點的下一個結點
        moveNode->next = deleteNode->next;
        deleteNode->next->prior = moveNode;
    } else if(k == allCount) {
        
        //因為要刪除最后一個結點  所以直接通過頭結點的前驅結點找到要刪除的結點
        deleteNode = list->prior;
        //根據要刪除的結點的前驅結點 找到第k-1個結點
        moveNode = deleteNode->prior;
        //剩下兩步是綁定next和前驅指針
        moveNode->next = deleteNode->next;
        deleteNode->next->prior = moveNode->next;
        printf("刪除了");
    } else {
        
        //找到第k-1個結點
        for (int i = 1; i < k; i++) {
            moveNode = moveNode->next;
        }
        //找到要刪除的第k個結點
        deleteNode = moveNode->next;
        moveNode->next = deleteNode->next;
        deleteNode->next->prior = moveNode;
    }
    return OK;
}

void print_data(DoubleLinkList list) {
    IteratorDLLinkList(list);
    printf("length is %d\n",DLLinkLength(list));
    printf("\n\n");
}

void print_reverse_data(DoubleLinkList list) {
    reverse_itemratorList(list);
    printf("length is %d\n",DLLinkLength(list));
    printf("\n\n");
}

#pragma mark - 使用
void k_check_DoubleLink(void) {
    
    DoubleLinkList list;
    InitDLLinkList(&list);
    createDLinkList(list, 9);
   
    insert_Node_DLList(list, 0, 12);
    print_data(list);

    insert_Node_DLList(list, 5, 22);
    print_reverse_data(list);
    
    delete_node(list, 9);
    IteratorDLLinkList(list);
}