数据结构——对于排序的理解

//目录

sort.h

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <string.h>

// 插入排序
void InsertSort(int* a, int n);
// 希尔排序
void ShellSort(int* a, int n);
// 选择排序
void SelectSort(int* a, int n);
// 堆排序
void AdjustDown(int* a, int n, int root);
void HeapSort(int* a, int n);
// 冒泡排序
void BubbleSort(int* a, int n);

// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int begin, int end);
// 快速排序挖坑法
int PartSort2(int* a, int begin, int end);
// 快速排序前后指针法
int PartSort3(int* a, int begin, int end);
int PartSort3Plus(int* a, int begin, int end);
//快排优化（小区间优化）
void QuickSort123(int* a, int left, int right);
extern int callCount;//声明  加extern就不会出现不同文件出现重复变量的问题
void QuickSortPlus(int* a, int left, int right);
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right);

// 归并排序递归实现
void MergeSort(int* a, int n);
// 归并排序非递归实现
void MergeSortNonR(int* a, int n);
// 计数排序
void CountSort(int* a, int n);

//桶排序，基数排序   校招不考！！！

//操作

sort.c

#define _CRT_SECURE_NO_WARNINGS

#include "Sort.h"
#include "Stack.h"

void Swap(int* n1, int* n2)
{
    int tmp = *n1;
    *n1 = *n2;
    *n2 = tmp;
}

void PrintArray(int * a, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

// 插入排序 =>时间复杂度O(N^2)
//     好O(N)   坏O(N^2)
void InsertSort(int* a, int n)
{
    //保持前面一直有序，然后后面的往里插
    for (int i = 0; i < n - 1; ++i)
    {
        //[0, end]有序，把end+1位置的值插入，保持有序
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
            if (tmp < a[end])
            {
                a[end + 1] = a[end];
                --end;
            }
            else
            {
                break;
            }
        }
        a[end + 1] = tmp;
    }
    
}

// 希尔排序(缩小增量排序)=>平均时间复杂度O(N^1.3)
void ShellSort(int* a, int n)
{
    //最坏：逆序
    //最好：顺序/解决顺序
    //设一个gap，使得每次都能跳gap步
    //1.gap越大，大的数可以更快到后面，小的数可以更快到前面，
    //   但是越不接近有序的
    //2.gap越小，越接近有序的
    //3.当gap==1，就是直接插入排序
    

/*  //这种方式太复杂了！！！
    int gap = 3;
    for (int j = 0; j < gap; ++j)
    {
        for (int i = j; i < n - gap; i += gap)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (tmp < a[end])
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
*/

    // gap组数据交替插入排序
    //  gap>1时是预排序，进行多次预排序
    // ==>让大的数尽快到后面，小的数尽快到前面
    //  最后一次gap=1时是直接插入排序
    int gap = n;
    while (gap > 1)
    {
        gap = gap / 3 + 1;//保证最后一次是1

        for (int i = 0; i < n - gap; ++i)
        {
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
                if (tmp < a[end])
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}

// 选择排序O(N^2)=>最烂的排序之一(最好最坏都一样)
//1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
//2. 时间复杂度：O(N ^ 2)
//3. 空间复杂度：O(1)
//4. 稳定性：不稳定
void SelectSort(int* a, int n)
{
    //不断选择，往中间走，把小的往前放，大的往后放
    //选出最小的，次小的......
    assert(a);

    int begin = 0, end = n - 1;
    while (begin < end)
    {
        int mini = begin, maxi = begin;

        for (int i = begin + 1; i <= end; i++)
        {
            if (a[i] < a[mini])
            {
                mini = i;
            }
            if (a[i] > a[maxi])
            {
                maxi = i;
            }
        }
        Swap(&a[begin], &a[mini]);
        if (begin == maxi)
        //如果begin和max重叠，那么要修正一下maxi的位置
        {
            maxi = mini;
        }
        Swap(&a[end], &a[maxi]);
        ++begin;
        --end;
    }
    
}

// 堆排序
//时间复杂度：O(NlogN)
void AdjustDown(int* a, int n, int root);
void HeapSort(int* a, int n);

// 冒泡排序=>时间复杂度  最坏O(N^2)  最好O(N)
// 对比插入排序，谁更好？
//==> 插入更优
void BubbleSort(int* a, int n)
{
    assert(a);
    for (int i = 0; i < n - 1; i++)
    {
        int exchange = 0;
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                Swap(&a[j], &a[j + 1]);
                exchange = 1;
            }
        }

        if (exchange == 0)
            //当已经有序时
        {
            break;
        }
    }
}

   // 快速排序递归实现  =>  好O(NlogN)   坏O(N^2)
