c语言实现基础的排序

1 插入排序

1.1 直接插入排序

void insert_sort(int *arr, int size)
{
    for (int i = 1; i < size; i++)
    {
        int end = i;         // 待插入的数字
        int temp = arr[end]; // 记录待排数值
        while (end > 0)
        {
            if (arr[end - 1] > temp) // 若前一个数大于待排数值，则后移一位
            {
                arr[end] = arr[end - 1];
                end--;
            }
            else
                break;
        }
        arr[end] = temp; // 将数据放入插入位置
    }
}

1.2 折半插入排序

void b_insert_sort(int *arr, int size)
{
    for (int i = 1; i < size; i++)
    {
        int left = 0;
        int right = i - 1;

        // 查找插入位置
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (arr[i] > arr[mid])
                left = mid + 1;
            else
                right = mid - 1;
        }

        // 后移数据并插入
        int temp = arr[i];
        right = i;
        while (right > left)
        {
            arr[right] = arr[right - 1];
            right--;
        }
        arr[left] = temp;
    }
}

2 交换排序

2.1 冒泡排序

void bubble_sort(int *arr, int length)
{
    for (int i = 0; i < length - 1; i++)         // 遍历n-1次
        for (int j = 0; j < length - 1 - i; j++) // 相邻两个数据依次进行比较
            if (arr[j] > arr[j + 1])             // 顺序不对的交换位置
                swap(arr, j, j + 1);
}

2.2 快速排序

int partition(int a[], int low, int high) // 计算基准点，分割为左右两个数组
{
    int point = a[low]; // 基准点等于第一个元素
    while (low < high)
    {
        while (low < high && a[high] >= point) // 控制high指针比较并左移
            high--;
        swap(a, low, high);
        while (low < high && a[low] <= point) // 控制low指针比较并右移
            low++;
        swap(a, low, high);
    }
    return low; // 返回基准点位置
}

void quick_sort(int a[], int low, int high) // low:起始位置 high:末尾位置
{
    if (low < high)
    {
        int point = partition(a, low, high); // 计算基准点
        quick_sort(a, low, point - 1);       // 对基准点的左边进行排序
        quick_sort(a, point + 1, high);      // 对基准点的右边进行排序
    }
}

3 选择排序

3.1 简单选择排序

void select_sort(int *arr, int size)
{
    int i = 0;
    for (i = 0; i < size - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
            if (arr[j] < arr[min])
                min = j;
        swap(arr, i, min);
    }
}

3.2 堆排序

typedef int HPDataType;	//堆存储的数据的类型

//交换数据
void Swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

//向下调整（大根堆）
void AdjustDown(HPDataType* data, int size, int parent)
{
	int maxchild = parent * 2 + 1;
	while (maxchild < size)
	{
        //比较左右子节点
		if (maxchild + 1 < size && data[maxchild] < data[maxchild + 1])
		{
			maxchild++;
		}
		
		if (data[maxchild] > data[parent])
		{
			Swap(&data[maxchild], &data[parent]);
			parent = maxchild;
			maxchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆排序
void HeapSort(int arr, int n)
{
    int i = 0;
    
    //建堆
    for (i=(n-2)/2; i>=0; i--)
    {
        AdjustDown(arr, n, i);
    }
    
    //选数
    for (i=n-1; i>0; i--)
    {
        Swap(&arr[0], arr[i]);
        AdjustDwon(arr, i-1, 0);
    }
}

4 归并排序

void merge_sort(int *arr, int size)
{
    // 申请空间
    int *temp = (int *)malloc(size * sizeof(int));
    if (temp == NULL)
    {
        perror("malloc fail!\n");
        return;
    }

    // 归并排序
    int gap = 1;
    while (gap < size)
    {
        // 单趟排序
        for (int i = 0; i < size; i += 2 * gap) // 一次跨2*gap格，两个数组
        {
            int begin1 = i, end1 = i + gap - 1;           // 第一个数组下标区间
            int begin2 = i + gap, end2 = i + 2 * gap - 1; // 第二个数组下标区间，别忘记加上i

            // 数组边界处理
            if (end1 >= size) // 第一个数组越界
                break;
            if (begin2 >= size) // 第二个数组全部越界
                break;
            if (end2 >= size) // 第二个数组部分越界
                end2 = size - 1;

            // 排序合并
            int j = i; // 合并后数组的下标
            while (begin1 <= end1 && begin2 <= end2)
            {
                if (arr[begin1] <= arr[begin2])
                {
                    temp[j] = arr[begin1];
                    begin1++;
                }
                else
                {
                    temp[j] = arr[begin2];
                    begin2++;
                }
                j++;
            }

            while (begin1 <= end1)
            {
                temp[j] = arr[begin1];
                begin1++;
                j++;
            }

            while (begin2 <= end2)
            {
                temp[j] = arr[begin2];
                begin2++;
                j++;
            }

            // 拷贝temp数组到原数组（排哪个区间就拷贝哪个区间，end2是闭区间哦）
            for (j = i; j <= end2; j++)
                arr[j] = temp[j];
        }
        gap *= 2;
    }

    free(temp);
    temp = NULL;
}

5 交换数组值的方法

// 数组值交换
void swap(int a[], int low, int high)
{
    int t = a[low];
    a[low] = a[high];
    a[high] = t;
}