CountSort在云构建环境中触发段错误，本地运行正常

问题描述 #

实现C语言计数排序时，输入以下数组：

0 0 0 0 0 1 1 1 1 2 2 2 3 3 4 6 7 7 8 10 10 10 10 10 8 8 9 9 9 9

本地运行完全正常，但在云构建环境中触发段错误。尝试用malloc动态分配count_array未解决问题。

错误分析 #

1. 栈上变长数组（VLA）风险：原代码用int count_array[max + 1];在栈上分配计数数组，云环境栈空间通常比本地更受限，即便本次max+1仅为11，也存在潜在溢出风险；且用户使用malloc时未正确初始化内存，导致计数逻辑读取垃圾值。
2. 降序模式逻辑错误：count_sort_write_output_array中降序循环条件i > 0会跳过值为0的元素，导致输入中的0无法写入输出数组，破坏计数排序的完整性。
3. 参数传递不规范：通过output_array[0]传递max+1的方式易引发误解和意外覆盖，增加逻辑出错概率。
4. 无内存分配检查：使用malloc时未检查返回值，若云环境内存分配失败返回NULL，直接访问会触发段错误。

修复方案 #

1. 替换VLA为动态内存分配：用calloc分配计数数组（自动初始化为0），并检查分配是否成功，避免垃圾值和NULL指针访问。
2. 修复降序循环条件：将i > 0改为i >= 0，确保所有值（包括0）被处理。
3. 优化参数传递：直接将max和数组长度len传入输出写入函数，消除通过输出数组传递额外数据的不合理设计。
4. 添加越界保护：在写入输出数组时检查output_idx是否超出数组长度，避免越界访问。

完整修复代码 #

#include <stdio.h>
#include <string.h>
#include "introprog_countsort.h"
#include "arrayio.h"
#include <stdlib.h>

void count_sort_calculate_counts(int input_array[], int len, int count_array[]) {
    for (int i = 0; i < len; i++)
        count_array[input_array[i]]++;
}

// 直接传入max、len参数，规范参数传递
void count_sort_write_output_array(int output_array[], int count_array[], int max, SortDirection order, int len) {
    int output_idx = 0;
    if (order == ASCENDING) {
        for (int i = 0; i <= max; i++) {
            for (int j = 0; j < count_array[i]; j++) {
                if (output_idx >= len) break; // 防止越界写入
                output_array[output_idx++] = i;
            }
        }
    } else {
        for (int i = max; i >= 0; i--) { // 包含0值的处理
            for (int j = 0; j < count_array[i]; j++) {
                if (output_idx >= len) break; // 防止越界写入
                output_array[output_idx++] = i;
            }
        }
    }
}

void count_sort(int input_array[], int len, int output_array[], SortDirection order) {
    // 初始化输出数组，确保未使用位置为0
    memset(output_array, 0, len * sizeof(int));
    
    int max = 0;
    for (int i = 0; i < len; i++) {
        if (input_array[i] > max) {
            max = input_array[i];
        }
    }

    // 使用calloc分配并初始化内存，同时检查分配结果
    int *count_array = calloc(max + 1, sizeof(int));
    if (count_array == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return;
    }

    count_sort_calculate_counts(input_array, len, count_array);
    count_sort_write_output_array(output_array, count_array, max, order, len);

    // 释放动态内存，避免泄漏
    free(count_array);
}

SortDirection extract_order_direction(char *order) {
    SortDirection direction = NOTDEFINED;
    if (strcmp(order, "desc") == 0)  
        direction = DESCENDING;
    else if (strcmp(order, "asc") == 0)  
        direction = ASCENDING;
    return direction;
}

int main(int argc, char *argv[]) {
    int input_array[] = {
        0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 6,
        7, 7, 8, 10, 10, 10, 10, 10, 8, 8, 9, 9, 9, 9
    };
    int len = 30;

    printf("Unsortiertes Array:");
    print_array(input_array, len);

    int output_array[MAX_LAENGE];
    count_sort(input_array, len, output_array, ASCENDING);

    printf("Sortiertes Array:");
    print_array(output_array, len);
    return 0;
}

内容的提问来源于stack exchange，提问作者user22977839