kotovalexarian-likes-gitlab/sortix--sortix
1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
Code Releases Activity

Change qsort(3) and qsort_r(3) to use heapsort.

Browse source 
Heapsort has O(n·log(n)) worst case runtime and O(1) space usage, which
is better than current implementation's best case, while still keeping
the code simple.

Co-authored-by: Jonas 'Sortie' Termansen <sortie@maxsi.org>
This commit is contained in:
Juhani Krekelä 2021-12-04 15:14:31 +00:00
parent 7e5a816749
commit 8b57a79567
1 changed files with 98 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

150
libc/stdlib/qsort_r.c
View file

@ -1,5 +1,6 @@
/*
* Copyright (c) 2012, 2014 Jonas 'Sortie' Termansen.
* Copyright (c) 2012, 2014, 2021 Jonas 'Sortie' Termansen.
* Copyright (c) 2021 Juhani 'nortti' Krekelä.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@ -14,11 +15,11 @@
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* stdlib/qsort_r.c
* Sort an array.
* Sort an array. Implemented using heapsort, which is not a stable sort.
*/
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
static void memswap(unsigned char* a, unsigned char* b, size_t size)
{
@ -31,69 +32,114 @@ static void memswap(unsigned char* a, unsigned char* b, size_t size)
}
}
static
unsigned char* array_index(unsigned char* base,
size_t element_size,
size_t index)
static unsigned char* array_index(unsigned char* base,
size_t element_size,
size_t index)
{
return base + element_size * index;
}
static
size_t partition(unsigned char* base,
size_t element_size,
size_t num_elements,
size_t pivot_index,
int (*compare)(const void*, const void*, void*),
void* arg)
{
if ( pivot_index != num_elements - 1 )
{
unsigned char* pivot = array_index(base, element_size, pivot_index);
unsigned char* other = array_index(base, element_size, num_elements - 1);
memswap(pivot, other, element_size);
pivot_index = num_elements - 1;
}
size_t store_index = 0;
for ( size_t i = 0; i < num_elements - 1; i++ )
{
unsigned char* pivot = array_index(base, element_size, pivot_index);
unsigned char* value = array_index(base, element_size, i);
if ( compare(value, pivot, arg) <= 0 )
{
unsigned char* other = array_index(base, element_size, store_index);
if ( value != other )
memswap(value, other, element_size);
store_index++;
}
}
unsigned char* pivot = array_index(base, element_size, pivot_index);
unsigned char* value = array_index(base, element_size, store_index);
memswap(pivot, value, element_size);
return store_index;
}
void qsort_r(void* base_ptr,
size_t num_elements,
size_t element_size,
int (*compare)(const void*, const void*, void*),
void* arg)
{
unsigned char* base = (unsigned char*) base_ptr;
unsigned char* base = base_ptr;
if ( !element_size || num_elements < 2 )
return;
size_t pivot_index = num_elements / 2;
pivot_index = partition(base, element_size, num_elements, pivot_index, compare, arg);
// Incrementally left-to-right transform the array into a max-heap, where
// each element has up to two children that aren't bigger than the element.
for ( size_t i = 0; i < num_elements; i++ )
{
// Grow the heap by inserting another element into it (implicit, done by
// moving the boundary between the heap and the yet-to-be-processed
// array elements) and swapping it up the parent chain as long as it's
// bigger than its parent.
size_t element = i;
while ( element > 0 )
{
unsigned char* ptr = array_index(base, element_size, element);
size_t parent = (element - 1) / 2;
unsigned char* parent_ptr = array_index(base, element_size, parent);
if ( compare(parent_ptr, ptr, arg) < 0 )
{
memswap(parent_ptr, ptr, element_size);
element = parent;
}
else
break;
}
}
if ( 2 <= pivot_index )
qsort_r(base, pivot_index, element_size, compare, arg);
// The array is split into two sections, first the max-heap and then the
// part of the array that has been sorted.
// Sorting progresses right-to-left, taking the biggest value of the heap
// (at its root), swapping it with the last element of the heap, and
// adjusting the boundary between the two sections such that the old biggest
// value is now part of the sorted section.
// After this, the max-heap property is restored by swapping the old last
// element down as long as it's smaller than one of its children.
for ( size_t size = num_elements; --size; )
{
memswap(array_index(base, element_size, size), base, element_size);
if ( 2 <= num_elements - (pivot_index + 1) )
qsort_r(array_index(base, element_size, pivot_index + 1),
num_elements - (pivot_index + 1), element_size, compare, arg);
size_t first_without_left = size / 2;
size_t first_without_right = (size - 1) / 2;
size_t element = 0;
while ( element < size )
{
unsigned char* ptr = array_index(base, element_size, element);
size_t left = 2 * element + 1;
unsigned char* left_ptr = NULL;
bool left_bigger = false;
if ( element < first_without_left )
{
left_ptr = array_index(base, element_size, left);
left_bigger = compare(ptr, left_ptr, arg) < 0;
}
size_t right = 2 * element + 2;
unsigned char* right_ptr = NULL;
bool right_bigger = false;
if ( element < first_without_right )
{
right_ptr = array_index(base, element_size, right);
right_bigger = compare(ptr, right_ptr, arg) < 0;
}
if ( left_bigger && right_bigger )
{
// If both the left and right child are bigger than the element,
// then swap the element with whichever of the left and right
// child is bigger.
if ( compare(left_ptr, right_ptr, arg) < 0 )
{
memswap(ptr, right_ptr, element_size);
element = right;
}
else
{
memswap(ptr, left_ptr, element_size);
element = left;
}
}
else if ( left_bigger )
{
memswap(ptr, left_ptr, element_size);
element = left;
}
else if ( right_bigger )
{
memswap(ptr, right_ptr, element_size);
element = right;
}
else
break;
}
}
}