三种排序浅析

一、冒泡排序

• 排序原理
  冒泡排序重复地走访需要排序的元素列表，依次比较两个相邻的元素，如果顺序(如从大到小或从小到大)错误就交换它们的位置。重复地进行直到没有相邻的元素需要交换，则元素列表排序完成。
  在冒泡排序中，值最大(或最小)的元素会通过交换慢慢“浮”到元素列表的“顶端”。就像“冒泡”一样，所以被称为冒泡排序。
• 代码实现(c语言）

/*基本算法
**/
#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void bubbleSort(int* array,int len){
	int i,j;
	for(i =0;i < len - 1;i++){
		for(j = 0; j < len-i-1 ;j++){
			if(array[j]>array[j+1]){//如果从大到小排序，将>改成<;
				swap(&array[j],&array[j+1]);
			}
		}
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
bubbleSort(array,len);
printArray(array,len);
return 0;
}

//优化算法
/*当循环几次后已经排好序，可以用flag来测试每次循环是否在排序，如果没有，跳出循环
*/
#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void bubbleSort(int* array,int len){
	int i,j;
	for(i =0;i < len - 1;i++){
	 int flag = 1;
		for(j = 0; j < len-i-1 ;j++){
			if(array[j]>array[j+1]){
				swap(&array[j],&array[j+1]);
				 flag = 0;
			}
		}
		 if(flag) break;
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
bubbleSort(array,len);
printArray(array,len);
return 0;
}

• 算法分析
  1.该算法的时间复杂度为O(N^2)，算法时间复杂度较高，再实际开发时不建议使用。
  2.该算法的空间复杂度为O(1)，该上述程序涉及的辅助存储空间为temp，辅助存储空间不随N的变化而变化，因此为常数级。
  3.该算法为稳定算法，该算法在相邻元素相同时不会发生交换（设置为>=条件，但这种不稳定性可以通过修改为>条件改为稳定的排序）。

二、选择排序

• 排序原理
  首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 代码实现(c语言）

/*基本算法
**/
#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void selectSort(int* array,int len){
	int i,j;
	for(i =0;i < len - 1;i++){
		int min = i; // int max = i;
		for(j = i + 1; j < len;j++){
			if(array[j]<array[min]){ //if(array[j]>array[max])
				min = j; //max = j;
			}
		}
		swap(&array[i],&array[min]); //swap(&array[i],&array[max]);
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
selectSort(array,len);
printArray(array,len);
return 0;
}

/*优化算法
一般是在一趟遍历中，同时找出最大值与最小值，放到数组两端，这样就能将遍历的趟数减少一半
**/
#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void selectSort(int* array,int len){
	int i,j;
	int left = 0,right = len-1;
	while(left<right){
		int min = left;
		int max = right;
		for( i = left;i <= right; i++){
			if(array[i] < array[min])
			min = i;
			if(array[i] > array[max])
			max = i;
		}
		swap(&array[max],&array[right]);
		if(min == right)
		min = max;
		swap(&array[min],&array[left]);
		left++;
		right--; 
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
selectSort(array,len);
printArray(array,len);
return 0;
}

• 算法分析
  1.该算法的时间复杂度为O(N^2)，算法时间复杂度较高，再实际开发时不建议使用。
  2.该算法的空间复杂度为O(1)，该上述程序涉及的辅助存储空间为temp，辅助存储空间不随N的变化而变化，因此为常数级。
  3.该算法为不稳定算法。假定待排序数组为{3,3,1}，排序后结果为{1,3,3}，原来位于0号下标的3跑到2号下标，因此是不稳定的。

三、插入排序

• 排序原理
• 代码实现(c语言）

//基本算法
#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void insertSort(int* array,int len){
	int i,j;
	for(i = 1;i < len;i++){
		for(j = i - 1; j >=0;j--){
			if(array[j] > array[j+1]){ //if(array[j] < array[j+1])
			swap(&array[j],&array[j+1]); 
			}else{
				break;
			}
		}
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
insertSort(array,len);
printArray(array,len);
return 0;
}

/*优化算法
对于前部分已经排序好的数组，进行折半查找（查找合适的插入位置），这样可以减少比较的次数
**/ 
#include<stdio.h>
#include<stdlib.h>
int binarySearch(int* array,int key,int low,int high){
	int mid = -1;
	while(low <= high){
		mid = (low + high) / 2;
		if(key <= array[mid])
			high = mid - 1;
		else
			low = mid + 1; 
	}
	return low;
}
void printArray(int* array,int len){
	int i;
	for(i = 0;i < len; i++){
		printf("%d ",array[i]);
	}
}
void insertSort(int* array,int len){
	int i,j;
	for(i = 1;i < len;i++){
		int key = array[i];
		int loc = binarySearch(array,key,0,i);
		if(loc != i){
		for(j = i - 1; j >= loc;j--){
			array[j + 1] = array[j];
			}
			array[loc] = key;
		}
	}
}
int main(){
int array[] = {3,4,2,3,6,1,0,9};
int len;
len = sizeof(array)/sizeof(array[0]);
insertSort(array,len);
printArray(array,len);
return 0;
}

• 算法分析
  1.该算法的时间复杂度为O(N^2)，算法时间复杂度较高，再实际开发时不建议使用。
  2.该算法的空间复杂度为O(1)，该上述程序涉及的辅助存储空间为temp，辅助存储空间不随N的变化而变化，因此为常数级。
  3.该算法为稳定算法。