个人笔记--大顶堆和基数排序

大顶堆：

大顶堆 是一种特殊的完全二叉树数据结构，满足以下性质：

核心性质

堆序性 ：每个节点的值都 大于或等于 其左右子节点的值
完全二叉树：除了最后一层，其他层都是满的，且最后一层节点从左到右排列

cs 复制代码

#include<stdio.h>
void heapify(int arr[],int length,int parent){
    int child=2*parent+1;
    while(child<length){
        int rchild=child+1;
        if(rchild<length && arr[rchild]>arr[child]{
            child=rchild;
        }
        if(arr[parent]<arr[child]){
            int temp=arr[parent];
            arr[parent]=arr[child];
            arr[child]=temp;
            parent=child;
            child=2*parent+1;
        }else{
            break;
        }
    }
}
int main(){
    int arr[]={5,7,4,2,0,3,1,6};
    int length=sizeof(arr)/sizeof(int);
    //建堆，从最后一个非叶子节点开始
    for(int p=length;p>=0;p--){
        heapify(arr,length,p);
    }
    //排序
    for(int i=length-1;i>0;i--){
        int temp=arr[0];
        arr[0]=arr[i];
        arr[i]=temp;
        heapify(arr,i,0);//调整前i个元素
    }
    //打印
    for(int i=0;i<length;i++){
        printf("%d",arr[i]);
    }
    printf("\n");
    return 0;
}

基数排序：基数排序 是一种非比较型整数排序算法，通过按位（个位、十位、百位...）分配和收集元素来实现排序。

cs 复制代码

#include <stdio.h>
#include <stdlib.h>    // for malloc/free

void radixSort(int arr[], int length) {
    // 1. 找最大值（用于确定最大位数）
    int max = arr[0];
    for (int i = 1; i < length; i++) {
        if (arr[i] > max) max = arr[i];
    }

    // 2. 计算最大值的位数
    int maxLength = 0;
    int temp = max;
    while (temp > 0) {
        temp /= 10;
        maxLength++;
    }

    // 若最大值是0，直接返回（或位数计为1）
    if (maxLength == 0) maxLength = 1;

    // 3. 定义桶（使用动态分配）
    // 注意：int (*bucket)[length] 这种写法在某些编译器可能不支持变长数组
    // 更安全的方式是使用 int** 或者一维数组模拟
    int (*bucket)[length] = malloc(10 * sizeof(*bucket));
    if (bucket == NULL) {
        perror("malloc failed");
        return;
    }

    int bucketCount[10] = {0};

    int n = 1;  // 用于获取当前位的除数（1, 10, 100, ...）
    
    // 4. 按位进行排序
    for (int digit = 0; digit < maxLength; digit++) {
        // 清空桶计数器（每轮开始前必须为0）
        for (int i = 0; i < 10; i++) bucketCount[i] = 0;
        
        // -------- 分配阶段：将元素放入对应的桶 --------
        for (int i = 0; i < length; i++) {
            int currentDigit = (arr[i] / n) % 10;  // 获取当前位上的数字
            bucket[currentDigit][bucketCount[currentDigit]++] = arr[i];
        }
        
        // -------- 收集阶段：按顺序从桶中取出元素 --------
        int index = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < bucketCount[i]; j++) {
                arr[index++] = bucket[i][j];
            }
        }
        
        // 更新除数，进入下一位
        n *= 10;
    }
    
    // 5. 释放动态分配的内存
    free(bucket);
}

// 测试函数
int main() {
    int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
    int length = sizeof(arr) / sizeof(arr[0]);
    
    printf("排序前: ");
    for (int i = 0; i < length; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    radixSort(arr, length);
    
    printf("排序后: ");
    for (int i = 0; i < length; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    return 0;
}