排序（插入排序，希尔排序，选择排序，堆排序）

选择排序

工作原理：每一次从待排序的数据元素中选出最大或最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

void SelectSort(int* a, size_t size)
{
    assert(a);

    for (int i = 0; i < size; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
        {
        //选择最小元素
            if (a[j] < a[i])
            {
                min = j;
            }
        }
        //放在第i个位置
        if (a[i] != a[min])
        {
            int tmp = a[i];
            a[i] = a[min];
            a[min] = tmp;
        }
    }
}

堆排序

只需要

//升序
void AdjustDown(int* a, size_t size, int root)
{
    assert(a);

    int child = root * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size && a[child + 1] > a[child])
        {
            child++;
        }

        if (a[child] > a[root])
        {
            swap(a[child], a[root]);
            root = child;
            child = root * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void AdjustUp(int* a, size_t size, int root)
{
    assert(a);

    int child = root * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size && a[child + 1] < a[child])
        {
            child++;
        }

        if (a[child] < a[root])
        {
            swap(a[child], a[root]);
            root = child;
            child = root * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void Heap_Sort(int* a, size_t size)
{
    assert(a);
    
    //建堆
    for (int i = (size - 2) / 2; i >= 0; i--)
    {
        AdjustDown(a, size, i);
    }

    for (int j = size - 1; j > 0; j--)
    {
        swap(a[0], a[j]);
        AdjustDown(a, j, 0);
    }
}

void _Heap_Sort(int* a, size_t size)
{
    assert(a);

    for (int i = (size - 2) / 2; i >= 0; i--)
    {
        AdjustUp(a, size, i);
    }

    for (int j = size - 1; j > 0; j--)
    {
        swap(a[0], a[j]);
        AdjustUp(a, j, 0);
    }
}