// 快速排序hoare版本
int PartSort1(int* a, int begin, int end)
{
    //选一个数为key(一般是最左或最右边的数)
    //单趟排完以后，要求：左边比key小，右边比key大
    //1.当左边找到一个比key大的，右边找到一个比key小的
    //  二者互换
    //2.两者相遇
    //  此处与key互换
    
    // 
    //当区间不存在，或者只有一个值则不需要再递归处理
    if (begin >= end)
    {
        return;
    }
    int left = begin; 
    int right = end;
    int keyi = left;
    while (left < right)
    {
        //为什么左边做key，却让右边先走？
        //  结论：因为要保证相遇位置的值，比key小
        //1.R先走，R停下来，L去遇到R，相遇的位置就是
        //  比key小的位置
        //2.R先走，没找到比key小的值，R去遇到L，相遇的
        //  位置是L上一轮停下的位置
        //  要么就是key的位置，要么比key要小
          
        //右边先走，找小
        while (left < right && a[right] >= a[keyi])
        {
            --right;
        } 
        //左边先走，找大
        while (left < right && a[left] <= a[keyi])
        {
            ++left;
        }

        Swap(&a[left], &a[right]);
    }

    Swap(&a[keyi], &a[left]);
    keyi = left;
    //形式为：用key分成左右两个区间
    //  [begin, keyi-1] keyi [keyi+1, end]
    //PartSort1(a, begin, keyi-1);
    //PartSort1(a, keyi+1, end);
    
    return keyi;//返回坑的位置
}

// 快速排序挖坑法
//   (和hoare区别不太大，但好理解)
int PartSort2(int* a, int begin, int end)
{
    //一次循环
        //左边为key，此处为坑
        //右边找小，找到后放入坑中，此处为新坑
        //左边找大，找到后放入坑中，此处为新坑
        //一直进行 右找--左找，直到左右到达同一位置（坑）
        //把key值放入坑的位置
    int key = a[begin];
    int piti = begin;//坑位置
    while (begin < end)
    {
        //右边找小，填到左边的坑里面去，这个位置形成新的坑
        while (begin < end && a[end] >= key)
        {
            --end;
        }
        a[piti] = a[end];//填坑
        piti = end;//形成新的坑

        //左边找大，填到右边的坑里面去，这个位置形成新的坑
        while (begin < end && a[end] <= key)
        {
            ++begin;
        }
        a[piti] = a[begin];
        piti = begin;
    }

    //最终它们一定相遇在坑的位置 => key值应放在最后的坑的位置
    a[piti] = key;
    return piti;//返回坑的位置
}

