C实现常见排序

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>

typedef int bool;
#define true 1
#define false 0
#define N 1000

void clone(int *, int *, int);
void generalArray(int);
void swap(int *, int, int);

//选择排序
void selectSort(int *, int);

// 冒泡排序
void bubbleSort(int *, int);
// 插入排序
void insertSort(int *, int);

// 归并排序
void guiSort(int *, int, int);
void gSort(int *, int);
void merge(int *, int, int, int);

// 堆排序
void heapInsert(int *, int);
void heapify(int *, int, int);
void heapSort(int *, int);

// 判断两个数组是否相等,比较器
int equals(int *, int *, int);
int check(int *, int *, int);

/**
 * 一个方法自动生成数组.
 *
 *
 */

// 全局变量arr数组
int arr[N];
int copyArr[N];

int main()
{
    generalArray(100);
    clone(arr, copyArr, N);
    heapSort(arr, (sizeof(arr) / 4));
    insertSort(copyArr, N);
    bool number = check(arr, copyArr, N);

    if (number == true)
    {
        printf("排序方法正确.\n");
    }
    else
    {
        printf("Fuck,You are wrong.\n");
    }
}

bool check(int *arr, int *copyArr, int length)
{
    bool flag = true;
    for (int i = 0; i < 1000; i++)
    {
        flag = equals(arr, copyArr, length);
        if (flag == false)
        {
            break;
        }
    }
    return flag;
}

// 检查两个数组是否相等
bool equals(int *arr, int *copyArr, int length)
{
    bool flag = true;
    for (int i = 0; i < length; i++)
    {
        if (arr[i] != copyArr[i])
        {
            flag = false;
            break;
        }
    }
    return flag;
}

// 克隆数组
void clone(int *arr, int *copyArr, int length)
{
    for (int i = 0; i < length; i++)
    {
        copyArr[i] = arr[i];
    }
}

// -------------------------------------------------------------------
// 堆排序
void heapInsert(int *arr, int index)
{
    while (arr[index] > arr[(index - 1) / 2])
    {
        swap(arr, index, (index - 1) / 2);
        index = (index - 1) / 2;
    }
}

// 堆排序
void heapify(int *arr, int index, int heapsize)
{
    int left = index * 2 + 1;
    while (left < heapsize)
    {
        int largeIndex = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
        largeIndex = arr[largeIndex] > arr[index] ? largeIndex : index;
        if (largeIndex == index)
        {
            break;
        }
        swap(arr, largeIndex, index);
        index = largeIndex;
        left = index * 2 + 1;
    }
}

// 堆排序
void heapSort(int *arr, int length)
{
    for (int i = 0; i < length; i++)
    {
        heapInsert(arr, i);
    }
    int heapsize = length;
    swap(arr, 0, --heapsize);
    while (heapsize > 0)
    {
        heapify(arr, 0, heapsize);
        swap(arr, 0, --heapsize);
    }
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// 归并排序
void gSort(int *arr, int length)
{
    guiSort(arr, 0, length - 1);
}

// 归并排序
void guiSort(int *arr, int left, int right)
{
    if (left == right)
    {
        return;
    }
    int mid = left + ((right - left) >> 1);
    guiSort(arr, left, mid);
    guiSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

// 归并排序
void merge(int *arr, int left, int mid, int right)
{

    int help[right - left + 1];
    int i = 0;
    int p1 = left;
    int p2 = mid + 1;
    while (p1 <= mid && p2 <= right)
    {
        help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= mid)
    {
        help[i++] = arr[p1++];
    }
    while (p2 <= right)
    {
        help[i++] = arr[p2++];
    }
    for (i = 0; i < (sizeof(help) / 4); i++)
    {
        arr[left + i] = help[i];
    }
}

// -------------------------------------------------------------------

// 插入排序
void insertSort(int *arr, int length)
{
    for (int i = 1; i < length; i++)
    {
        for (int j = i - 1; j >= 0; j--)
        {
            if (arr[j] > arr[j + 1])
            {
                swap(arr, j, j + 1);
            }
        }
    }
}

// 冒泡排序
void bubbleSort(int *arr, int length)
{
    for (int i = length - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                swap(arr, j, j + 1);
            }
        }
    }
}

// 选择排序
void selectSort(int *arr, int length)
{
    for (int i = 0; i < length; i++)
    {
        int minIndex = i;
        for (int j = i + 1; j < length; j++)
        {
            minIndex = arr[minIndex] < arr[j] ? minIndex : j;
        }
        swap(arr, minIndex, i);
    }
}

// 数组对象的i和j位置的数字交换
void swap(int *arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

// 生成随机数 数组,设定最大值
void generalArray(int maxValue)
{
    srand((unsigned)time(NULL));
    for (int i = 0; i < N; i++)
    {
        arr[i] = rand() % maxValue;
    }
}