C++数据结构和算法：排序算法

为了便于测试，先写一个生成随机数组的方法。

pair<int*,int> GenerateRandomArray(int maxSize, int maxValue, int minValue)
{
    //随机数组长度
    const int len = rand()%maxSize+1;
    int* arr = new int[len];
    
    for (int i = 0; i < len; i++)
    {
        arr[i] = rand()%(maxValue-minValue+1)+minValue;
    }
    return make_pair(arr,len);
}

返回值（数组，数组长度）

 

//////////冒泡排序//////////

第一轮：从第0位开始，依次比较 i 和 i+1 位，把大的换到 i+1 位，一直比较到 i+1 = N

第二轮：从第0位开始，依次比较 i 和 i+1 位，把大的换到 i+1 位，一直比较到 i+1 = N-1

......

第N-1轮：从第0位开始，比较 0 和 1 位，大的换到第1位，比较结束。

void BubbleSort(int arr[], int N)
{
    for (int i = N-1; i > 0; i--) //第一轮比较了N-1次，第二轮N-2次，...，一直到1次
    {
        for (int j = 0; j < i; j++) //注意最大值是j+1=i，所以要比较到j<i
        {
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
        }
    }
}

 

//////////选择排序//////////

第一轮：从第0位开始，一直到最后一位，找到最小的数，放在第0位

第二轮：从第1位开始，一直到最后一位，找到最小的数，放在第1位

......

第N-1轮：从第N-2位开始，比较第N-2和第N-1位，也就是最后两位，找到最小的放在N-2位，排序结束。

void SelectionSort(int arr[], int N)
{
    for (int i = 0; i < N - 1 ; i++)  //只剩最后一位时不用比较，所以一共比较了N-1次
    {
        int minIdx = i;
        for (int j = i + 1; j < N; j++)  //已经把第i位设为当前最小值，直接从i+1开始比到最后一位
        {
            if (arr[j] < arr[minIdx])
                minIdx = j;
        }
        swap(arr[minIdx], arr[i]);
    }
}

 

//////////插入排序//////////

第一轮：从第1位往前到第0位，逐次比较，把更小的换到左边，共比较1次。

第二轮：从第2位往前到第0位，逐次比较，把更小的换到左边，共比较2次。

......

第N-1轮：从第N-1位往前到第0位，逐次比较，把更小的换到左边，共比较N次。

===>外循环：i：1~N-1；

===>内循环：j：i~0；

最简单的可以类比扑克牌抽牌理牌，每抽起来一张牌都从右往左一一比较，然后插入到合适位置。

void InsertionSort(int arr[], int N)
{
    for (int i = 1; i < N; i++)
    {
        for (int j = i - 1; j >= 0; j--)
        {
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
        }
    }
}

 

时间复杂度：冒泡、选择、插入的时间复杂度都为O(N²)

下面介绍两种时间复杂度为O(NlogN)的算法：归并排序、快速排序（最坏情况是O(N²)）

在此之前，先介绍递归

//////////递归//////////

Q. 在[L,R]范围内找最大值

