五种排序算法（选择、冒泡、归并、快排、插入）的思路和代码。

最新推荐文章于 2025-02-22 20:01:49 发布
最新推荐文章于 2025-02-22 20:01:49 发布
阅读量1.4k 收藏 16
点赞数
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45742441/article/details/114674586
版权

Code/C++

选择排序

**第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。**以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
–《百度百科》

伪代码：（注意是伪代码，源码在最后！）
void select_sort( *array, size){
    for i=1 to size
        min = i;          //min记录最小值下标
        for j=i to size
            if(array[min]>array[j])
               min = j;
        }
        swap(array[i],array[min]);
}

举例： 34 56 23 65 77 90 12 56
第一轮：（12）（34 56 23 65 77 90 56）
第二轮：（12 23）（34 56 65 77 90 56）
第三轮：（12 23 34）（56 65 77 90 56）
第四轮：（12 23 34 56）（65 77 90 56）
第五轮：（12 23 34 56 56）（65 77 90）

冒泡排序

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
    –《百度百科》

伪代码：

伪代码：（注意是伪代码，源码在最后！）
void bubble_sort(*array, size){
    for i=0 to size
        for j=1 to size-i
            if(array[j-1]>array[j])
               swap(array[j-1],array[j]);
}

举例： 34 56 23 65 77 90 12 56
第一轮： 34 23 56 65 77 12 56 90
第二轮： 23 34 56 65 12 56 77 90
第三轮： 23 34 56 12 56 65 77 90
第四轮： 23 34 12 56 56 65 77 90
第五轮： 23 12 34 56 56 65 77 90
······

归并排序

  1. 将序列上每相邻的两个数字进行排序，
  2. 排序后的n/2 个有序序列每相邻的两个序列进行归并
  3. 重复步骤2，直到整个序列有序。
伪代码：（注意是伪代码，源码在最后！）
void merge_sort( *array,start,end, *result){
    switch(end - start){
        case 1: //只剩两个元素，直接比较排序
               if(array[start]>array[end])
                  swap(array[start],array[end]);
              return；
        case 0://只剩一个元素，已有序，直接返回
              return；
        default
              merge_sort(array,start,(end - start +1)/2+start,result);
              merge_sort(array,(end-start+1)/2+start+1,end,result);
              //合并
              merge(array, start, end, result); //merge函数是自定义的合并两个有序序列的操作
              for i = start to end+1 
                  array[i] = result[i]; 
    }
}

void merge( *array, start, end, *result,){
    //归并,两个有序序列的合并 
     left_length = (end - start + 1) / 2 + 1;    
     left_index = start;
     right_index = start + left_length;
     result_index = start;
    while(left_index<right_index && right_index <end + 1){
        if(array[left_index] <= array[right_index])
            result[result_index++] = array[left_index++];       
        else
            result[result_index++] = array[right_index++];        
    }
    //剩余元素续接在后   
    while(left_index < right_index)
        result[result_index++] = array[left_index++];   
    while(right_index <end+1)
        result[result_index++] = array[right_index++];
}

举例： 34 56 23 65 77 90 12 56
递归逻辑：
Merge_sort（34 56 23 65） Merge_sort（77 90 12 56） //递归进入下一层
Merge_sort（34 56 ）Merge_sort （23 65） Merge_sort（77 90）Merge_sort（12 56）//当括号内只有1或2个数时，递归触底。
Merge（（34 56） （23 65）） Merge(（77 90） （12 56）) //合并已排序列，从头开始，找出较小者。
Merge（（23 34 56 65） （12 56 77 92）） //合并已排序列
（12 23 34 56 56 65 77 92）

快速排序

快速排序（Quicksort）是对冒泡排序算法的一种改进。
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
–《百度百科》

