排序失败。退出代码: 0x1_C/C++后台开发学习笔记(一)-排序算法(上)

一、排序介绍

排序算法有很多，比较基础的有下列10种：

• 冒泡排序
• 选择排序
• 插入排序
• 希尔排序
• 归并排序
• 快速排序
• 堆排序
• 计数排序
• 桶排序
• 基数排序

排序算法还可以根据其稳定性，划分为稳定排序和不稳定排序。

即如果值相同的元素在排序后仍然保存着排序前的顺序，则这样的排序算法是稳定排序；如果值相同的元素在排序后打乱了排序前的顺序，这样的排序算法是不稳定排序。

例如下面的例子：

根据在排序过程中待排序的记录是否全部被放置在内存中，排序分为内排序和外排序。（我都不是很了解外排序，不在内存中的意思）

二、冒泡排序

冒泡排序思想，我们要把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换他们的位置（要把大的元素移动到右则），当一个元素小于右则相邻元素时，不动（大的元素在右边）。下面详细过程：

上面是冒泡排序的基本思路，一共需要两个for循环，内循环把较大的数移动到右侧，外循环是一共有8个数，都要循环一边才能把8个数排序，下面是代码部分：

/**
  * @brief  冒泡排序1
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int bubble_sort1(int *base, int len)
{
    int i = 0 , j = 0;
    int temp;
    for(i=0; i<len-1; i++)   //外循环，一共循环n-1
    {
        for(j=0; j<len-i-1; j++)	//内循环，一共循环n-i-1
        {
           if(base[j] > base[j+1])
           {
               temp = base[j];
               base[j] = base[j+1];
               base[j+1] = temp;
           }
        }
    }

    return 0;
}

这一个冒泡排序是按步就班的排，没有做优化，下面有冒泡排序的优化版：

如上图，可以看出只需要一次循环即可，如果用bubble_sort1()就还是要循环(n-1)*(n-i-1)次，这样明显性能不好，所以需要添加一个标志位，如果数据在一个循环中，判断已经是有序的了，就不需要再循环了，代码如下：

/**
  * @brief  冒泡排序2
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int bubble_sort2(int *base, int len)
{
    int i = 0 , j = 0;
    int temp;
    int flag = 1;       //1是有序的
    for(i=0; i<len-1; i++)
    {
        flag = 1;       //初始默认是有序的
        for(j=0; j<len-i-1; j++)   //进入循环
        {
           if(base[j] > base[j+1])
           {
               flag = 0;                //这次循环无序的，标志置0
               temp = base[j];
               base[j] = base[j+1];
               base[j+1] = temp;
           }
        }
        if(flag == 1)               //如果是有序的就退出
            break;
    }

    return 0;
}

冒泡排序是不是优化到这里就为止了呢？其实不是，下面还有一个例子可以继续优化：

由上图可以发现，其实右边的数据已经排好序了，然后冒泡算法还是要继续循环排序，性能不好，所以可以记录一下无序数列的边界，再往后就有序了，这个无序数列边界就是每一轮之后交换的那个数，就是无序数列边界了，代码如下：

/**
  * @brief  冒泡排序3，在2的基础上，优化了右侧有序就不用循环了
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int bubble_sort3(int *base, int len)
{
    int i = 0 , j = 0;
    int k = 0;
    int temp;
    int flag = 1;       //1是有序的
    int sort_border = len-1;
    int sort_border_temp = sort_border;
    for(i=0; i<len-1; i++)
    {
        flag = 1;       //初始默认是有序的
        sort_border_temp = sort_border;  //每次循环完一次之后，要更新下次循环的次数
        for(j=0; j<sort_border_temp; j++)   //进入循环,循环判断条件
        {
           if(base[j] > base[j+1])
           {
               flag = 0;                //这次循环无序的，标志置0
               temp = base[j];
               base[j] = base[j+1];
               base[j+1] = temp;
               sort_border = j;
               
           }
        }
         printf("sort_border %d %dn", sort_border, j);
        if(flag == 1)               //如果是有序的就退出
            break;
    }

    return 0;
}

经过了两次优化了冒泡算法，在有些时候效果是提升了。不过还真不容易啊，冒泡排序还有这么多事情可以搞。

三、 选择排序

选择排序的基本思想是，遍历一遍查找数列里面最小的值，然后跟第一个值交换，然后继续第二轮遍历，查找第二小的值，然后跟第二个值交换，一直这样继续操作，整体遍历完数列就已经排好序了。下面来个图示：

选择排序也需要两个for循环，外for循环n-1次，负责把数据放好，内for循环n-i-1次，负责寻找到档次最小的值，然后进行交换，代码如下：

/**
  * @brief  选择排序
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int select_sort(int *base, int len)
{
    int i = 0 , j = 0;
    int small_index = 0;
    int temp = 0;

    for(i=0; i<len-1; i++)
    {
        //small = base[i];            //每次循环，获取当前i上的值，作为默认最小值
        small_index = i;
        for(j=i+1; j<len; j++)        //进入循环,循环判断条件  因为 i已经在移动了，所以j<len就这样
        {
           if(base[j] < base[small_index])
           {
               //small = base[j];
               small_index = j;
           }
            printf("sort_border %d %dn", small_index, j);
        }
       
        if(i != small_index)
        {
            temp = base[i];
            base[i] = base[small_index];
            base[small_index] = temp;             
        }
    }

    return 0;
}

选择排序的好处就是交换少，这样也是提升性能的一种方法。

四、插入排序

插入排序，就想是我们玩扑克牌的时候，进行理牌，刚摸到一张牌，就找好这张牌的位置，然后插入。例如：

第一次摸到5，因为只有一个，所以不排序，第二次摸到8，8比5大，所以排在5的右边，第三次摸到6，6比8小，所以需要插入，然后6又比5大，所以插入到5和8之间，第四次摸到3，因为3比5，6，8都少，所以插入到5的左边，以此类推，即可完成排序。

但是在程序中，不能直接插入，需要申请一个临时变量，保存刚摸到的牌，然后拿刚摸到的牌和已经排好序的牌比较，如果刚摸的牌小，拿原来的牌往后移动一位，预留出空间，一直查到比刚摸的牌小的数字，然后就插入到这里位置。即可完成代码。

/**
  * @brief  插入排序
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int insert_sort(int *base, int len)
{
    int i=0, j = 0;
    int temp = 0;
    for(i=1; i<=len-1; i++)
    {      
        temp = base[i];     //刚摸的牌，存储到临时变量
        for ( j=i; temp<base[j-1]; j-- )   //拿到刚摸的牌进行循环判断
        {
            printf("i= %d %d %dn", i, base[j], base[j-1]);
            base[j] = base[j-1];	//刚摸的牌小，那就顺序往后挪一位
        }

        if(j != i)   
        {
            base[j] = temp;   //对比完成后，找到合适的位置插入
        }
    }

    return 0;
}

五、希尔排序

这个希尔排序确实很难理解，我也是搞了很久才理解了一下下，记录一下理解的过程，哈哈。
希尔排序是根据某个增量，来分割成各个子序列，然后在子序列中进行比较和交换，依次循环，还是先上图吧，文字还难描述：

希尔排序的步骤，就是如上图所示，这里我选择的增量是len/2=4，所以第一轮比较是分为
4组，子序列分别是{5，9}，{8，2}，{4，1}和{3，7}。然后在这4个子序列中分别排序小的在左，分别是{5，9}，**{2，8}，{1，4}**和{3，7}。这时数组的序列变成了{5，2，1，3，9，8，4，7}；接下来第二轮，这次选择的增量是4/2=2,上一个增量除以2，这次分为2组，增量为2，子序列分别为：{5，1，9，4}和{2，3，8，7}，然后两个子序列分别排序，排序后变成：{1，4，5，9}和{2，3，7，8}，原数组中的序列变成：{1，2，4，3，5，7，9，8}，再次选择增量2/2=1，这次就分为1组，相当于每一个都比较，其实在这时候序列基本有序了，所以就把基本有序变成有序了。
接下来代码：

/**
  * @brief  希尔排序
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int shell_sort(int *base, int len)
{
    int i=0, j = 0;
    int temp = 0;
    int gap = len;                //增量

    //增量的定义可能不同，我们这里去/2
    for ( gap = len/2; gap >= 1; gap /= 2)  //这个就是增量每次都除以2
    {
        for ( i = gap; i < len; i++)  //这个就是循环移动哨兵
        {       
            temp = base[i];		//临时存储起来
            printf("gap = %d i = %d j = %d base[i] = %d base[j] = %dn", gap, i, i-gap, base[i], base[i-gap]);   //分析打印
            for(j=i-gap; j>=0 && temp<base[j]; j-=gap)
//上面就是在哨兵变化的时候，j跟着变，每次都是比哨兵-gap，这样就形成了分组对比
//temp<base[j]  就行进行比较，如果temp小的话，就要跟前面的交换，
//j-=gap 这个是因为在一个组里，会有几个元素，所以需要往前把前面的元素也对比了
            {
                printf("for gap = %d i = %d j = %d base[i] = %d base[j] = %dn", gap, j+gap, j, base[j+gap], base[j]);   //分析打印
                base[j+gap] = base[j];     
//temp比前面那个元素小，所以把前面的元素填充到j+gap的位置。这个需要自己跟据打印分析
            }
            base[j+gap] = temp;   //把temp填充到他自己的位置
            bianli(base);	//这个也是分析打印的，是打印真的数组的元素
        }
    }

    return 0;
}

下面把程序运行的打印粘贴出来，再分析分析，确实不好理解：

# 第一轮分组，增量为4
gap = 4 i = 4 j = 0 base[i] = 9 base[j] = 5  #  下标  4 0 比较
5 8 4 3 9 2 1 7 
gap = 4 i = 5 j = 1 base[i] = 2 base[j] = 8  #  下标  5 1 比较  
for gap = 4 i = 5 j = 1 base[i] = 2 base[j] = 8	#temp小进行交换
5 2 4 3 9 8 1 7 
gap = 4 i = 6 j = 2 base[i] = 1 base[j] = 4  #  下标  6 2 比较  
for gap = 4 i = 6 j = 2 base[i] = 1 base[j] = 4  #temp小进行交换
5 2 1 3 9 8 4 7 
gap = 4 i = 7 j = 3 base[i] = 7 base[j] = 3	 #  下标  7 3 比较
5 2 1 3 9 8 4 7 
# 第二轮分组，增量4/2=2
gap = 2 i = 2 j = 0 base[i] = 1 base[j] = 5   #  下标  2 0 比较
for gap = 2 i = 2 j = 0 base[i] = 1 base[j] = 5  #temp小进行交换
1 2 5 3 9 8 4 7 
gap = 2 i = 3 j = 1 base[i] = 3 base[j] = 2  #  下标  3 1 比较
1 2 5 3 9 8 4 7 
gap = 2 i = 4 j = 2 base[i] = 9 base[j] = 5  #  下标  4 2 比较
1 2 5 3 9 8 4 7 
gap = 2 i = 5 j = 3 base[i] = 8 base[j] = 3  #  下标  5 3 比较
1 2 5 3 9 8 4 7 
gap = 2 i = 6 j = 4 base[i] = 4 base[j] = 9  #  下标  6 4 比较
for gap = 2 i = 6 j = 4 base[i] = 4 base[j] = 9  #temp小进行交换
for gap = 2 i = 4 j = 2 base[i] = 9 base[j] = 5  #temp现在是再4，结果比前面的2还小，需要继续交换，这时候赋值的j+gap就很巧妙，下面差不多了，就不分析了
1 2 4 3 5 8 9 7 
gap = 2 i = 7 j = 5 base[i] = 7 base[j] = 8
for gap = 2 i = 7 j = 5 base[i] = 7 base[j] = 8
1 2 4 3 5 7 9 8 
gap = 1 i = 1 j = 0 base[i] = 2 base[j] = 1
1 2 4 3 5 7 9 8 
gap = 1 i = 2 j = 1 base[i] = 4 base[j] = 2
1 2 4 3 5 7 9 8 
gap = 1 i = 3 j = 2 base[i] = 3 base[j] = 4
for gap = 1 i = 3 j = 2 base[i] = 3 base[j] = 4
1 2 3 4 5 7 9 8 
gap = 1 i = 4 j = 3 base[i] = 5 base[j] = 4
1 2 3 4 5 7 9 8 
gap = 1 i = 5 j = 4 base[i] = 7 base[j] = 5
1 2 3 4 5 7 9 8 
gap = 1 i = 6 j = 5 base[i] = 9 base[j] = 7
1 2 3 4 5 7 9 8 
gap = 1 i = 7 j = 6 base[i] = 8 base[j] = 9
for gap = 1 i = 7 j = 6 base[i] = 8 base[j] = 9
1 2 3 4 5 7 8 9

1.6 归并排序

归并排序是利用归并的思想实现的排序方法。不多说 ，先上图：

归并排序就是先把整个序列进行拆分，直到拆分成每个元素一组的时候，上图第一轮到第三轮的时候就是进行拆分的，拆分完成之后，就可以进行归并排序了，从第四轮开始，相邻的两组进行归并，并且排序，所以就形成了第四轮的样子，归并成了4组，然后继续归并，这次归并成了两组，变成了第五轮，然后继续归并成一组，就排完序，这次的图描述的很形象了，不需要在用语言描述了，下面来看代码：

/**
  * @brief  归并
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
static int merge(int *base, int *temp, int start, int middle, int end)
//需要归并的数组，这个数组是有2个，一个是start -> middle  一个是middle+1 -> end
{
    int i = 0, j = 0,k = start;
    
    printf("merge %d %d %dn", start, middle, end);
    //归并
    for(i=start, j=middle+1; i<=middle && j<=end; k++)  //i=0, j=1;   
    //两个数组的下标同时移位，并且判断那个比较小，小的存储到temp这个临时数组中
    {
        if(base[i] < base[j])       //如果是i的小，就保存到temp中
        {
            temp[k] = base[i++];
        }
        else						//如果是j的小，也保存到temp中
        {
            temp[k] = base[j++];
        }
    }

    while(i<=middle)    //有可能一个j的数组比较小，都拷贝完了，i的数组还没拷贝完，所以需要继续拷贝
    {
        temp[k++] = base[i++];
    }

    while(j<=end)		//有可能一个i的数组比较小，都拷贝完了，j的数组还没拷贝完，所以需要继续拷贝
    {
        temp[k++] = base[j++];
    }

    //需要拷贝回到data中,这里是借助了临时变量temp，但是数据还是要拷贝到base里，返回的
    for(i=start; i<=end; i++)
    {
        base[i] = temp[i];
    }

    bianli(base);
    return 0;
}

/**
  * @brief  归并排序
  * @param  base: 数据的基地址
  *         len : 数据的长度
  * @retval 成功返回0，失败返回负数
  */