int MaxValue(int arr[], int L, int R)
{
    //[L,R] 只有1个数时，直接返回这个数
    if (L == R)
        return arr[L];
    int mid = L + ((R - L) >> 1);
    int leftMax = MaxValue(arr, L, mid);
    int rightMax = MaxValue(arr, mid + 1, R);
    return max(leftMax, rightMax);
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

小技巧：如何选取中间节点？

mid = ( L + R ) / 2 ???    × 当数字特别大时，L+R可能会溢出

mid = L + ( R - L ) / 2     √ 避免溢出

还可以效率更高：mid = L + (R - L) >> 1 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tips. 不建议用递归，容易栈溢出

∵ 每当程序执行一个函数调用，就会增加一层栈帧，当函数返回才会减一层栈帧。递归调用达到结束点才会退栈清栈。

∴ 可以用动态规划代替递归 或 修改栈的大小

//////////归并排序//////////

void Merge(int arr[], int low, int mid, int high)
{
    int i = low, j = mid + 1;
    vector<int> tmpArr;
    while (i <= mid && j <= high)
    {
         if (arr[i] < arr[j])
            tmpArr.push_back(arr[i++]);
        else
            tmpArr.push_back(arr[j++]);
          }
    while (i <= mid)
        tmpArr.push_back(arr[i++]);
    while (j <= high)
        tmpArr.push_back(arr[j++]);
    for (int n = 0; n <= high-low; n++)
        arr[low+n] = tmpArr[n];
}

//归并排序
void MergeSort(int arr[],int L, int R)
{
    if (L >= R)    return;
    int mid = L + ((R - L) >> 1);
    MergeSort(arr,L, mid);                 //左边排好序
    MergeSort(arr,mid + 1, R);             //右边排好序
    Merge(arr, L, mid, R);                 //整体有序
}

 

Q. 荷兰国旗问题：给定一个数组arr，和一个数num，把小于num的数放在数组左边，等于num的数放在中间，大于num的数放右边，要求空间复杂度O(1)，时间复杂度O(N)

思路：最左和最右两个指针i,j，指向当前位置的cur，从左往右依次遍历，如果比num大就跟j交换位置，j--；如果比num小就跟i交换位置，i++，cur++；如果等于num不用交换直接cur++。

void QuickSort1(int arr[], int len, int num)
{
    int i = 0;  //小于区域指针
    int j = len-1;  //大于区域指针
    int cur = 0;    //当前指针

    while (cur < j)
    {
        if (arr[cur] < num)
        {
            swap(arr[cur], arr[i]);
            i++;
            cur++;
        }
        else if (arr[cur] == num)
            cur++;
        else
        {
            swap(arr[cur], arr[j]);
            j--;
        }
    }
}

 

//////////快速排序//////////

void QuickSort(int arr[], int L, int R)
{
    int i = L;
    int j = R;
    int temp = arr[i];   //基准值
    if (i >= j)    return;
    while (i < j)
    {
        while (i < j && arr[j] >= temp)    j--;   //从右往左找到比基准值小的值
        if (i < j)
            arr[i++] = arr[j];  //将找到的比基准值小的数换到左边
        while (i < j && arr[i] <= temp)    i++;  //从左往右找到比基准值大的数
        if (i < j)
            arr[j--] = arr[i];  //将找到的比基准值大的数换到右边
        arr[i] = temp;  //最后把基准数放在i位置
    }
    QuickSort(arr, L, i - 1);
    QuickSort(arr, i + 1, R);
}

 

///大根堆///

堆逻辑上是一棵完全二叉树

    0                           i 的左孩子序号是：2i+1

 1     2                            右孩子序号是：2i+2

3 4  5 6                          父节点序号是：(i-1)/2

每一棵子树的最大值是根节点，小根堆同理。

void HeapInsert(int arr[], int index)
{   
    while (arr[index] > arr[(index - 1) / 2])  //比父节点大则交换
    {
        swap(arr[index], arr[(index - 1) / 2]);
        index = (index - 1) / 2;    //继续向上检查父节点
    }
}
int main()
{
        for (int i = 0; i < len; i++)
            HeapInsert(arr, i);    
}

eg. 原始数组： 26 31 48 8 22

按大根堆插入之后：48 26 31 8 22

      26                        48

  31   48      ==>     26    31

8  22                    8   22

 上面介绍了如何向上检查是否是大根堆，下面介绍如何向下检查：

void Heapify(int arr[], int index, int heapsize)
{
    int left = index * 2 + 1;   //左孩子的下标
    while (left < heapsize)    //如果左孩子下标没有越界，说明有左孩子
    {
        //比较左右孩子谁大赋给largest
        int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
        //比较大孩子跟父亲谁大赋给largest
        largest = arr[largest] < arr[index] ? index : largest;
        //如果父节点最大，不用交换，退出循环
        if (largest == index)  break;  
        //更大孩子与父节点交换位置，继续向下检查是否是大根堆
        swap(arr[largest], arr[index]);
        index = largest;
        left = index * 2 + 1;
    }
}

//////////堆排序//////////

void HeapSort(int arr[], int heapSize)
{
    if (arr == nullptr || heapSize < 2)
        return;
    //向上检查大根堆，结果是最大的数排在根节点
    for (int i = 0; i < heapSize; i++)   //O(N)
        HeapInsert(arr, i);              //O(logN)

    //把最大的数放到最后，heapSize理解为未排序的堆大小
    swap(arr[0], arr[--heapSize]);

    while (heapSize > 0)               //O(N)
    {
        //向下检查大根堆，会把未排序最大值排到根节点
        Heapify(arr, 0, heapSize);    //O(logN)
        //交换根节点与未排序末尾
        swap(arr[0], arr[--heapSize]);
    }
}  

时间复杂度：O(NlogN)

过程演示：

         7                                           28            

    27    28   ==HeapInsert==>    7    27   

4                                              4                     

                                              4                                                

==heapSize=3,Swap==>   7    27    

                                       28

                                 27                                                                                                     

==Heapify==>     7       4     

                      28                          

                                                 4      

==heapSize=2,Swap==>     7      27  

                                        28             

                                7      

==Heapify==>    4     27   

                       28  

                                               4   

==heapSize=1,Swap==>   7     27   

                                       28   

                              4              

==Heapify==>  7     27  

                     28      

                                              4   

==heapSize=0,Swap==>  7     27

                                     28

 

//////////基数排序//////////

 原理：arr = {1,35,100,40,19} 

数组中最大元素是3位（100），所以执行轮数是3轮

0~9 十个桶，每次按第i位数去装桶，再按先进先出原则输出顺序。

第一轮，比较 i=1 位

             40

            100  1                     35                    19

bucket：0    1    2    3    4    5    6    7    8    9

输出：100 40 1 35 19

第二轮：比较 i=2 位

              1

            100  19       35   40

bucket：0    1    2    3    4    5    6    7    8    9

输出：100 1 19 35 40

第三轮：比较 i=3 位

             40

             35

             19

              1   100  

bucket：0    1    2    3    4    5    6    7    8    9

输出：1 19 35 40 100 

找到最大位数：

int MaxBits(int arr[], int len)
{
    int max = 0;
    for (int i = 0; i < len; i++)
        max = max > arr[i] ? max : arr[i];
    int res = 0;
    while (max != 0)
    {
        res++;
        max /= 10;
    }
    return res;
}

 获取数字x的第d位数：

int GetDigit(int x, int d)
{
    return ((x / (int)pow(10, d - 1)) % 10);
}

长度为1不用排直接返回，否则进行基数排序：

void RadixSort(int arr[],int len)
{
    if (arr == nullptr || len < 2)
        return;
    RadixSort(arr, 0, len, MaxBits(arr, len));
}

基数排序：每轮排序用到了键索引计数法（参考 上一篇字符串相关算法）

void RadixSort(int arr[], int L, int R, int digit)
{
    int i = 0, j = 0;
    vector<int> bucket;
    for (int i = 0; i < R; i++)
        bucket.push_back(0);

    //根据最大位数确定轮数
    for (int d = 1; d <= digit; d++)
    {
        int count[10] = { 0 };  //用于计算出现频率，count[i]代表d位≤i的数有多少个
        for (int i = L; i <= R; i++)
        {
            j = GetDigit(arr[i], d);
            count[j]++;
        }
        for (int i = 1; i < 10; i++)
            count[i] += count[i - 1];

        for (i = R-1; i >= L; i--)
        {
             j = GetDigit(arr[i], d);
            bucket[count[j] - 1] = arr[i];
            count[j]--;
        }
        for (int i = L, j = 0; i < R; i++, j++)
            arr[i] = bucket[j];
    }
}

Tips. 上面这段代码函数返回时报count数组附近栈去损坏，还没找到原因

 

排序稳定性：不因为排序而改变相对次序就是稳定，比如 1 2 1 3，排序后 1 1 2 3，排序后的第一个1在原来的数组里也是第1个1，两个1的相对位置不变。

稳定的排序：冒泡、插入、归并、桶排序

不稳定的排序：选择、快排、堆排序

那么这个属性有什么用呢？比如多条件排序，先用了按时间排序，对于稳定的排序，再按下按价格排序，就会把最近最便宜的排在最上面，但如果用了不稳定的排序，那么添加第二个条件的时候最便宜的在最上面，但不一定是时间最近的了。