排序算法：冒泡排序、插入排序、选择排序

 

目录

 

冒泡排序

插入排序

选择排序

---

冒泡排序

1.算法思想

比较相邻两个元素，如果前一个比后一个大则交换，使最大的一个落到最后位置。

除了最后一个位置，剩下元素重复上述比较和交换，得到次大元素。

重复上述步骤，直到没有元素需要比较。

越大的数会“冒泡”到最后。

2.时间复杂度O(N^2)，额外空间复杂度O(1)，算法稳定

3.实现代码

//冒泡排序 
#include <iostream>
#include <vector>
#include  <stdlib.h>
using namespace std;
vector<int> BubbleSort(vector<int> arr){
	int len=arr.size();
	if(arr.empty()==true || len<2){
		return arr;
	}
	if(arr.empty()==true|| len<2)
	    return arr;
	for(int i=len-1;i>0;i--){
		for(int j=0;j<i;j++){
			if(arr[j]>arr[j+1]){
				int s = arr[j];
				arr[j ]=arr[j+1];
				arr[j + 1] = s;
			//	swap(arr[j],arr[j+1]);
			}
		}
	}
	return arr;
}
int main(void){
	vector<int> obj;
	vector<int> arr;
    int maxvalue=10;
	for(int i=0;i<10;i++) // push_back(elem)在数组最后添加数据 
    {
        obj.push_back(int(rand()%(maxvalue+1)));
        cout<<obj[i]<<" ";    
    }
	arr=BubbleSort(obj);
	for(int j=0;j<arr.size();j++){
		cout<<arr[j]<<endl;
	}
}

int main(void){
	vector<int> obj={8,4,5,3,7,2,6};
	vector<int> arr;
	arr=BubbleSort(obj);
	for(int j=0;j<arr.size();j++){
		cout<<arr[j]<<endl;
	}
}

python实现

#冒泡排序
a=[2,3,1,4,5]
for i in range(len(a)-1,0,-1):
    for j in range(0,i):
        if a[j]>a[j+1]:
            a[j],a[j+1]=a[j+1],a[j]
print(a)

插入排序

1.算法思想

第一个元素当做有序，后面是待排序列；

第一步，第二个元素插入到前一个有序序列，如果第二个值比第一个小则交换；

接着寻找第三元素是否比前两个小，有小于则交换插入到之前没有比其小的位置；

重复上面步骤，如果待排序列的那个值比有序序列的值小，则交换插入到前面没有比其小的位置。依次把待排序列的元素插入到有序序列。

2.时间复杂度O(N^2)，额外空间复杂度O(1)，算法稳定

3.实现代码

//插入排序 
vector<int> insertSort(vector<int> arr){
	if(arr.empty()==true || arr.size()<2){
		return arr;
	}
	for(int i=1;i<arr.size();i++){
		for(int j=i-1;j>=0;j--){
			if(arr[j]>arr[j+1])
	            swap(arr[j],arr[j+1]);
		}
	}
	return arr;
}

python实现

#插入排序
a=[2,3,1,4,5]
for i in range(1,len(a)):
    for j in range(i-1,-1,-1):
        if(a[j]>a[j+1]):
            a[j],a[j+1]=a[j+1],a[j]
print(a)

选择排序

1.算法思想

假设第一个元素是有序，记为最小值；在剩下未排序元素中查找是否有比该最小值最小的值，记录下标，查找完成后交换原先的最小值

此时第一个位置是最小值，重复上述步骤，假设第二个元素是最小值，重复上述查找交换，得第二个位置次小值

重复以上步骤，直到所有元素均排序完毕

2.时间复杂度O(N^2)，额外空间复杂度O(1)，算法不稳定

3.实现代码

vector<int>  selectSort(vector<int> arr){
	if(arr.empty()==true || arr.size()<2){
		return arr;
	}
	for(int i=0;i<(arr.size()-1);i++){
		int min=i;
		//外层循环i的位置放的最小值 
	    for(int j=i+1;j<arr.size();j++){
//	    	min=arr[j]<arr[min]?j:min;  //高级一些 
	    	if(arr[j]<arr[min]){
	            min=j;
			}
		}  
		swap(arr[i],arr[min]);
	}
	return arr;
}

注：外层循环到倒数第二个元素结束，最后一次交换即结束。

python实现

#选择排序
a=[2,3,1,5,4]
for i in range(len(a)-1):
    min=i
    for j in range(i+1,len(a)):
        if(a[j]<a[min]):
            min=j
    a[i],a[min]=a[min],a[i]
print(a)

参考：

左神排序算法