c++各种排序

1.插入排序

void InsertSort(int a[], int n)
{
    int temp, i, j;
    for (i = 1; i < n; i++)
    {
        if (a[i] < a[i - 1])
        {
            temp = a[i];
            for (j = i - 1; j >= 0 && a[j]>temp; j--)
                a[j + 1] = a[j];
            a[j + 1] = temp;
        }
    }
}

时间复杂度：O（n²）

空间复杂度：O(1)

稳定性：稳定

2.希尔排序

void ShellSort(int a[], int n)
{
    int dk,temp, i, j;
    for (dk = n / 2; dk >= 1; dk /= 2)
    {
        for (i = dk; i <n; i+=dk)
        {
            if (a[i] < a[i - dk])
            {
                temp = a[i];
                for (j = i - dk; j>=0&&a[j]>temp; j -= dk)
                    a[j + dk] = a[j];
                a[j + dk] = temp;
            }
        }
    }
}

时间复杂度：O（n^1.3）

最坏时间复杂度：O（n²）

空间复杂度：O(1)

稳定性：不稳定

3.冒泡排序

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

时间复杂度：O（n²）

空间复杂度：O(1)

稳定性：稳定

4.快速排序：O（nlog）---O(1)----稳定

int Parttion1(int a[], int low,int high)
{
    int temp = a[low];
    while (low < high)
    {
        while (low < high&&a[high] >= temp) high--;
        a[low] = a[high];
        while (low < high&&a[low] <= temp) low++;
        a[high] = a[low];
    }
    a[low] = temp;
    return low;
}

void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
int Parttion2(int a[], int low, int high)
{//将小于等于a[high]的元素移到最前面，最后再将a[high]移到最终位置
    int temp = a[high];
    int i = low - 1;
    for (int j = low; j < high; j++)
    {
        if (a[j] <= temp)
        {
            i++;
            swap(a[i], a[j]);
        }
    }
    swap(a[i + 1], a[high]);
    return i + 1;
}
void QuickSort(int a[], int low, int high)
{
    if (low < high)
    {
        int p = Parttion2(a, low, high);
        QuickSort(a, low, p - 1);
        QuickSort(a, p + 1, high);
    }
}

时间复杂度：O（n²）--基本有序或逆序的情况

空间复杂度：O(n)

稳定性：不稳定

平均时间复杂度最好：O（nlog₂n）

5.简单选择排序

void SelectSort(int a[], int n)
{
    int min;
    for (int i = 0; i < n-1; i++)
    {
        min = i;
        for (int j = i+1; j < n; j++)
        {
            if (a[j] < a[min])
                min = j;
        }
        if (min!=i)
            swap(a[min], a[i]);
    }
}

时间复杂度：O（n²）

空间复杂度：O(1)

稳定性：不稳定

6.堆排序

void AdjustDown(int a[], int k, int n)
{
    a[0] = a[k];  //a[0]是暂存单元
    for (int i = 2 * k; i <= n; i *= 2)
    {
        if (i < n&&a[i] < a[i + 1]) i++;
        if (a[0]>=a[i]) break;
        else
        {
            a[k] = a[i];
            k = i;
        }
    }
    a[k] = a[0];
}

void AdjustUp(int a[], int k)
{
    a[0] = a[k];
    for (int i = k / 2; i > 0; i /= 2)
    {
        if (a[i] > a[0]) break;
        else
        {
            a[k] = a[i];
            k = i;
        }
    }
    a[k] = a[0];
}

void BuildMaxHeap(int a[], int n)
{
    /*for (int i = n / 2; i > 0; i--)
        AdjustDown(a, i, n);*/
    for (int i = n; i > 0; i--)
        AdjustUp(a, i);
}

void HeapSort(int a[], int n)
{
    BuildMaxHeap(a, n);
    for (int i = n; i > 0; i--)
    {
        swap(a[1], a[i]);
        AdjustDown(a, 1, i - 1);
    }
}

时间复杂度：O（nlog₂n）

空间复杂度：O(1)

稳定性：不稳定