數據結構和算法（2）-單向循環鏈表

一.單向循環鏈表

循環鏈表 是另外一種形式的鏈式存儲結構，特色是表中最後一個節點的指針域指向頭結點，整個鏈表造成一個環。因此從表中任意節點出發，均可以找到表中其餘的結點。

單向循環鏈表 的操做和單鏈表基本一致，惟一不一樣的是，當鏈表遍歷時，判斷當前指針p是否指向尾結點的終止條件不一樣:

• 單鏈表中，條件爲p!=NULL 或 p->next !=NULL
• 循環鏈表中，條件爲p!=L 或 p->next != L

二.常規操做

1.定義結點

typedef int Status;// Status是函數的類型,其值是函數結果狀態代碼，如OK等
typedef int ElemType;// ElemType類型根據實際狀況而定，這裏假設爲int

typedef struct Node{
    ElemType data;
    struct Node *next;
}Node;

typedef struct Node * LinkList;
複製代碼

2.建立單向循環鏈表

須要考慮兩種狀況：

• 只包含一個結點(即首元結點）
• 包含多個節點，就要尋找尾結點，將新結點的指針指向首元結點，而後尾結點的指針指向新結點。

Status CreateList(LinkList *L){
    int item;
    LinkList temp = NULL;
    LinkList target = NULL;
    printf("輸入節點的值，輸入0結束\n");
    while(1)
    {
        scanf("%d",&item);
        if(item==0) break;
          //若是輸入的鏈表是空。則建立一個新的節點，使其next指針指向本身  (*head)->next=*head;
        if(*L==NULL)
        {
            *L = (LinkList)malloc(sizeof(Node));
            if(!L)exit(0);
            (*L)->data=item;
            (*L)->next=*L;
        }
        else
        {
           //輸入的鏈表不是空的，尋找鏈表的尾節點，使尾節點的next=新節點。新節點的next指向頭節點
            for (target = *L; target->next != *L; target = target->next);
            temp=(LinkList)malloc(sizeof(Node));
            if(!temp) return ERROR;
            temp->data=item;
            temp->next=*L;  //新節點指向頭節點
            target->next=temp;//尾節點指向新節點
        }
    }
    return OK;
}
複製代碼

3.插入結點

3.1 插入的位置是首元結點

• 要找到尾結點，將尾結點的next指針指向新結點
• 讓新結點的next指針指向首元結點
• 頭指針指向新結點

3.2 插入的位置非首元結點

• 找到插入位置的前一結點
• 新結點的next指向前一結點的next
• 前一結點的next指針指向新結點

Status ListInsert(LinkList *L, int place, int num){
    LinkList temp ,target;
    int i;
    if (place == 1) {
        //若是插入的位置爲1,則屬於插入首元結點,因此須要特殊處理
        //1. 建立新結點temp,並判斷是否建立成功,成功則賦值,不然返回ERROR;
        //2. 找到鏈表最後的結點_尾結點,
        //3. 讓新結點的next 執行頭結點.
        //4. 尾結點的next 指向新的頭結點;
        //5. 讓頭指針指向temp(臨時的新結點)
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        for (target = *L; target->next != *L; target = target->next);
        temp->next = *L;
        target->next = temp;
        *L = temp;
    }else{
        //若是插入的位置在其餘位置;
        //1. 建立新結點temp,並判斷是否建立成功,成功則賦值,不然返回ERROR;
        //2. 先找到插入的位置,若是超過鏈表長度,則自動插入隊尾;
        //3. 經過target找到要插入位置的前一個結點, 讓target->next = temp;
        //4. 插入結點的前驅指向新結點,新結點的next 指向target原來的next位置 ;
        temp = (LinkList)malloc(sizeof(Node));
        if (temp == NULL) {
            return ERROR;
        }
        temp->data = num;
        for ( i = 1,target = *L; target->next != *L && i != place - 1; target = target->next,i++) ;
        temp->next = target->next;
        target->next = temp;
    }
    return OK;
}

複製代碼

4.刪除結點

4.1刪除首元結點

4.1.1 鏈表中只有首元結點一個結點

• 將頭指針置爲NULL

4.1.2 鏈表中除首元結點外，還有其餘節點

• 找到尾結點
• 將首元結點的指針，指向首元結點的next指針指向的下一結點
• 將尾結點的next指針指向首元結點
• 釋放原來的首結點

4.2刪除非首元結點

• 找到刪除結點的前一個結點target
• 將前一結點的next指針指向，要刪除結點的next指向的結點
• 釋放要刪除的節點

Status  LinkListDelete(LinkList *L,int place){
    LinkList temp,target;
    int i;
    //temp 指向鏈表首元結點
    temp = *L;
    if(temp == NULL) return ERROR;
    if (place == 1) {
        //①.若是刪除到只剩下首元結點了,則直接將*L置空;
        if((*L)->next == (*L)){
            (*L) = NULL;
            return OK;
        }
        //②.鏈表還有不少數據,可是刪除的是首結點;
        //1. 找到尾結點, 使得尾結點next 指向頭結點的下一個結點 target->next = (*L)->next;
        //2. 新結點作爲頭結點,則釋放原來的頭結點
        for (target = *L; target->next != *L; target = target->next);
        temp = *L;
        *L = (*L)->next;
        target->next = *L;
        free(temp);
    }else{
        //若是刪除其餘結點--其餘結點
        //1. 找到刪除結點前一個結點target
        //2. 使得target->next 指向下一個結點
        //3. 釋放須要刪除的結點temp
        for(i=1,target = *L;target->next != *L && i != place -1;target = target->next,i++) ;
            temp = target->next;
            target->next = temp->next;
            free(temp);
        }
    return OK;
}
複製代碼

5.查詢某個值所在位置

int findValue(LinkList L,int value){
    int i = 1;
    LinkList p;
    p = L;
    //尋找鏈表中的結點 data == value
    while (p->data != value && p->next != L) {
        i++;
        p = p->next;
    }
    //當尾結點指向頭結點就會直接跳出循環,因此要額外增長一次判斷尾結點的data == value;
    if (p->next == L && p->data != value) {
        return  -1;
    }
    return i;
}
複製代碼