// 快速排序前后指针法
int GetMidIndex(int* a, int begin, int end)//三数取中，选中间数的下标
{
    int mid = (begin + end) / 2;
    if (a[begin] < a[mid])
    {
        if (a[mid] < a[end])
        {
            return mid;
        }
        else if(a[begin] < a[end])// 且  a[mid] > a[end]
        {
            return end;
        }
        else// a[mid] == a[end]
        {
            return begin;
        }
    }
    else//a[begin] >= a[mid]
    {
        if (a[mid > a[end]])
        {
            return mid;
        }
        else if (a[begin] > a[end])
        {
            return end;
        }
        else
        {
            return begin;
        }
    }
}
int PartSort3(int* a, int begin, int end)
{
    //初始时，prev在begin，cur在下一位
    //cur小于key，prev移一位，在cur和prev中间有大于key的数的情况下，cur与prev内容互换，cur++
    //效果：prev之前的（包括prev的）比key小
    //      prev之后的比key大
    int prev = begin;
    int cur = begin + 1;
    int keyi = begin;

    while (cur <= end )
    {
        //若cur位置的值小于keyi位置的值
        if (a[cur] < a[keyi] && ++prev != cur)
        {
            Swap(&a[prev], &a[cur]);
        }
        ++cur; 
    }
    Swap(&a[prev], &a[keyi]);//此时key左面均比key小，key右面均比key大
    keyi = prev;

    return keyi;
}
//（对前后指针法的优化）
int PartSort3Plus(int* a, int begin, int end)
{
    int prev = begin;
    int cur = begin + 1;
    int keyi = begin;

    //加入三数取中
    int midi = GetMidIndex(a, begin, end);//选出首、中间、尾三者中处于中间大小的数的下标
    Swap(&a[keyi], &a[midi]);//让key位置的值和三数取中的数交换，使key位置的数既不是最大也不是最小

    while (cur <= end)
    {
        //若cur位置的值小于keyi位置的值
        if (a[cur] < a[keyi] && ++prev != cur)
        {
            Swap(&a[prev], &a[cur]);
        }
        ++cur;
    }
    Swap(&a[prev], &a[keyi]);//此时key左面均比key小，key右面均比key大
    keyi = prev;

    return keyi;
}

//普通快排
void QuickSort123(int* a, int begin, int end)
// 当选择的key每次都是中位数的时候效率最高 N*logN
// 当每次排序后都有序（key为最大或最小时）效率最低 N*2
// 数据量稍微大一些，会出现栈溢出
{
    //区间不存在，或者只有一个值则不需要再处理
    if (begin >= end)
    {
        return;
    }

    int keyi = PartSort1(a, begin, end);
    //或者  int keyi = PartSort2(a, begin, end)；
    //或者  int keyi = PartSort3(a, begin, end)；
    //或者  int keyi = PartSort3Plus(a, begin, end)；

    // [begin, keyi-1] keyi [keyi+1, end]
    QuickSort123(a, begin, keyi - 1);
    QuickSort123(a, keyi + 1, end);
}

//升级快排（小区间优化）
int callCount = 0;// 定义初始化
void QuickSortPlus(int* a, int begin, int end)
// 当区间比较小的时候，就不再递归划分去排序这个小区间
// 直接可以考虑用其他排序对小区间进行处理（插入排序）
// 减少80%以上的递归次数
{
    callCount++;// 统计递归次数

    //区间不存在，或者只有一个值则不需要再处理
    if (begin >= end)
    {
        return;
    }

    if (end - begin > 10)
    {
        int keyi = PartSort3(a, begin, end);
        // [begin, keyi-1] keyi [keyi+1, end]
        QuickSortPlus(a, begin, keyi - 1);
        QuickSortPlus(a, keyi + 1, end);
    }
    else//区间小于等于10后，不再递归排序小区间
    {
        InsertSort(a + begin, end - begin + 1);   
    }
}

// 快速排序 非递归实现
//要求掌握=>递归改非递归
//递归有大问题，极端场景下面，如果深度太深，会出现栈溢出
//1.直接改循环 -- 比如斐波那契数列、归并排序
//2.用数据结构栈模拟递归过程
void QuickSortNonR(int* a, int begin, int end)
{
    ST st;
    StackInit(&st);
    StackPush(&st, end);
    StackPush(&st, begin);

    while ( !StackEmpty(&st))
    {
        int left = StackTop(&st);
        StackPop(&st);

        int right = StackTop(&st);
        StackPop(&st);
        
        int keyi = PartSort3(a, begin, end);
        //  [begin, keyi-1] keyi [keyi+1, end]
        
        if (right > keyi + 1)
        {
            StackPush(&st, right);
            StackPush(&st, keyi + 1);
        }

        if (left < keyi - 1)
        {
            StackPush(&st, keyi - 1);
            StackPush(&st, left);
        }
    }

    StackDestroy(&st);
}

