八大排序算法详解（java版）

1.冒泡排序

//冒泡排序
	//冒泡排序就是每次选择一个最大值放到后面
	public void bubbleSort(int[] arr) {
		//外层循环控制需要比较的次数   一共是n-1次
		for(int i=0; i<arr.length-1; i++) {
			//内层循环进行冒泡，因为每完成一次外层循环，就会在后面多一个有序序列，因此可以不用比较		
			for(int j=0; j<arr.length-i-1; j++) {
				if(arr[j]>arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}

2.选择排序

//选择排序
	//选择排序就是依次选择最小值放在最前面
	public void selectSort(int[] arr) {
		//外层循环控制每次选择的位置
		for(int i=0; i<arr.length-1; i++) {
			int min = i;
			//内层循环表示第i个位置依次和后面的元素比较选出最小的值，并放在第i个位置
			for(int j=i+1; j<arr.length; j++) {
				if(arr[j]<arr[min]) {
					min = j;
				}
			}
			//把选出的最小值放在第i个位置	
			if(min!=i) {
				int temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
	}

3.直接插入排序

//直接插入排序
	public void insertSort(int[] arr) {
		int temp,j;
		for(int i=1; i<arr.length; i++) {
			temp = arr[i];
			j = i-1;
			while(j>=0&&temp<arr[j]) {
				arr[j] = arr[j-1];
				j--;
			}
			arr[j+1] = temp;
		}
	}

4.希尔排序

//希尔排序 使用移动元素法
//希尔排序就是插入排序的升级版，只不过步长不再是1
public void shellSort1(int[] arr){
	int length = arr.length;
	//先分组，直到gap等于1
	for(int gap=length/2; gap>0; gap/=2) {
		//分成了gap组之后，从第gap个元素开始进行插入排序
		for(int j=gap; j<length; j++) {
			if(arr[j]<arr[j-gap]) {
				int k = j;
				int temp = arr[j];
				while(k-gap>=0&&temp<arr[k-gap]) {
					arr[k] = arr[k-gap];
					k-=gap;
				}
				arr[k] = temp;
			}
		}
	}
}

//希尔排序 使用交换元素法 （类似冒泡法）
public void shellSort2(int[] arr){
	int length = arr.length;
	for(int gap=length/2; gap>0; gap/=2) {
		for(int j=gap; j<length; j++) {
			if(arr[j]<arr[j-gap]) {
				int k = j;
				while(k-gap>=0&&arr[k]<arr[k-gap]) {
					int temp = arr[k];
					arr[k] = arr[k-gap];
					arr[k-gap] = temp;
				}
			}
		}
	}
}

5.快速排序（双指针）

//快速排序
public void quickSort(int[] arr,int left,int right) {
	
	//如果没有元素或只有一个元素直接返回，因为一个元素已经有序，无需排序
	if(left>=right)
		return;
	
	//第一个指针指向数组的第一个元素
	int start = left;
	//第二个指针指向数组的最后一个元素
	int end = right;
	
	//缓存直接选择的基准，大部分都是以第一个元素为基准
	int temp = arr[start];
	while(start<end) {
		//从第二个指针开始找到第一个小于基准数的索引，
		//因为循环退出的条件就是arr[end]<temp
		while(start<end&&arr[end]>=temp)
			end--;
		//把找到的小于基准的数放在基准数的左边
		if(start<end)
			arr[start++] = arr[end];
		
		//从第一个指针开始找第一个大于基准数的索引
		while(start<end&&arr[start]<temp)
			start++;
		//把找到的大于基准的数放在基准数的右边
		if(start<end)
			arr[end--] = arr[start];
	}
	//把基准数放在中间，循环结束之后，基准数左边都比基准数小，基准数右边都比基准数大
	arr[start] = temp;
	
	//基准数左边进行快速排序
	quickSort(arr, left, start-1);
	//基准数右边进行快速排序
	quickSort(arr, start+1, right);
}

6.归并排序

//归并排序
public void mergeSort(int[] arr,int left,int right) {
	if(left>=right)
		return;
	int mid = left+(right-left)/2;
	mergeSort(arr, left, mid);
	mergeSort(arr, mid+1, right);
	merge(arr,left,mid,right);
}

//合并两个数组
public void merge(int[] arr,int left,int mid,int right) {
	int t1 = left;
	int t2 = mid+1;
	int k = 0;
	int[] temp = new int[right-left+1];
	while(t1<=mid&&t2<=right) {
		if(arr[t1]<arr[t2])
			temp[k++] = arr[t1++];
		else
			temp[k++] = arr[t2++];
	}
	while(t1<=mid)
		temp[k++] = arr[t1++];
	while(t2<=right)
		temp[k++] = arr[t2++];
	
	for(int i=0; i<k; i++) {
		arr[left++] = temp[i];
	}
}

7.基数排序

//基数排序
public void baseSort(int[] arr) {
	int[][] bucket = new int[10][arr.length];
	int[] bucketCounts = new int[10];
	
	int max = arr[0];
	for(int i=0; i<arr.length; i++)
		if(arr[i]>max)
			max = arr[i];
	int maxLength = (max+"").length();
	int n = 1; 
	for(int i=1; i<=maxLength; i++) {				
		for(int j=0; j<arr.length; j++) {
			int temp = (arr[j]/n)%10;
			bucket[temp][bucketCounts[temp]] = arr[j];  
			bucketCounts[temp]++;
		}
		int index = 0;
		for(int j=0; j<bucketCounts.length; j++) {
			int count = bucketCounts[j];
			for(int k=0; k<count; k++) {
				arr[index++] = bucket[j][k];
			}
			bucketCounts[j] = 0;
		}
		n*=10;
	}
}

8.堆排序

//堆排序    史上最难理解的排序之一
public void heapSort(int[] arr) {
	
	//构建大顶堆 i表示需要调整的每个双亲节点
	for(int i=(arr.length-1-1)/2; i>=0; i--) {
		
		adjustHeap(arr, i, arr.length);
	}
	
	//构建好大顶堆之后，交换堆顶和对底元素并调整堆的结构
	for(int i=arr.length-1; i>0; i--) {
		int temp = arr[i];
		arr[i] = arr[0];
		arr[0] = temp;
		adjustHeap(arr, 0, i);
	}
}
//调整堆的结构
public void adjustHeap(int[] arr,int parent,int length) {
	int temp = arr[parent];
	
	//找到其左孩子
	int lchild = 2*parent+1;
	while(lchild<length) {
		int rchild = lchild+1;
		if(rchild<length&&arr[rchild]>arr[lchild])
			lchild++;
		if(temp>=arr[lchild])
			break;
		arr[parent] = arr[lchild];
		parent = lchild;
		lchild = 2*lchild+1;
	}
	arr[parent] = temp;
}