lucielle/lsort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Better memory management of arrays and test sample generation

Browse Source
This commit is contained in:
lucielle
2026-05-15 13:18:01 -05:00
parent de5493e7c6
commit f186ebfca8
12 changed files with 228 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
radix.c
View File

@@ -1,40 +1,42 @@
#include "include/lsort.h"
#include "include/types.h"
#include "include/radix.h"
static int _seperate_pos_neg(lsort_array_i* array, lsort_array_i* pos_array, lsort_array_i* neg_array) {
static int _seperate_pos_neg(lsort_array* array, lsort_array* pos_array, lsort_array* neg_array) {
for (int i = 0; i < array->count; i++) {
if ((0x80000000 & array->items[i]) == 0x80000000) {
lsort_array_i_append(neg_array, array->items[i]);
if ((0x80000000 & array->items[i]->key) == 0x80000000) {
lsort_array_append(neg_array, array->items[i]);
} else {
lsort_array_i_append(pos_array, array->items[i]);
lsort_array_append(pos_array, array->items[i]);
}
}
return 0;
}
static int _sort_items(lsort_array_i* numbers, lsort_array_i_array* buckets) {
static int _sort_items(lsort_array* numbers, lsort_array_array* buckets) {
int byte_check = 0x0000000F;
for (int i = 0; i < 8; i++) {
// Loop through the list of numbers and append them to their respective buckets for this 4-byte chunk
for (int item_index = 0; item_index < numbers->count; item_index++) {
int* current_number = &numbers->items[item_index];
lsort_array_i* bucket = buckets->items[(*current_number >> (i * 4)) & byte_check];
lsort_item* current_item = numbers->items[item_index];
lsort_array* bucket = buckets->items[(current_item->key >> (i * 4)) & byte_check];
lsort_array_i_append(bucket, *current_number);
lsort_array_append(bucket, current_item);
}
numbers->count = 0;
lsort_array_clear(numbers);
// Add the bucketed numbers back to the original array after emptying it
for (int bucket_number = 0; bucket_number < buckets->count; bucket_number++) {
lsort_array_i* bucket = buckets->items[bucket_number];
lsort_array* bucket = buckets->items[bucket_number];
for (int bucket_item = 0; bucket_item < bucket->count; bucket_item++) {
lsort_array_i_append(numbers, bucket->items[bucket_item]);
lsort_array_append(numbers, bucket->items[bucket_item]);
}
bucket->count = 0;
lsort_array_clear(bucket);
}
// Repeat for each 4-byte chunk...
@@ -43,37 +45,41 @@ static int _sort_items(lsort_array_i* numbers, lsort_array_i_array* buckets) {
return 0;
}
int lsort_radix(lsort_array_i* array, lsort_array_i* return_array) {
int lsort_radix(lsort_array* array, lsort_array* return_array) {
if (array->count <= 0) return 1;
// Seperate positive and negative numbers
lsort_array_i positive_numbers = {0};
lsort_array_i negative_numbers = {0};
lsort_array* positive_numbers = lsort_array_create();
lsort_array* negative_numbers = lsort_array_create();
if (_seperate_pos_neg(array, &positive_numbers, &negative_numbers)) return 2;
if (_seperate_pos_neg(array, positive_numbers, negative_numbers)) return 2;
// Create buckets
lsort_array_i_array buckets = {0};
lsort_array_array* buckets = lsort_array_array_create();
for (int i = 0; i < 16; i++) {
lsort_array_i* bucket = lsort_array_i_create();
lsort_array_i_array_append(&buckets, bucket);
lsort_array* bucket = lsort_array_create();
lsort_array_array_append(buckets, bucket);
}
// Sort each set of numbers using those buckets
_sort_items(&negative_numbers, &buckets);
_sort_items(&positive_numbers, &buckets);
_sort_items(negative_numbers, buckets);
_sort_items(positive_numbers, buckets);
// Add each array of numbers to the return array
for (int i = 0; i < negative_numbers.count; i++) {
lsort_array_i_append(return_array, negative_numbers.items[i]);
for (int i = 0; i < negative_numbers->count; i++) {
lsort_array_append(return_array, negative_numbers->items[i]);
}
for (int i = 0; i < positive_numbers.count; i++) {
lsort_array_i_append(return_array, positive_numbers.items[i]);
for (int i = 0; i < positive_numbers->count; i++) {
lsort_array_append(return_array, positive_numbers->items[i]);
}
lsort_array_destroy(negative_numbers, 0);
lsort_array_destroy(positive_numbers, 0);
// Destroy the buckets
lsort_array_i_array_destroy(&buckets);
lsort_array_array_destroy(buckets, 0);
return 0;
return check_sorted(return_array);
}