数据结构 面试算法 : 冒泡排序，插入排序，归并排序，快速排序。。。

3 排序算法

3.1 冒泡排序



3.2 插入排序



3.3 归并排序




开辟新的内存存



3.4 快速排序








3.5 拓扑排序








各种排序算法的C++实现：

#include<iostream>
using namespace std;
#include<time.h>
#include<sys/timeb.h>

#define Max 10


int* Createarr(){
	srand((unsigned int)time(NULL));
	int* arr = (int*)malloc(sizeof(int)* Max);
	for(int i=0;i<Max; i++){
		arr[i]=rand() % Max;
	}
	return arr;
}

void Printarr(int arr[], int len){
	for(int i=0;i<len;i++){
	cout<<arr[i]<<" ";
	}
	cout<<endl;
}
//冒泡排序: 改进加一个标识flag
void Bubblesort(int arr[],int len){
	int flag=0;//表示没排序好
	for(int i=0;i < len-1 && flag==0; i++)
	{
		flag=1;
		for(int j=0;j<len-i-1;j++)
		{
			if(arr[j]>arr[j+1]){
				flag=0;
				int temp =arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
}
//选择排序
void Selectsort(int arr[],int len){
	
	int min=0;
	for(int i=0;i<len;i++){
		min=i;
		for(int j=i+1;j<len;j++){
			if(arr[j] < arr[min]){
				min=j;
			}
		}
		if(min!=i){
			int temp =arr[min];
			arr[min]=arr[i];
			arr[i]=temp;
		}
	}
}

//插入排序
void Insertsort(int arr[],int len){
	int j;
	for(int i=1;i<len;i++){

		if(arr[i]>arr[i-1]){

			int temp =arr[i];
			for(j = i-1;j>=0 && temp>arr[j];j--){
				arr[j+1]=arr[j];
			}
			arr[j+1]=temp;
		}
	}
}

//希尔排序:分组插入排序
void Shellsort(int arr[],int len){

	int increasement = len;
	int j,k;

	do{
		increasement=increasement/3+1;
		for(int i=0;i<increasement;i++){
			for(j=i+increasement;j<len;j+=increasement)
			{
				if(arr[j]<arr[j-increasement]){
				
					int temp= arr[j];
					for(k= j-increasement;k>=0 && temp< arr[k];k-=increasement)
					{
						arr[k+increasement]=arr[k];
					}
					arr[k+increasement]=temp;
				}
			}
		}
	
	}while(increasement>1);

}

//快速排序：递归
void Quicksort(int arr[],int start,int end){
	
	int i=start; int j = end;
	int temp=arr[start];//基准数
	if(i<j){

		while(i<j)
		{
			//从右向左去找比基准数小的
			while(i<j && arr[j]>=temp){
				j--;
			
			}//填坑
			if(i<j){
				arr[i] = arr[j];
				i++;
			}//从左向右
			while(i<j && arr[i]<temp){
				i++;
			}//填坑
			if(i<j){
				arr[j]=arr[i];
				j--;
			}
		}
		//把基准数放在i位置
		arr[i]=temp;
		Quicksort(arr,start,i-1);
		Quicksort(arr,i+1,end);
	}
}

//合并算法
void Merge(int arr[], int start,int end,int mid,int * temp){

	int i_start = start;
	int i_end = mid;
	int j_start = mid+1;
	int j_end = end;
	//表示辅助空间有多少元素
	int len=0;
	//合并两个有序序列
	while(i_start<=i_end && j_start <= j_end){
	
		if(arr[i_start]<arr[j_start]){
			temp[len] = arr[i_start];
			len++;
			i_start++;
		}else{
			temp[len] = arr[j_start];
			j_start++;
			len++;
		}
	}
	//i这个序列
	while(i_start<=i_end){
		temp[len] = arr[i_start];
		i_start++;
		len++;
		}
	//j这个序列
	while(j_start<=j_end){
		temp[len] = arr[j_start];
		j_start++;
		len++;
		}

	//辅助空间的数据覆盖到原来空间
	for(int i =0; i<len ;i++){
		arr[start+i]=temp[i];
	}

}
// 归并排序:递归
void Mergesort(int arr[],int start, int end,int *temp){

	if(start>=end){
		return ;
	}
	int mid= (start + end )/2;
	//分组
	//左半边
	Mergesort(arr,start,mid,temp);
	//右半边
	Mergesort(arr,mid+1,end,temp);
	//合并
	Merge(arr,start,end,mid,temp);
}

/*  @param arr 待调整的数组
	@param index 待调整的结点下标
	@param len 数组的长度
*/
void HeapAdjust(int arr[],int index,int len){
	
	//先保存当前结点的下标
	int max = index;
	//保存左右孩子的数组下标
	int lchild = index * 2 + 1;
	int rchild = index * 2 + 2;

	if(lchild < len && arr[lchild] > arr[max]){
		max = lchild;
	}

	if(rchild < len && arr[rchild] > arr[max]){
		max = rchild;
	}

	if(max != index){
		//交换两个结点
		int temp = arr[max];
		arr[max] = arr[index];
		arr[index] = temp;
		//递归调整
		HeapAdjust(arr,max,len);
	}

}
//堆排序
void Heapsort(int arr[],int len){

	for(int i = len/2 - 1;i >= 0; i--){
		HeapAdjust(arr,i,len);
	}
	for(int i = len - 1;i >= 0; i--){

		int temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;

		HeapAdjust(arr,0,i);
	}
}

int main(void)
{
	int arr[] = {4,2,8,0,5,7,1,3,9};
	int * arr1=Createarr();
	int len=sizeof(arr)/sizeof(int);
	Printarr(arr1,len);
	//Bubblesort(arr,len);

	//Selectsort(arr,len);

	//Insertsort(arr,len);

	//Printarr(arr,len);

	//Shellsort(arr,len);

	//Quicksort(arr,0,len-1);

	//int* temp =(int*)malloc(sizeof(int)*Max);
	//Mergesort(arr1,0,Max-1,temp);
	//free(temp);

	Heapsort(arr1,len);
	Printarr(arr1,len);

	system("pause");
	return 0;
	
}