伪代码：（注意是伪代码，源码在最后！）
void QSort(*array, size, low, high){
    //快速排序，递归方法 
    if(low<high)
    {
        pivotloc = Partition(array,size,low,high);//Partition（）函数返回关键字快排一次后的位置
        QSort(array,size,low,pivotloc-1);
        QSort(array,size,pivotloc+1,high);
    }
} 


int Partition( *array, size, low, high){
    //排序一次，找到枢轴所在位置
     key=array[low]; //记录关键字，待排序列第一个数字作为关键字
    while(low<high){
        while(low<high && array[high]>=key)
            --high; 
        array[low] = array[high];
        while(low<high && array[low]<=key)
            ++low;
        array[high] = array[low];
    } 
    array[low] = key;
    return low;
}

举例： 34 56 23 65 77 90 12 56

第一次Partion：key = 34 //黑色加粗是数值发生改变，（) 是枢轴位置。
12 56 23 65 77 90 (12) 56 //
12 (56) 23 65 77 90 56 56
12 23 (23) 65 77 90 56 56 // 枢轴的值比它后面的值都小，无插入，循环结束，修改枢轴位置的值为关键字的值
【12 23】 34 【65 77 90 56 56 】 //可以看到，枢轴进行跳转后，原来位置的值将会进行改变。
对【】内重复排序，最终得到有序序列。
过程略，自行推导。

插入排序

将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表

void insert_sort( *array, size){
伪代码：（注意是伪代码，源码在最后！）
    for i=1 to size
        if(array[i]<array[i-1]){
            key = array[i]; //记录关键字key
            j=i-1;
            while(j>0 && array[j]>key)
                array[j+1]=array[j--]; //数据后移,空出插入位置
        }
        array[j+1]=key; //将关键字插入空位
}

总结

在这里插入图片描述
效率： 插入>选择>冒泡

在这里插入图片描述
快排>归并，因为快排开销更小

举例： 34 56 23 65 77 90 12 56
第一轮： （34） （56 23 65 77 90 12 56）
第二轮： （34 56） （23 65 77 90 12 56）
第三轮： （23 34 56） （65 77 90 12 56）
第四轮： （23 34 56 65） （77 90 12 56）
第五轮： （23 34 56 65 77） （90 12 56）
……

//源码
#include<iostream>
#include<stdlib.h> 
#include "cstring"
#include<time.h>
#include <fstream>   
using namespace std;

void delay(){
	for(int i =0;i<1e8;i++);{
	   for(int j=0;j<1e9;j++);
	   }
	for(int i =0;i<1e8;i++);{
	   for(int j=0;j<1e9;j++);
	   }
} 

int * createTestData(int size){
	//创建随机数组
	srand((int)time(0));
	int* array;
	array = new int [size];
	for(int i = 0;i < size; i++ ){
        array[i] = rand()*rand(); 
    }
    
    return array;
}

void printArray(int *array){
		for(int i =0;i<20;i++){
    	cout<<array[i]<<" "; 
     	}
     	cout<<"......"<<endl;	
} 


//选择排序
void Ssort(int *array,int size){
	for(int i = 0;i<size;i++){
		int min = i;
		for(int j=i;j<size;j++){
			if(array[min]>array[j])
			 min=j;
			
		}
		swap(array[i],array[min]);
	}
} 
 

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


//归并排序
void merge(int *array,int start,int end,int *result,int size) 
{
    int left_length = (end - start + 1) / 2 + 1;    
    int left_index = start;
    int right_index = start + left_length;
    int result_index = start;
    while(left_index<start + left_length && right_index <end + 1)  
    {
        if(array[left_index] <= array[right_index])
        	result[result_index++] = array[left_index++];
            
        else
        	result[result_index++] = array[right_index++];
    }
    while(left_index < start + left_length)
    	result[result_index++] = array[left_index++];
    	
    while(right_index <end+1)
    	result[result_index++] = array[right_index++];
}

