【数据结构】排序算法实现（直接插入、折半插入、希尔、冒泡、快速、简单选择、堆、归并、基数）

#include <stdio.h>
#include <stdbool.h>

void printArray(int arr[], int n);
void insertionSort(int arr[], int n);
void binaryInsertionSort(int arr[], int n);
void shellSort(int arr[], int n);
void bubbleSort(int arr[], int n);
void quickSort(int arr[], int low, int high);
void simpleSelectionSort(int arr[], int n);
void heapSort(int arr[], int n);
void mergeSort(int arr[], int size);
void radixSort(int arr[], int size);

int main()
{
    int arr[] = {1, 9, 95, 0, 5, 23};
    int arrLength = sizeof(arr) / sizeof(arr[0]);
    printf("The Original Array is:\n");
    printArray(arr, arrLength);
    printf("The Sorted array is:\n");
    // insertionSort(arr, arrLength);
    // binaryInsertionSort(arr, arrLength);
    // shellSort(arr, arrLength);
    // bubbleSort(arr, arrLength);
    // quickSort(arr, 0, arrLength - 1);
    // simpleSelectionSort(arr, arrLength);
    // heapSort(arr, arrLength);
    // mergeSort(arr, arrLength);
    radixSort(arr, arrLength);
    printArray(arr, arrLength);
}

void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
// *插入排序*
// 直接插入排序
void insertionSort(int arr[], int n)
{
    int i, j, key;
    for (i = 1; i < n; i++)
    {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

// 折半插入排序
void binaryInsertionSort(int arr[], int n)
{
    int i, j, key, low, high, mid;
    for (int i = 1; i < n; i++)
    {
        key = arr[i];
        j = i - 1;
        low = 0;
        high = i - 1;
        // 使用折半查找找到插入的位置
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (arr[mid] > key)
            {
                high = mid - 1;
            }
            else
            {
                low = mid + 1;
            }
        }
        while (j >= low && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
// 希尔排序
void shellSort(int arr[], int n)
{
    int gap, i, j, key;
    for (gap = n / 2; gap > 0; gap = gap / 2)
    {
        for (i = gap; i < n; i++)
        {
            key = arr[i];
            for (j = i - gap; j >= 0 && arr[j] > key; j = j - gap)
            {
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = key;
        }
    }
}

//*交换排序*
// 冒泡排序
void bubbleSort(int arr[], int n)
{
    int temp;
    bool flag = false;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;
            }
        }
        if (flag == false)
        {
            break;
        }
    }
}
// 快速排序
void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
int partition(int arr[], int low, int high)
{
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j <= high - 1; j++)
    {
        if (arr[j] < pivot)
        {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        int pivote = partition(arr, low, high);
        quickSort(arr, low, pivote - 1);
        quickSort(arr, pivote + 1, high);
    }
}

// *选择排序*
// 简单选择排序
void simpleSelectionSort(int arr[], int n)
{

    for (int i = 0; i < n; i++)
    {
        int minValue = arr[i];
        int minIndex = i;
        for (int j = i; j < n; j++)
        {
            if (minValue > arr[j])
            {
                minValue = arr[j];
                minIndex = j;
            }
        }
        swap(&arr[i], &arr[minIndex]);
    }
}

// 堆排序
void heapify(int arr[], int n, int i)
{
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;

    if (left < n && arr[largest] < arr[left])
    {
        largest = left;
    }

    if (right < n && arr[largest] < arr[right])
    {
        largest = right;
    }
    if (largest != i)
    {
        swap(&arr[largest], &arr[i]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n)
{
    for (int i = n / 2 - 1; i >= 0; i--)
    {
        heapify(arr, n, i);
    }

    for (int i = n - 1; i >= 0; i--)
    {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

//*其它排序算法*
// 归并排序
void merge(int arr[], int left[], int leftSize, int right[], int rightSize)
{
    int i = 0, j = 0, k = 0;
    while (i < leftSize && j < rightSize)
    {
        if (left[i] < right[j])
        {
            arr[k] = left[i];
            i++;
        }
        else
        {
            arr[k] = right[j];
            j++;
        }
        k++;
    }
    while (i < leftSize)
    {
        arr[k++] = left[i++];
    }
    while (j < rightSize)
    {
        arr[k++] = right[j++];
    }
}

void mergeSort(int arr[], int size)
{
    if (size < 2)
    {
        return;
    }

    int mid = size / 2;
    int left[mid];
    int right[size - mid];
    for (int i = 0; i < mid; i++)
    {
        left[i] = arr[i];
    }
    for (int i = mid; i < size; i++)
    {
        right[i - mid] = arr[i];
    }
    mergeSort(left, mid);
    mergeSort(right, size - mid);
    merge(arr, left, mid, right, size - mid);
}

// 基数排序
int getMaxValue(int arr[], int size)
{
    int maxValue = arr[0];
    for (int i = 1; i < size; i++)
    {
        if (maxValue < arr[i])
        {
            maxValue = arr[i];
        }
    }
    return maxValue;
}

void countingSort(int arr[], int size, int exp)
{
    int output[size];
    int count[10] = {0};

    // 统计原始数组中指定位数 数字出现的次数
    for (int i = 0; i < size; i++)
    {
        count[(arr[i] / exp) % 10]++;
    }

    // 累加求位置
    // 这里通过累加出现频次，求出每个数字（0~9）最后出现的位置
    for (int i = 1; i < 10; i++)
    {
        count[i] += count[i - 1];
    }

    // 移动
    // 由于之前的累加操作，这里最好是从后往前移动
    for (int i = size - 1; i >= 0; i--)
    {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    // 将输出数组复制回原数组
    for (int i = 0; i < size; i++)
    {
        arr[i] = output[i];
    }
}

void radixSort(int arr[], int size)
{
    int maxValue = getMaxValue(arr, size);
    for (int exp = 1; maxValue / exp > 0; exp *= 10)
    {
        countingSort(arr, size, exp);
    }
}