排序的实现

# 快排

int partition(vector<int>& arr, int left, int right)
{
    int piv_val = arr[right];
    int i = left;
    int j = left;

    while (j < right)
    {
        if (arr[j] < piv_val)
        {
            if (i != j)
            {
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
            ++i;
        }
        ++j;
    }

    arr[right] = arr[i];
    arr[i] = piv_val;

    return i;
}

void __quick_sort(vector<int>& arr, int p, int r)
{
    if (p >= r)
        return;

    int piv = partition(arr, p, r);
    __quick_sort(arr, p, piv - 1);
    __quick_sort(arr, piv + 1, r);
}

void quick_sort(vector<int>& arr)
{
    int n = arr.size();
    __quick_sort(arr, 0, n - 1);
}

# 归并

void merge(int *a, int p, int q, int r)
{
    int i = p;
    int j = q + 1;
    int k = 0;

    int *temp = (int*)malloc(sizeof(int) * (r - p + 1));
    
    if (!temp)
		abort();

    while (i <= q && j <= r)
    {   
        if (a[i] <= a[j])
        {
            temp[k++] = a[i++];
        }
        else
        {
            temp[k++] = a[j++];
        }
    }

    int start = i <= q ? i : j;
    int end =  i <= q ? q : r;

    while (start <= end)
    {
        temp[k++] = a[start++];
    }

    for (int v = 0; v <= r - p; v++)
    {
        a[p + v] = temp[v];
    }

    free(temp);
}

void mergeSort(int *a, int p, int r)
{
    if (p >= r)
        return;
    
    int q = (p + r) / 2;
    mergeSort(a, p, q);
    mergeSort(a, q + 1, r);

    merge(a, p, q, r);
}

# 冒泡

void bubbleSort(int* a, int n)
{
    if (n <= 1)
        return;
    
    for (int i = 0; i < n; i++)
    {
        bool flag = false;
        for (int j = 0; j < n - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
                flag = true;
            }
        }
        if (!flag)
            break;
    }
}

# 插入

void insertSort(int* a, int n)
{
    if (n <= 1)
        return;

    for (int i = 1; i < n; i++)
    {
        int temp = a[i];
        int j = i - 1;
        for (; j >= 0; j--)
        {
            if (a[j] > temp)
            {
                a[j + 1] = a[j];
            }
            else
                break;
        }
        a[j + 1] = temp;
    }
}

# 选择

void selectSort(int* a, int n)
{
    if (n <= 1)
        return;
    
    for (int i = 0; i < n; i++)
    {
        int min = a[i];
        int k = -1;
        for (int j = i; j < n; j++)
        {
            if (a[j] < min)
            {
                min = a[j];
                k = j;
            }
        }
        if (a[i] != min)
        {
            int temp = a[i];
            a[i] = min;
            a[k] = temp;
        }
    }
}