排序

1.概念：升序 降序
2.排序算法的稳定性
3.不需要比较的排序：位图 哈希(直接定址法--找出字符串中第一个只出现一次的字符)
4.内部排序：数据可以一次性加载到内存中
外部排序：数据不能一次性加载到内存中

必须掌握：排序原理 代码 时间复杂度 空间复杂度 稳定性 应用场景

常见排序算法

插入排序: 数据量小 尽可能有序 稳定 时间复杂度0(n^2) 空间复杂度0(1)

插入排序.png

//插入排序：数据量小 尽可能有序 稳定 时间复杂度0(n^2) 空间复杂度0(1)
void InsertSort(int array[], int size)
{
    //默认已有一个数据
    for (int i = 1; i < size; i++)
    {
        int key = array[i];
        int end = i - 1;
        
        //找待插入元素的位置 & 搬移数据
        while (end >= 0 && key < array[end])
        {
            array[end + 1] = array[end];
            end--;
        }

        //插入数据
        array[end + 1] = key;
    }
}

void TestInsertSort()
{
    int array[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    InsertSort(array, sizeof(array) / sizeof(array[0]));
}

插入排序调试1.png

插入排序2.png

希尔排序:
时间0(n^1.25)or0(n1.65) 空间0(1) 不稳定：间隔元素排序，不稳定 应用场景：数据量大且杂乱。

希尔排序.png

void ShellSort(int array[], int size)
{
    int gap = 3;
    while (gap > 0)
    {
        for (int i = gap; i < size; i++)
        {
            int key = array[i];
            int end = i - gap;

            //找待插入元素的位置 & 搬移数据   (找位置尝试二分查找。)
            while (end >= 0 && key < array[end])
            {
                array[end + gap] = array[end];
                end-=gap;
            }

            //插入数据
            array[end + gap] = key;
        }
        gap--;
    }
    
}

void TestShellSort()
{

    int array[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    InsertSort(array, sizeof(array) / sizeof(array[0]));
}

希尔排序调试1.png

希尔排序调试2.png

选择排序

选择排序.png

//选择排序

void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;

}

void SelectSort(int *array, int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        int maxPos = 0;
        for (int j = 1; j < size-i; j++)
        {
            if (array[j]>array[maxPos])
                maxPos = j;
        }
        if (maxPos!=size-i-1) //最大的元素在最后（升序） 则不需要交换
            Swap(&array[size - 1-i], &array[maxPos]);
    }
}

选择排序1.png

选择排序2.png

选择排序优化

void SelectSort_OP(int *array, int size)
{
    int begin = 0;
    int end = size - 1;
    while (begin < end)
    {
        int minPos = begin;
        int maxPos = end;

        //找最大 最小元素位置
        int i = begin + 1;
        while (i <= end)
        {
            if (array[i]>array[maxPos])
                maxPos = i;

            if (array[i] < array[minPos])
                minPos = i;
            i++;
        }
        if (maxPos != end)
            Swap(&array[maxPos], &array[end]);

        //最小的元素有可能在end的位置 需要重新标记minPos
        if (minPos == end)
            minPos = maxPos;

        if (minPos != begin)
            Swap(&array[minPos], &array[begin]);

        begin++;
        end--;
    }

}

void TestSelectSort()
{

    int array[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    SelectSort_OP(array, sizeof(array) / sizeof(array[0]));
}

选择排序优化.png

选择排序优化2.png

冒泡排序

//冒泡排序
void BubbleSort(int *array, int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - i-1; j++)
        {
            if (array[j]>array[j + 1])
                Swap(&array[j], &array[j + 1]);
        }
    }
}

void TestBubbleSort()
{

    int array[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    BubbleSort(array, sizeof(array) / sizeof(array[0]));
}

冒泡排序1.png

冒泡排序2.png