算法【常见的排序算法[简单排序]】

常见的一些排序算法,一些是从书上看的,一些则是参考别人的博客,从杂乱无章的博客里提取实属不易,多谢理解!

1 插入排序算法

1.1 直接插入排序算法

直接插入排序算法的基本思路:把未排序的数据放在一个已排序好的数组里面

算法名称	平均时间复杂度	最差时间分析	空间复杂度	稳定度
直接插入排序	O(n2)	O(n2)	O(1)	稳定

所有排序方法的 main 函数

#include <iostream>
using namespace std;

//直接插入排序 for
void insertFor(int s[], int n);
//直接插入排序 while
void insertWhile(int s[], int n);
//折半插入排序
void halfInsert(int s[], int n);
//冒泡排序
void bubbleSort(int s[], int n);
int main()
{
	int a[11] = {0,8,5,6,3,9,4,2,1,7,10};	//待排序数组
	int aLength = sizeof(a)/sizeof(a[0]);   //待排序数组的长度
	cout<<"before sort"<<endl;
	for(int i =0;i<aLength;i++){
		cout<<a[i]<<"\t";
	}
	bubbleSort(a,aLength);
	cout<<"\nafter sort"<<endl;
	for(int i =0;i<aLength;i++){
			cout<<a[i]<<"\t";
	}
	system("pause");
    return 0;
}

//直接插入排序 while
void insertWhile(int a[], int n){
	//从i=1开始循环,因为这里j是取的i-1
	for(int i =1; i<n; i++){
		//排好的序列在左边,拍好的序列的最大的如果比第i个大的话,就排序.
		if(a[i]<a[i-1]){
			int temp = a[i];  //相当于哨兵,(哨兵:相当于暂存的一个变量)
			int j = i - 1;
			while(j>=0 && a[j]>temp){ //j>=0防止超出数组边界. a[j] > a[i]的时候
				a[j+1] = a[j];
				j--;
			}
			a[j+1] = temp;  //哨兵(暂存的变量)赋给对应位置
		}
	}
}

1.2 折半插入排序

折半插入排序算法的基本思路:跟直接插入排序一样,都是把未排序的数据放在一个已排序好的数组里面.折半插入排序算法相对直接插入排序算法减少了插入位置的寻找比较次数，但是没有减少元素的移动次数，所以排序的时间复杂度没有大的变化，基本和直接插入排序保持一致,在数组比较大时可能会减少时间复杂度。

算法名称	平均时间复杂度	最差时间分析	空间复杂度	稳定度
折半插入排序	O(n2)	O(n2)	O(1)	稳定

//折半插入排序
void halfInsert(int a[],int n){
	int i,j,temp,low,mid,high;
	for(i = 1;i<n;i++){
		temp = a[i];  // 此时的 temp相当于一个哨兵
		low = 0; high = i - 1;
		while(low<=high){  //缩小查找范围
			mid = (low+high)/2;
			if(a[mid] > temp)
				high = mid - 1;
			else 
				low = mid + 1;
		}
		for(j = i;j>low;j--)  //移动次数仍然不变
			a[j] = a[j-1];
 		a[low] = temp; 
	}
}

2 冒泡排序算法

冒泡排序算法的基本思路:重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法名称	平均时间复杂度	最差时间分析	空间复杂度	稳定度
冒泡排序	O(n2)	O(n2)	O(1)	稳定

//冒泡排序

 void bubbleSort(int a[], int n){
	int i,j,temp;
	for(i=0;i<n;i++){
		for(j=i;j<n;j++){
			if(a[i]>a[j]){
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
	}
}  

3 选择排序

选择排序算法的基本思路:首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾.因为每次都选择一个最小(最大)的排序,所以有了这个名字

算法名称	平均时间复杂度	最差时间分析	空间复杂度	稳定度
选择排序	O(n2)	O(n2)	O(1)	不稳定

//选择排序
void selectSort(int a[], int n){
	int i,j,min,temp;
	for(i=0;i<n-1;i++){
		min = i;
		//选择出最小的来
		for(j = i+1;j<n;j++){
			if(a[j]<a[min]){
				min = j;
			}
		}
		//如果最小的和i不相等,换值
		if(min!=i){
			temp = a[i];
			a[i] = a[min];
			a[min]= temp;
		}
	}
}

博客持续更新!!!,多谢关注