数据结构与算法-第八章-堆，希尔，快速，归并

		时间复杂度  最坏时间复杂度 空间复杂度	 稳定性
归并排序	nlogn       nlogn          n          稳定
快速排序	nlogn       n^2            logn       不稳定
堆排序	nlogn       nlogn          1          不稳定
希尔排序 nlogn       n*s            1          不稳定

堆排序

void reheap(int arr[],size_t index,size_t len){
	int tmp = arr[index];
	int child = 0;//记录子节点
	for(;index<len;index=child){
		child = 2*index+1;//获得index节点的左节点位置
		if(child >= len){//子节点必须存在
			break;	
		}
		if(/*child<len&&*/child+1<len&&arr[child]<arr[child+1]){
			++child;//有右子节点 且右子节点值比左子节点的值更大	
		}
		if(tmp < arr[child]){
			arr[index] = arr[child];	
			//arr[child] = tmp;
		}else{//index节点的值 不小于 左右子节点 不需要交换
			break;	
		}
	}
	arr[index] = tmp;
}

void heap(int arr[],size_t len){
	for(int i=len/2-1;i>=0;--i){
		reheap(arr,i,len);	
	}
}

void swap(int *ps,int *pd){
	int tmp = *ps;
	*ps = *pd;
	*pd = tmp;
}
void heapSort(int arr[],size_t len){
	heap(arr,len);
	for(int i=len-1;i>0;--i){
		swap(&arr[0],&arr[i]);
		reheap(arr,0,i);
	}
}

void print(int arr[],size_t len){
	for(int i=0;i<len;i++){
		printf("%d ",arr[i]);	
	}	
	printf("\n");
}

希尔排序

void shellSort(int arr[],size_t len){
	for(int step = len/2;step>0;step = step/2){//分组
		for(int j = step;j<len;j++){
			int data = arr[j];
			int k = j-step;
			for(;k>=0&&data<arr[k];k-=step){
				arr[k+step] = arr[k];	
			}
			arr[k+step] = data;
		}	
	}
}

归并排序

void mergerArr(int arr[],size_t left,size_t right){
	int mid = (left+right)/2;  //[left,mid]  [mid+1,right]分别是有序的
	//合并  [left,right]区间有序
	int lds = mid+1-left;
	int *pd = malloc(lds*sizeof(int));
	for(int i=0;i<lds;i++){
		pd[i] = arr[left+i];	
	}
	int i = 0,j = mid+1;//i记录pa的下标  j记录arr[mid+1,right]下标
	int k = left;
	while(i<lds && j<=right){
		if(pd[i] < arr[j]){
			arr[k++] = pd[i++];	
		}else{
			arr[k++] = arr[j++];	
		}
	}
	while(i<lds){
		arr[k++] = pd[i++];	
	}
	free(pd);
	/*不需要
	while(j<=right){
		arr[k++] = arr[j++];	
	}
	*/
}
//递归调用
void merger(int arr[],size_t left,size_t right){
	if(left>=right){
		return;	
	}
	int mid = (left+right)/2;
	if(mid-left>=1)
		merger(arr,left,mid);//对[left,mid]区间进行排序
	if(right-mid-1>=1)
		merger(arr,mid+1,right);//对[mid+1,right]区间进行排序
	mergerArr(arr,left,right);
	//把[left,mid],[mid+1,right]两部分有序的合并成一个整体有序的
}
void mergerSort(int arr[],size_t len){
	merger(arr,0,len-1);	
}

快速排序

void quick(int arr[],int left,int right){
	int data = arr[left];
	int i = left;
	int j = right;
	while(i<j){
		while(i<j&&data<=arr[j]){--j;}
		if(i<j)
			arr[i] = arr[j];
		while(i<j&&arr[i]<=data){++i;}
		if(i<j)
			arr[j] = arr[i];
	}
	arr[i] = data;
	if(i-left>1){
		quick(arr,left,i-1);	
	}
	if(right-i>1){
		quick(arr,i+1,right);	
	}
}

void quickSort(int arr[],size_t len){
	quick(arr,0,len-1);	
}