数据结构与算法-第七章冒泡，选择，鸡尾酒，插入

		时间复杂度  最坏时间复杂度 空间复杂度	 稳定性
冒泡		n^2 		n^2			 1        稳定 	
选择		n^2			n^2   	     1        不稳定
鸡尾酒       n^2			n^2   	     1        不稳定
直接插入	    n^2         n^2          1        稳定
折半插入		n^2         n            1        稳定

冒泡排序

void bubbleSort(int arr[],size_t len){
	for(int i=0;i<len-1;i++){
		bool isSwap = false;
		for(int j=1;j<len-i;j++){
			if(arr[j]<arr[j-1]){
				swap(&arr[j],&arr[j-1]);	
				isSwap = true;
			}
		}
		if(!isSwap){//在一次循环过程中没有交换任意两个值 说明数组已经有序
			break;
		}
	}	
}

选择排序

void selectSort(int arr[],size_t len){
	for(int i=0;i<len-1;i++){
		int mvIndex = 0;
		for(int j=1;j<len-i;j++){
			if(arr[mvIndex] < arr[j]){
				mvIndex = j;	
			}	
		}
		if(mvIndex != len-1-i){
			swap(&arr[mvIndex],&arr[len-1-i]);	
		}
	}	
}

鸡尾酒

void cookSort(int arr[],size_t len){
	for(int i=0;i<len/2;i++){
		int minIndex = i;
		int maxIndex = i;
		for(int j=i+1;j<len-i;j++){
			if(arr[minIndex] > arr[j]){
				minIndex = j;	
			}	
			if(arr[maxIndex] < arr[j]){
				maxIndex = j;	
			}
		}
		if(i !=minIndex)
			swap(&arr[minIndex],&arr[i]);
		if(maxIndex == i){
			//最大值是arr[i] 但是arr[i]已经被交换到arr[minIndex]
			maxIndex = minIndex;
		}
		if(maxIndex != len-1-i)
			swap(&arr[maxIndex],&arr[len-1-i]);
	}	
}

直接插入

void insertSort(int arr[],size_t len){
	for(int i=1;i<len;i++){//把arr[i..len-1]这些元素插入到前面使用[0,i]有序
		int data = arr[i];//要插入的值
		int j = i-1;
		//arr[j]比要插入的元素大 arr[j]要往后移一个位置
		for(;j>=0 && arr[j]>data;--j){
			arr[j+1] = arr[j];
		}
		arr[j+1] = data;
	}	
}

折半插入

void binaryInsertSort(int arr[],size_t len){
	for(int i=1;i<len;i++){
		int right = i-1;
		int left = 0;
		int data = arr[i];
		while(left<=right){
			int mid = (left+right)/2;
			if(data < arr[mid]){
				right = mid-1;
			}else{
				left = mid+1;	
			}
		}
		//left > right
		int j = i-1;
		for(;j>right;j--){//j>=left
			arr[j+1] = arr[j];	
		}
		arr[j+1] = data;
		
	}
}