單鏈表的排序

　　最近學了單鏈表，遇到了一些問題 ，和大家分享一下！

首先看一下帶頭指針的單鏈表示意圖： 

從中可以看到鏈表的每一個節點（除了尾指針）都有一個指針指向下一個節點（頭指針只有只保存了該鏈表的地址），尾指針指向空。

所以我們要對鏈表中的某個節點進行操作的話，基本上要使用到該節點的前驅節點和后驅節點。（節點2的前驅節點是節點1，節點2的后驅節點是節點3；）

 　　單鏈表的排序關鍵在交換，交換有兩種方式  一種是節點值的交換，另一種是節點的交換。

        先講第一種節點值交換法：

#include <stdio.h>
#include <stdlib.h>
//定義STUDENT類型變量 包括了學號、分數
typedef struct student {
    int number;
    int score;
    struct student *pNext;
}STUDENT;

STUDENT *Create(int n) {
    STUDENT *pHead, *pEnd,*pNew=NULL;
    int i;
    pHead=pEnd= (STUDENT*)malloc(sizeof(STUDENT));
         for (i = 0; i < n; i++)
     {
        pNew = (STUDENT*)malloc(sizeof(STUDENT));
        scanf("%d", &pNew->number);
        scanf("%d", &pNew->score);
        pNew->pNext = NULL;
        pEnd->pNext = pNew;
        pEnd = pNew;

    }
     return pHead;
}
//輸出鏈表
void print(STUDENT *p1) {
    while (p1->pNext != NULL) {
        p1 = p1->pNext;
        printf("%d %d\n", p1->number, p1->score);
    }
}
//冒泡排序 節點值交換法
void Sort(STUDENT *head) {
    STUDENT *p, *q;
    for (p = head->pNext; p != NULL; p = p->pNext)
        for (q = p->pNext; q != NULL; q = q->pNext)
            if (p->number > q->number)//根據學號從小到大排序
            {
                int t1 = p->number; p->number = q->number; q->number = t1;
                int t2 = p->score; p->score = q->score; q->score = t2;
            }
    
    }

int main() {
    int  n;
    STUDENT *p;
    scanf("%d",  &n);
    p= Create(n);
    Sort(p);
    print(p);
    }

 

 　　根據算法不難看出節點值交換法適用於節點中變量成員較少的情況下，但是實際問題往往是復雜的。

　　比如節點中增加學生的姓名等等，那么想通過交換節點值的方法是比較繁瑣的。所以我就想能不能想通過交換任意兩個節點的位置排序呢？

     之后寫下了如下代碼：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定義STUDENT類型變量 包括學號、姓名、分數
typedef struct student {
    unsigned  number;
    char name[50];
    unsigned score;                                                    
    struct  student *pNext;
}STUDENT;
//尋找前驅節點
STUDENT *Find_before(STUDENT* phead, STUDENT* p)
{
    if (!p) return NULL;
    STUDENT *pbefore = phead;
    while (pbefore)
    {
        if (pbefore->pNext == p)
            return pbefore;
        pbefore = pbefore->pNext;
    }
    return NULL;
}
//冒泡排序 按照分數高低排序 交換任意的滿足條件的節點
//head 為鏈表的頭地址
void Sort(STUDENT *head) {
    STUDENT *p, *pbefore, *q, *qbefore, *t1, *t2;
    STUDENT *phead = head;
    for (p = head->pNext; p != NULL; p = p->pNext)
    {
        pbefore = Find_before(phead, p);
        for (q = p->pNext; q != NULL; q = q->pNext)
        {
            qbefore = Find_before(phead, q);
            //當p q節點不相鄰
            if (p->score < q->score && p->pNext != q)
            {
                t1 = pbefore->pNext;              //保存p節點地址
                pbefore->pNext = qbefore->pNext;  //把q節點賦值給p節點
                qbefore->pNext = t1;             //p節點賦值給q節點
                t2 = q->pNext;                   //保存q的后驅節點
                q->pNext = p->pNext;            //把p的后驅節點賦值給q的后驅節點
                p->pNext = t2;                 //把q的后驅節點賦值給p的后驅節點
            }
            //當p q節點相鄰
            else if (p->score < q->score  && p->pNext == q)
            {
                t1 = pbefore->pNext;
                pbefore->pNext = p->pNext;
                p->pNext = t1;
                t1 = q->pNext;
            }

        }

    }

}

　　　　上面的代碼看似沒有問題 但卻忽略了一個問題--交換之后的p,q 將for語句的循環破壞了! 我們來看一下p q不相鄰情況下的交換圖：

              

如果按照for語句中執行語句q=q->pNext ，q更新后為節點3，而不是我們想要的節點5。所以這種交換任意節點排序的方法是錯誤的

　　之后我又換了個思路：（假設按分數從高到低為鏈表節點排序）在鏈表a中找到最高分節點q，然后將q節點接在b鏈表（空鏈表）的頭指針后面，

再通過q的前后驅動節點將q從a鏈表中剔除，接下來又在a鏈表中尋找最高分節點q'，如此循環           直到a鏈表為空。

　　代碼如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//創建STUDENT類型變量 包括學號、姓名、成績
typedef struct student {
    int  number;
    char name[50];
    int  score;
    struct  student *pNext;
}STUDENT;
//創建鏈表
STUDENT *Create(int n) {
    STUDENT *pHead, *pEnd, *pNew = NULL;
    int i;  pHead = pEnd = (STUDENT*)malloc(sizeof(STUDENT));
    for (i = 0; i < n; i++)
    {
        pNew = (STUDENT*)malloc(sizeof(STUDENT));
        scanf("%d%s%d", &pNew->number, &pNew->name, &pNew->score);
        
        pNew->pNext = NULL;
        pEnd->pNext = pNew;
        pEnd = pNew;

    }
    return pHead;
}
//尋找前驅節點
STUDENT *Find_before(STUDENT* phead, STUDENT* p)
{
    if (!p) return NULL;
    STUDENT *pbefore = phead;
    while (pbefore)
    {
        if (pbefore->pNext == p)
            return pbefore;
        pbefore = pbefore->pNext;
    }
    return NULL;
}

STUDENT *Sort(STUDENT *head) {
    STUDENT *pHead,*pEnd,*q=NULL,*qbefore=NULL,*p=NULL;
    int maxscore;
    pHead=pEnd = (STUDENT*)malloc(sizeof(STUDENT));
    while (head->pNext != NULL)
    {
        maxscore = head->pNext->score;
        q = p = head->pNext;
        //尋找最高分節點p
        while (p->pNext!=NULL)
        {
            if(maxscore<p->pNext->score)
            {
                maxscore = p->pNext->score; q = p->pNext;
            }
            p = p->pNext;
        }

       qbefore = Find_before(head,q);  //尋找q節點的前驅節點
       qbefore->pNext = q->pNext; //將q的前驅節點指向q的后驅節點 從而將q節點從a鏈表中剔除

        pEnd->pNext = q;    //將頭指針指向q
        q->pNext = NULL;    //q節點指向空
        pEnd = q;            //更新尾節點

        
    }
    free(head);//釋放head鏈表頭節點
    return pHead;
}
void print(STUDENT *q) {
    while (q->pNext != NULL)
    {
        q = q->pNext; printf("%s\n", q->name);
    }
    free(q);//釋放使用完的鏈表
}
int main() {
    int n, i = 1; STUDENT *p,*q;
    scanf("%d", &n);
    p = Create(n);
    q=Sort(p);
    print(q);
}

 

  　　　　　　如果有什么錯誤，請指正！ 萬分感謝！