int merge_sort(int *base, int *temp, int start, int end)   //因为是递归代码，所以需要每次传参的时候，要传开始和结束下标
{
    //start开始下标，end结束下标
    int middle; 
    printf("start %d %dn", start, end);
    if(start < end)      //判断递归结束条件，这个就相当于一个元素一组的时候了
    {
        middle = start + (end-start)/2;   //计算中间middle的值
        printf("middle %d %d %dn", start, middle, end);    //分析打印
        merge_sort(base, temp, start, middle);  // 0 3  0 1    0 0   //开始递归  左边的注释就是递归的start和middle的值
        printf("end %d %d %dn", start, middle+1, end);    //分析打印
        merge_sort(base, temp, middle+1, end);   //  4 7  2 3   1 1  //开始递归  左边的注释就是递归的middle+1和end

        //排序，倒序归并排序
        printf(">>>>>>>>>>>>>>>>n");
        merge(base, temp, start, middle, end);   //进行归并并排序
    }
    printf("返回 n");
    return 0;
}
代码分析就这么多了，这种递归的代码确实比较难理解，可以通过程序打印来继续分析：
# 分析递归，还是先抓住返回的时候，返回的时候我已经打印了
start 0 7          # 开始传参，我们数组下标范围就是  0  -- 7
middle 0 3 7          # 进行拆分
start 0 3               # 前半段（1前），进行递归，所以范围只有  0 -- 3
middle 0 1 3
start 0 1					# 前半段的前半段在进行递归，（2前） 这次的范围更小了  0  -- 1
middle 0 0 1
start 0 0						# 前半段的前半段的前半段（3前） 在进行递归，范围是 0 -- 0 因为这次是一个元素了，所以递归返回
返回 
end 0 1 1                       # 返回到前半段的前半段的后半段进行递归（3后）  范围是 1 -- 1
start 1 1						#这次也是一个元素了，所以递归返回
返回 
>>>>>>>>>>>>>>>>                # 第一次进行归并排序
merge 0 0 1						#  排序的范围是 0 - 1  ，也就是2前，（对应的图是5，8）
5 8 4 3 9 2 1 7 
返回 						
end 0 2 3					#返回前半段的后半段（2后），这次的范围是2 -- 3
start 2 3						
middle 2 2 3					#前半段的后半段的前半段开始递归 ，范围是 2 -- 2 
start 2 2
返回 
end 2 3 3					    #前半段的后半段的后半段开始递归 ，范围是 3 -- 3 
start 3 3
返回 
>>>>>>>>>>>>>>>>
merge 2 2 3						# 开始归并，对应的图的 （4，3）
5 8 3 4 9 2 1 7 
返回 
>>>>>>>>>>>>>>>>			# 前半段开始归并 范围 0 -- 3  对应的是（5，8，3，4）
merge 0 1 3
3 4 5 8 9 2 1 7 
返回 
end 0 4 7				
start 4 7				# 开始后半段的递归了  4 -- 7
middle 4 5 7				# 后半段的前半段开始递归  4 -- 5
start 4 5
middle 4 4 5					# 后半段的前半段的前半段， 4 -- 4 
start 4 4
返回 
end 4 5 5						# 后半段的前半段的后半段， 5 -- 5
start 5 5
返回 
>>>>>>>>>>>>>>>>				
merge 4 4 5						# 递归返回，并归并排序，对应图的（2，9）
3 4 5 8 2 9 1 7 
返回 
end 4 6 7					# 后半段的后半段开始递归  6 -- 7
start 6 7
middle 6 6 7					# 后半段的后半段的前半段 6 -- 6
start 6 6
返回 
end 6 7 7						# 后半段的后半段的后半段 7 -- 7
start 7 7
返回 
>>>>>>>>>>>>>>>>
merge 6 6 7						# 递归完成，并归并排序，对应图（1，7）
3 4 5 8 2 9 1 7 
返回 
>>>>>>>>>>>>>>>>			# 后半段开始归并，对应的图（2，9，1，7）
merge 4 5 7
3 4 5 8 1 2 7 9 
返回 
>>>>>>>>>>>>>>>>		# 最后两组归并并排序 对应着（3，4，5，8  1，2，7，9）
merge 0 3 7
1 2 3 4 5 7 8 9 
返回

这个递归确实有点难理解，不过慢慢分析还是可以的。

---

下一篇：C/C++后台开发学习笔记(二)-排序算法(下)

首先恭喜您，能够认真的阅读到这里，如果对部分理解不太明白，建议先将文章收藏起来，然后对不清楚的知识点进行查阅，然后在进行阅读，相应你会有更深的认知。如果您喜欢这篇文章，就点个赞或者【关注我】吧！！