C中的快速排序鏈接列表

Question

我試圖對遞歸更加熟悉，並且試圖遞歸而不是迭代地編寫一個函數...我試圖為鏈表創建一個快速排序函數，我一直在重新評估代碼，但我不知道我所缺少的是，代碼始終將列表中的最后一個節點保留下來，例如...

input list ... 1->2->3->4->NULL
output list .. 4->NULL

這是我的代碼...

void lst_qsort(LIST *l){
    if(l==NULL || l->front==NULL || l->front->next==NULL)
        return;
    if(lst_length(l)<=1)
        return;

    LIST *lt = lst_create();
    LIST *pivot = lst_create();

    pivot->front = l->front;
    pivot->back = l->front;

    l->front = l->front->next;
    pivot->front->next = NULL;
    lt = lst_filter_leq(l, pivot->front->val);


    lst_qsort(lt);
    lst_qsort(l);
    lst_concat(l, lt);

}

注意lst_filter_leq()是提取所有出現的x <= cutoff point並返回所有被拉節點的列表的函數。

LIST * lst_filter_leq(LIST *lst, ElemType cutoff) {
    LIST *lst2 = lst_create();
    NODE *tmp = lst->front;
    int i = 0, n=1;

    while(lst->front != NULL){
        if(lst->front->val <= cutoff){
            lst_push_back(lst2, lst->front->val);
        }
        lst->front = lst->front->next;
    }
    lst->front = tmp;
    for(i=cutoff; i>=0; i--){
        n = lst_remove_all_slow(lst, i);
    }

    return lst2;
}

lst_concat()將兩個列表合並在一起

Answer 1

查看您的代碼和示例。 首先，似乎似乎不需要創建pivot表列表，因為您僅使用了pivot->front->val ，我認為這是列表中的第一個值（因為您之前做過pivot->front = l->front ）。

因此，對於值[1、2、3、4]，您需要在第一步中執行以下操作（我使用偽代碼顯示列表成員）：

// you extracted '1' from your list, because you did l->front = l->front->next;
lt = lst_filter_leq([2, 3, 4], 1);

這意味着您一無所有（列表中的任何一個值都不小於或等於1）。 接下來，對l （即[2，3，4]）進行快速排序，然后將l和lt結果連接起來。

但是當進行快速排序[2，3，4]時，您什么也收不到，而進行快速排序[3，4]，
沒什么，[4]。
快速排序[4]返回[4]。 因此，您的結果。

因此，看起來您忘記了在l和lt列表之間插入pivot表。

將glib庫用於雙端隊列的有效實現：

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

// defines to maintain compatibility with OP code
#define LIST GQueue
#define lst_create g_queue_new
#define lst_length g_queue_get_length

// lst_push_back implementation using GQueue
void lst_push_back(LIST *list, int val) {
    g_queue_push_tail(list, GINT_TO_POINTER(val));
}

// lst_pop_front implementation using GQueue
int lst_pop_front(LIST *list) {
    return GPOINTER_TO_INT(g_queue_pop_head(list));
}

// adds elements from list2 to list1
// list2 is destroyed afterwards
void lst_concat(LIST *list1, LIST *list2) {
    int length = lst_length(list2);
    int i, v;
    for (i = 0; i < length; ++i) {
        v = lst_pop_front(list2);
        lst_push_back(list1, v);
    }
    g_queue_free(list2);
}

// filters 'list' elements
// elements less or equal 'value' are returned in newly created list
// elements greater than 'value' are left in 'list'
LIST *lst_filter_leq(LIST *list, int value) {
    LIST *lte = lst_create();
    LIST *gt  = lst_create();
    int length = lst_length(list);
    int i, v;
    for (i = 0; i < length; ++i) {
        v = lst_pop_front(list);
        if (v <= value) {
            lst_push_back(lte, v);
        } else {
            lst_push_back(gt, v);
        }
    }
    lst_concat(list, gt);
    return lte;
}

void lst_qsort(LIST *l) {
    if (l == NULL) {
        return;
    }
    if (lst_length(l) <= 1) {
        return;
    }

    LIST *lt = lst_create();
    LIST *pivot = lst_create();

    int val = lst_pop_front(l);
    lst_push_back(pivot, val);

    // this function divides the list int two parts
    // elements less or equal 'val' are returned in lt list ("right" list)
    // elements greater than 'val 'are left in l list ("left" list)
    lt = lst_filter_leq(l, val);

    lst_qsort(lt); // sort "right" part of list

    lst_qsort(l);  // sort "left" part of list

    lst_concat(l, pivot); // add the pivot element
    lst_concat(l, lt);    // add right part of list
}

void printList(LIST *list) {
    GList *vList = g_queue_peek_head_link(list);
    while (vList != NULL) {
        printf("%d", GPOINTER_TO_INT(vList->data));
        vList = g_list_next(vList);
        if (vList != NULL) {
            printf("->");
        } else {
            printf("\n");
        }
    }
}

int main(void) {
    LIST *l = lst_create();
    lst_push_back(l, 4);
    lst_push_back(l, 3);
    lst_push_back(l, 2);
    lst_push_back(l, 1);

    printf("unsorted: ");
    printList(l);
    lst_qsort(l);
    printf("sorted: ");
    printList(l);

    g_queue_clear(l);

    lst_push_back(l, 1);
    lst_push_back(l, 2);
    lst_push_back(l, 3);
    lst_push_back(l, 4);

    printf("unsorted: ");
    printList(l);
    lst_qsort(l);
    printf("sorted: ");
    printList(l);

    g_queue_clear(l);

    srand(time(NULL));
    int i;
    for (i = 0; i < 16; ++i) {
        lst_push_back(l, rand() % 32);
    }
    printf("unsorted: ");
    printList(l);
    lst_qsort(l);
    printf("sorted: ");
    printList(l);

    g_queue_free(l);

    return 0;
}

輸出示例：

unsorted: 4->3->2->1
sorted: 4->3->2->1
unsorted: 1->2->3->4
sorted: 4->3->2->1
unsorted: 27->16->20->4->14->30->26->28->10->13->19->1->30->8->3->14
sorted: 30->30->28->27->26->20->19->16->14->14->13->10->8->4->3->1