void Msort(int *array,int start,int end,int *result,int size)
{
	
	switch(end - start){
		case 1:
			if(array[start] > array[end])
            swap(array[start],array[end]);      
        return;
		case 0:
			 return;
		default:
             Msort(array, start, (end - start + 1) / 2 + start, result,size);
             Msort(array, (end - start + 1) / 2 + start + 1, end, result,size);
            merge(array, start, end, result,size);
            for(int i=start;i<end+1;i++)
               array[i]=result[i];
	}

} 


// 快排
int Partition(int *array, int low, int high){
	int key=array[low]; 
	while(low<high){
		while(low<high && array[high]>=key){
			--high;
		} 
		array[low] = array[high];
		while(low<high && array[low]<=key){
			++low;
		}
		array[high] = array[low];
	}
	array[low] = key;
	return low;
}
void QSort(int *array,int low,int high){
	int pivotloc;
	if(low<high)
	{
		pivotloc = Partition(array,low,high);
		QSort(array,low,pivotloc-1);
		QSort(array,pivotloc+1,high);
	}
} 



//插入排序
void ISort(int *array,int size){
	int key; 
	for(int i=1;i<size;i++)
	{
	
		if(array[i]<array[i-1]){
			int j = i-1;
			key=array[i];
			while(j>=0 && array[j]>key){
				array[j+1]=array[j];	
				j--;
			}
			array[j+1]=key;
		}
	}
}

int main(){
     // 测试逻辑



     return 0；
}
选择排序算法
qq_58341172的博客
01-02 703
选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序的基本思想是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。选择排序的时间复杂度为O(n^2)，其中n为待排序元素的个数。
七大排序算法（Java实现）——冒泡、快排、插入、希尔、选择、堆排、归并
weixin_46356448的博客
04-24 772
*** 交换排序：稳定，O(n^2)* 1. 冒泡排序：* 相邻两个元素两两比较，若逆序则交换* 每一轮会确定一个最大值到它最后的位置上,只需n-1轮排序* 优化：如果某一轮排序从头至尾没有发生交换，说明已经有序，结束* @param array 待排序列*/i < n - 1;i++) { // n-1轮排序j++) { // 每轮会确定一个最值if(array[j] > array[j + 1]) { // 逆序则交换// 本轮发生了交换。
一站式教懂冒泡排序！
Twzdxcxc的博客
02-22 674
希望能对大家有帮助，有什么问题可以直接留言或者私信我。
算法_排序算法_冒泡选择插入归并快速堆_排序应用工具集_1741873718.zip
最新发布
03-15
冒泡排序、选择排序、插入排序、归并排序、快速排序和堆排序是计算机科学中常见的六种基本排序算法。每种算法都有其特点和适用场景，通常作为程序员和数据结构学习者的基础知识。冒泡排序是通过重复遍历要排序的数列...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
十个基础排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、
09-23
1. 冒泡排序：这是一种简单直观的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
Freedom的博客
11-28 1万+
1.2 希尔排序 二.选择排序 2.1 单向选择排序 2.2双向选择排序 2.3 堆排序 堆序详情堆排序 三.交换排序 3.1 冒泡排序 3.2 快速排序 3.2.1 Hoare排序 这里定义一个left为左，right为右，将任意左右位置两边定义一个基准值，根据基准值的大小，直到left为大于基准值数，right为小于基准值数停下，若定义左边为基准值则右边先走，同理右边为基准值左边先走。
排序算法实现代码与伪代码
06-11
本压缩包中包含了各种冒泡算法的代码实现与伪代码实现，附有对排序算法思想的解释，方便读者快速掌握排序算法。
C语言排序算法之简单交换法排序，直接选择排序，冒泡排序
abyiy9580的博客
01-16 1324
　　C语言排序算法之简单交换法排序，直接选择排序，冒泡排序，最近考试要用到，网上也有很多例子，我觉得还是自己写的看得懂一些。 简单交换法排序 1 /*简单交换法排序 2 根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置 3 交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动 4 不稳定 5 */ 6 #i...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鼠不爱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值