// 归并排序递归实现
//  时间复杂度：O(NlogN)（无波动，无最好最坏情况）
//  空间复杂度：O(N)
void _MergeSort(int* a, int begin, int end, int* tmp)
{
    if (begin >= end)
        return;

    int mid = (begin + end) / 2;
    //  [begin, mid][mid+1, end]  
    //分治递归,让子区间有序

    _MergeSort(a, begin, mid, tmp);
    _MergeSort(a, mid+1, end, tmp);

    //归并
    int begin1 = begin, end1 = mid;
    int begin2 = mid+1, end2 = end;
    int i = begin1;
    while (begin1 <= end1 && begin2 <= end2)
    {
        if (a[begin1] < a[begin2])
        {
            tmp[i++] = a[begin1++];
        }
        else
        {
            tmp[i++] = a[begin2++];
        }
    }

    while (begin1 <= end1)
    {
        tmp[i++] = a[begin1++];
    }

    while (begin2 <= end2)
    {
        tmp[i++] = a[begin2++];
    }

    //把 归并数据 拷贝回 原数组
    memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
    //设置一个用来排序的空数组
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (tmp == NULL)
    {
        printf("malloc fail");
        exit(-1);
    }
    _MergeSort(a, 0, n - 1, tmp);//做一个操作的函数

    free(tmp);
}

// 归并排序非递归实现
//    (小心奇数个数据，非2的n次方个数据)
//     需要对越界进行分类处理 => 
void MergeSortNonR(int* a, int n)
{
    //做一个手动的归并
    //设置一个用来排序的空数组 => 很像斐波那契数列
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (tmp == NULL)
    {
        printf("malloc fail");
        exit(-1);
    }

    int gap = 1;//规定每一组有多少数据进行归并
    while (gap < n)
    {
        int i = 0;
        for (i = 0; i < n; i += 2 * gap)
        {
            //[i, i+gap-1][i+gap, i+2*gap-1]
            //归并
            int begin1 = i, end1 = i + gap - 1;
            int begin2 = i + gap, end2 = i + 2 * gap - 1;
            
            //越界-修正边界
            /*if (end1 >= n)
            {
                end1 = n - 1;
                //[begin2, end2]修正为不存在区间
                begin2 = n;
                end2 = n-1;
            }
            else if (begin2 >= n)
            {
                //[begin2, end2]修正为不存在区间
                begin2 = n;
                end2 = n - 1;
            }
            else if(end2 >= n)//end2越界
            {
                end2 = n - 1;
            }
            */

            //end1越界或者begin2越界，则可以不归并了
            if (end1 >= n || begin2 >= n)
            {
                break;
            }
            else if (end2 >= n)
            {
                end2 = n - 1;
            }

            //printf("[%d, %d] [%d, %d]--", begin1, end1, begin2, end2);

            int m = end2 - begin1 + 1;
            int j = begin1;
            while (begin1 <= end1 && begin2 <= end2)
            {
                if (a[begin1] < a[begin2])
                {
                    tmp[j++] = a[begin1++];
                }
                else
                {
                    tmp[j++] = a[begin2++];
                }
            }

            while (begin1 <= end1)
            {
                tmp[j++] = a[begin1++];
            }

            while (begin2 <= end2)
            {
                tmp[j++] = a[begin2++];
            }

            //把 归并数据 拷贝回 原数组
            memcpy(a + i, tmp + i, sizeof(int) * m);
        }

        gap *= 2;
    }
    
    free(tmp);
}

// 计数排序 => 适合范围集中的
//   时间复杂度  O(max（range, N）)
//   空间复杂度  O(range)
void CountSort(int* a, int n)
{
    //1.统计每个数据出现的次数
    //2.排序  （按出现次数写回原数组）
    //局限性！！！
    //  1..如果是浮点数，字符串就不行了
    //  2..如果数据范围很大，空间复杂度就会很高
    //   =>不使用绝对映射，用相对映射

    //找  max  min
    int min = a[0], max = a[0];
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < min)
        {
            min = a[i];
        }

        if (a[i] > max)
        {
            max = a[i];
        }
    }

    //统计次数的数组
    int range = max - min - 1;
    int* count = (int*)malloc(sizeof(int) * range);
    if (count == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    memset(count, 0, sizeof(int) * range);

    //统计次数
    for (int i = 0; i < n; ++i)
    {
        count[a[i] - min]++;
        //为了让数组min以前的位置不空缺(min以前的位置百分百空缺)
    }

    //回写-排序
    int j = 0; 
    for (int i = 0; i < range; ++i)
    {
        //出现几次就会回写几个  i+min
        while (count[i]--)
        {
            a[j++] = i + min;
        }
    }
}

