七个最常用排序的代码（java）

七个最常用排序：

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 希尔排序
5. 归并排序
6. 快速排序
7. 堆排序

---

1.冒泡排序

链接：深入理解冒泡排序

	public static void bubbleSort(int[] value,int length){
		for(int i=1;i<length;i++){ 
			for(int j=0;j<length-i;j++){
				if(value[j]>value[j+1])
					swap(value,j,j+1); 
			}
		}
	}
	public static void swap(int[] value,int i,int j){
		int temp=value[i];
		value[i]=value[j];
		value[j]=temp;
	}

---

2.选择排序

链接：深入理解选择排序

	public static void selletionSort(int[] value,int length){
		int minIndex;
		for(int i=0;i<length-1;i++){
			minIndex=i;
			for(int j=i+1;j<length;j++){
				if(value[j]<value[minIndex]){
					minIndex=j;	
				}
			}
			swap(value,i,minIndex);
		}
	}
	public static void swap(int[] value,int i,int j){
		int temp=value[i];
		value[i]=value[j];
		value[j]=temp;
	}

---

3.插入排序

链接：深入理解插入排序（why二分插入排序中left就是待插入位置）

/*
*	直接插入排序
*/
public static void insertSort(int[] value,int length){
		int temp;
		for(int i=1;i<length;i++){
			temp=value[i];
			int j=i-1;
			while(j>=0&&value[j]>temp){
				value[j+1]=value[j];
				j--;
			}
			value[j+1]=temp;
		}
	}
/*
*	二分插入排序
*/
public static void insertSort2(int[] value,int length){
		for(int i=1;i<length;i++){
			int left = 0;
			int right = i-1;
			int temp = value[i];
			while(left<=right){
				int mid = (left+right)/2;
				if(value[mid]>temp)
					right=mid-1;
				else 
					left=mid+1;
			}
			for(int j=i-1;j>=left;j--){
				value[j+1]=value[j];
			}
			value[left]=temp;
		}
	}

---

4.希尔排序

链接：深入理解希尔排序

public static void shellSort(int[] value,int length){
	for(int p=length/2;p>0;p/=2){
		for(int i=p;i<length;i++){
			int temp=value[i];
			int j = i-p;
			while(j>=0&&value[j]>temp){
				value[j+p]=value[j];
				j-=p;
			}
			value[j+p]=temp;
		}
	}
}

---

5.归并排序

链接：深入理解归并排序

	public static void mergeSort(int[] value,int length){
		sort(value,0,length-1);
	}
	private static void sort(int[] value,int l,int r){
		if(l>=r) return;
		int mid=(l+r)/2;
		sort(value,l,mid);
		sort(value,mid+1,r);
		merge(value,l,mid,r);
	}
	private static void merge(int[] value,int l,int mid,int r){
		int[] temp=new int[r-l+1];
		int i=0;
		int p1=l;
		int p2=mid+1;
		while(p1<=mid&&p2<=r){
			temp[i++]=value[p1]<value[p2]?value[p1++]:value[p2++];
		}
		while(p1<=mid){
			temp[i++]=value[p1++];
		}
		while(p2<=r){
			temp[i++]=value[p2++];
		}
		for(int j=0;j<temp.length;j++){
			value[l+j]=temp[j];
		}
	}

---

6.快速排序

链接：深入理解快速排序

	public static void quikSort(int[] value,int start,int end){
		if(start<end){
			int i=start-1;
			int j=start;
			int X=value[end];
			while(j<=end){
				if(value[j]<=X){
					i++;
					swap(value,i,j);
				}
				j++;
			}
			quikSort(value,start,i-1);
			quikSort(value,i+1,end);
		}
	}
	public static void swap(int[] value,int i,int j){
		int temp=value[i];
		value[i]=value[j];
		value[j]=temp;
	}

---

7.堆排序

链接：深入理解堆排序

	public static void heapSort(int[] value,int length){
		for(int j=(length/2-1);j>=0;j--){
			buildHeapTree(value,j,length);
		}
		for(int i=length-1;i>0;i--){
			swap(value,0,i);
			buildHeapTree(value,0,i);
		}
	}
	private static void buildHeapTree(int[] value,int n,int len){
		int left=n*2+1;
		int right=left+1;
		int max=n;
		if(left<len&&value[left]>value[max]){
			max=left;
		}
		if(right<len&&value[right]>value[max]){
			max=right;		
		}
		if(max!=n){
			swap(value,max,n);
			buildHeapTree(value,max,len);
		}
	}
	private static void swap(int[] value,int i,int j){
		int temp=value[i];
		value[i]=value[j];
		value[j]=temp;
	}