112 lines
3.8 KiB
C
112 lines
3.8 KiB
C
#include "c_HeapSort.h"
|
|
#include "c_Test.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
static int sort_compare_ints_with_args(const void* a, const void* b, void* args) {
|
|
(void)args;
|
|
int arg1 = *(const int*)a;
|
|
int arg2 = *(const int*)b;
|
|
if (arg1 < arg2) return -1;
|
|
if (arg1 > arg2) return 1;
|
|
return 0;
|
|
}
|
|
|
|
typedef struct {
|
|
char label;
|
|
int primary;
|
|
int secondary;
|
|
} LogMeta_t;
|
|
|
|
// 复合结构体双级比对器：优先按 primary 升序，相同时按 secondary 降序
|
|
static int sort_compare_logs(const void* a, const void* b, void* args) {
|
|
(void)args;
|
|
const LogMeta_t* l1 = (const LogMeta_t*)a;
|
|
const LogMeta_t* l2 = (const LogMeta_t*)b;
|
|
if (l1->primary != l2->primary) {
|
|
return l1->primary - l2->primary;
|
|
}
|
|
return l2->secondary - l1->secondary;
|
|
}
|
|
|
|
TEST_CASE(test_c_HeapSort_BasicInts) {
|
|
// 准备一组带有高频大量重复项的恶劣随机分布整型集合，验证单调非减
|
|
int arr[] = { 45, 12, 85, 45, 5, 67, 12, 90, 45, 1 };
|
|
c_size_t num = sizeof(arr) / sizeof(arr[0]);
|
|
|
|
c_HeapSort(arr, num, sizeof(int), sort_compare_ints_with_args, NULL);
|
|
|
|
// 验证全区间无损单调递增性
|
|
for (c_size_t i = 0; i < num - 1; i++) {
|
|
if (arr[i] > arr[i + 1]) {
|
|
// 利用您已有的精确断言对数值冲突点实施高精确报错打印
|
|
ASSERT_INT_EQ(arr[i + 1], arr[i]);
|
|
return;
|
|
}
|
|
}
|
|
ASSERT_INT_EQ(1, arr[0]);
|
|
ASSERT_INT_EQ(5, arr[1]);
|
|
ASSERT_INT_EQ(45, arr[4]); // 重复项完美挤压归位
|
|
ASSERT_INT_EQ(90, arr[num - 1]); // 尾部必须收拢为最大值 90
|
|
}
|
|
|
|
TEST_CASE(test_c_HeapSort_StructArray) {
|
|
// 复杂业务多主键对象的就地堆排序搬运测试
|
|
LogMeta_t logs[] = {
|
|
{ 'A', 50, 100 },
|
|
{ 'B', 20, 300 },
|
|
{ 'C', 50, 400 }, // primary 键同为 50，但 secondary 次键 400 应当在 100 前面（降序）
|
|
{ 'D', 10, 200 }
|
|
};
|
|
c_size_t num = sizeof(logs) / sizeof(logs[0]);
|
|
|
|
c_HeapSort(logs, num, sizeof(LogMeta_t), sort_compare_logs, NULL);
|
|
|
|
// 预期就地堆排序后的精确物理排布顺序: D(10/200) -> B(20/300) -> C(50/400) -> A(50/100)
|
|
// 严格引入了正确的数组下标位置，杜绝了前几轮的数组名称未加下标引用笔误
|
|
ASSERT_INT_EQ(10, logs[0].primary);
|
|
ASSERT_TRUE(logs[0].label == 'D');
|
|
|
|
ASSERT_INT_EQ(20, logs[1].primary);
|
|
ASSERT_TRUE(logs[1].label == 'B');
|
|
|
|
ASSERT_INT_EQ(50, logs[2].primary);
|
|
ASSERT_INT_EQ(400, logs[2].secondary); // 降序次键优先被堆顶下沉挪移到左侧插槽
|
|
ASSERT_TRUE(logs[2].label == 'C');
|
|
|
|
ASSERT_INT_EQ(50, logs[3].primary);
|
|
ASSERT_INT_EQ(100, logs[3].secondary);
|
|
ASSERT_TRUE(logs[3].label == 'A');
|
|
}
|
|
|
|
TEST_CASE(test_c_HeapSort_ExtremeEdges) {
|
|
// 压测完全有序和完全逆序序列，全方位高强度检验 `num >> 1` 自底向上建堆边界的拦截安全性
|
|
int rev_arr[] = { 5, 4, 3, 2, 1 };
|
|
c_size_t num = sizeof(rev_arr) / sizeof(rev_arr[0]);
|
|
|
|
c_HeapSort(rev_arr, num, sizeof(int), sort_compare_ints_with_args, NULL);
|
|
for (c_size_t i = 0; i < num - 1; i++) {
|
|
ASSERT_TRUE(rev_arr[i] < rev_arr[i + 1]);
|
|
}
|
|
|
|
// 极端输入空边界及单元素优雅退出拦截断言
|
|
int single_arr[] = { 66666 };
|
|
c_HeapSort(single_arr, 1, sizeof(int), sort_compare_ints_with_args, NULL);
|
|
c_HeapSort(NULL, 0, sizeof(int), sort_compare_ints_with_args, NULL);
|
|
ASSERT_INT_EQ(66666, single_arr[0]);
|
|
}
|
|
|
|
// ==========================================
|
|
// 5. 独立集成主入口点
|
|
// ==========================================
|
|
int main(void) {
|
|
TEST_START(C_HeapSort_Isolated_TestSuite);
|
|
|
|
// 顺序触发堆排序专线的全景自动化验证
|
|
RUN_TEST(test_c_HeapSort_BasicInts);
|
|
RUN_TEST(test_c_HeapSort_StructArray);
|
|
RUN_TEST(test_c_HeapSort_ExtremeEdges);
|
|
|
|
TEST_REPORT();
|
|
RETURN_TEST_STATUS;
|
|
} |