QuickSorting Linked Lists in C - c

Question

I am trying to become more familiar with recursion and I am trying to write a function recursively rather than iteratively... I am trying to create a quick-sort function for linked list, I keep reevaluating the code, but I don't know what I am missing, the code always leaves the last node on the list, for example...
input list ... 1->2->3->4->NULL
output list .. 4->NULL
here is my code ...
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);
}
NOTES lst_filter_leq() is a function that pulls out all occurrences of x<=cutoff point and returns a list of all the nodes pulled.
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() merges two list together

Answer 1

Look at your code and your example. First, looks like creating pivot list is seemingly not necessary, as you use only pivot->front->val, which I assume is the first value on your list (because you earlier did pivot->front = l->front).
So for values [1, 2, 3, 4] you do the following in the first step (I use pseudo-code to show list members):
// you extracted '1' from your list, because you did l->front = l->front->next;
lt = lst_filter_leq([2, 3, 4], 1);
which means you end with nothing (none of the values on the list are less or equal than 1). Next you do quicksort of l (which is [2, 3, 4]) and then concatenate results of l and lt.
But when quicksorting [2, 3, 4] you receive nothing and quicksort [3, 4],
which is nothing and [4].
And quicksorting of [4] returns [4]. Hence your result.
So looks what you forgot was inserting pivot between l and lt lists.
Working implementation using glib library for double-ended queues:
#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;
}
Example output:
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