//测试

Test.c

#define _CRT_SECURE_NO_WARNINGS
#include "Sort.h"
#include "Stack.h"

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

void TestShellSort()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    ShellSort(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

TestSelectSort()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    SelectSort(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestBubbleSort()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    BubbleSort(a, sizeof(a) / sizeof(int));
    BubbleSort(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestPartSort1()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    PartSort1(a, 0, sizeof(a) / sizeof(int)-1);
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestPartSort2()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    PartSort1(a, 0, sizeof(a) / sizeof(int) - 1);
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestPartSort3()
{
    int a[] = { 9,1,2,5,7,4,8,6,3,5 };
    PartSort1(a, 0, sizeof(a) / sizeof(int) - 1);
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestQuickSort()
{
    int a[] = { 6,1,2,7,9,3,4,5,10,8 };
    QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestMergeSort()
{
    int a[] = { 10,6,7,1,3,9,4,2,5 };
    MergeSort(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

void TestMergeSortNonR()
{
    int a[] = { 10,6,7,1,3,9,4,2,5 };
    MergeSortNonR(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

void CountSort()
{
    int a[] = { 10,15,19,10,15,14,18,10,-5,-5,-8,-8 };
    CountSort(a, sizeof(a) / sizeof(int));
    PrintArray(a, sizeof(a) / sizeof(int));
}

// 测试排序的性能对比
void TestOP()
{
    srand(time(0));
    const int N = 100000;
    int* a1 = (int*)malloc(sizeof(int) * N);
    int* a2 = (int*)malloc(sizeof(int) * N);
    int* a3 = (int*)malloc(sizeof(int) * N);
    int* a4 = (int*)malloc(sizeof(int) * N);
    int* a5 = (int*)malloc(sizeof(int) * N);
    int* a6 = (int*)malloc(sizeof(int) * N);
    int* a7 = (int*)malloc(sizeof(int) * N);
    for (int i = 0; i < N; ++i)
    {
        a1[i] = rand();
        a2[i] = a1[i];
        a3[i] = a1[i];
        a4[i] = a1[i];
        a5[i] = a1[i];
        a6[i] = a1[i];
        a7[i] = a1[i];
    }
    int begin1 = clock();
    InsertSort(a1, N);
    int end1 = clock();
    int begin2 = clock();
    ShellSort(a2, N);
    int end2 = clock();
    int begin3 = clock();
    SelectSort(a3, N);
    int end3 = clock();
    int begin4 = clock();
    //HeapSort(a4, N);
    int end4 = clock();
    int begin5 = clock();
    QuickSort(a5, 0, N - 1);
    int end5 = clock();
    int begin6 = clock();
    //MergeSort(a6, N);
    int end6 = clock();

    printf("InsertSort:%d\n", end1 - begin1);
    printf("ShellSort:%d\n", end2 - begin2);
    printf("SelectSort:%d\n", end3 - begin3);
    printf("HeapSort:%d\n", end4 - begin4);
    printf("QuickSort:%d\n", end5 - begin5);
    printf("MergeSort:%d\n", end6 - begin6);

    printf("callCount:%d\n", callCount);

    free(a1);
    free(a2);
    free(a3);
    free(a4);
    free(a5);
    free(a6);
}

int main()
{
    TestInsertSort();
    TestShellSort();
    TestSelectSort();
    TestBubbleSort();  
    TestPartSort1();
    TestPartSort2();
    TestPartSort3();
    TestMergeSort();
    TestMergeSortNonR();
    CountSort();

    TestOP();
    
    return 0;
}