c++常用排序算法

1、快速排序

快速排序其思想是来自冒泡排序，冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端，而快速排序是比较和交换小数和大数，这样一来不仅把小数冒泡到上面同时也把大数沉到下面。

2、归并排序

#include <iostream>
using namespace std;

//计算数组元素个数
#define Length(table) (sizeof(table) / sizeof(table[0]))

//冒泡排序
void bubble_sort(int* arr, int length)
{
    int tmp = 0;
    int i = 0, j = 0;

    if (arr == NULL || length == 0)
    {
        return;
    }

    for (i = 0; i < length; i++)
    {
        for (j = length - 1; j > i; j--)
        {
            if (arr[i] > arr[j])
            {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

//快速排序
void quick_sort(int* arr, int begin, int end)
{
    int i = begin;
    int j = end;
    int tmp = arr[i];

    if (arr == NULL || begin >= end)
    {
        return;
    }

    while (i < j)
    {
        while (i < j && tmp <= arr[j])
        {
            j--;
        }

        if (i < j)
        {
            arr[i] = arr[j];
        }

        while (i < j && arr[i] <= tmp)
        {
            i++;
        }

        if (i < j)
        {
            arr[j] = arr[i];
        }
    }
    arr[i] = tmp;

    quick_sort(arr, begin, i - 1);
    quick_sort(arr, i + 1, end);
}

//选择排序
void select_sort(int* arr, int length)
{
    int min = 0, tmp = 0;
    int i = 0, j = 0;

    if (arr == NULL || length == 0)
    {
        return;
    }

    for (i = 0; i < length; i++)
    {
        min = i;
        for (j = length - 1; j > i; j--)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }

        tmp = arr[i];
        arr[i] = arr[min];
        arr[min] = tmp;
    }
}

//归并排序
void merge_sort_recursive(int* arr, int* reg, int start, int end)
{
    if (end <= start)
    {
        return;
    }

    int i = start;
    int mid = (end - start) / 2 + start;
    int start1 = start;
    int end1 = mid;
    int start2 = mid + 1;
    int end2 = end;

    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);

    while (start1 <= end1 && start2 <= end2)
    {
        reg[i++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    }

    while (start1 <= end1)
    {
        reg[i++] = arr[start1++];
    }

    while (start2 <= end2)
    {
        reg[i++] = arr[start2++];
    }

    for (i = start; i <= end; i++)
    {
        arr[i] = reg[i];
    }
}

void merge_sort(int* arr, int len)
{
    int* reg = (int*)malloc(len * sizeof(int));
    merge_sort_recursive(arr, reg, 0, len - 1);
    free(reg);
}

//堆排序
void heapify(int arr[], int n, int i)
{
    int smallest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] < arr[smallest])
    {
        smallest = l;
    }

    if (r < n && arr[r] < arr[smallest])
    {
        smallest = r;
    }

    if (smallest != i)
    {
        swap(arr[smallest], arr[i]);

        i = smallest;

        heapify(arr, n, i);
    }
}

void heap_sort(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);
    }
}

int main()
{
    int i = 0;
    int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };

    //  bubble_sort(a, Length(a));
    //  quick_sort(a, 0, Length(a)-1);
    //  select_sort(a, Length(a));
    //  merge_sort(a, Length(a));
    heap_sort(a, Length(a));

    for (i = 0; i < Length(a); i++)
    {
        cout << a[i] << endl;
    }
    system("pause");
}