主要的七种排序（快排、希尔排序、堆排序、归并排序、选择排序、插入排序、冒泡排序）

一、冒泡排序

冒泡排序是最简单的排序，不需要额外空间，时间复杂度为O(N^2)；代码如下

import java.util.Arrays;

public class BubbleSort {
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			for(int j=arr.length-1;j>i;j--) {
				if(arr[j]<arr[j-1]) {
					swap(arr,j,j-1);
				}
			}
		}
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

	public static void main(String[] args) {
		int[] arr= {1,5,3,2,5,1,7};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}

二、选择排序

选择排序和冒泡排序比较相似，就是找到最小的或最大的与对应位置交换，时间复杂度也是O(N^2)，代码如下

import java.util.Arrays;

public class SelectedSort {
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					swap(arr,i,j);
				}
			}
		}
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

	public static void main(String[] args) {
		int[] arr= {9,1,3,5,2,3,5,8,4};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}

三、插入排序

插入排序相当于默认前面的都已经排好序，将待排的数插入进去，但要注意，得数组从后往前比较，然后进行交换，交换到合适的位置（前一个比它小，后一个比它大），则该数就插入成功了，时间复杂度也是O(N^2)，代码如下

import java.util.Arrays;

public class InsertSort {
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=i+1;j>0;j--) {
				if(arr[j]<arr[j-1])
					swap(arr,j,j-1);
			}
		}
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

	public static void main(String[] args) {
		int[] arr= {6,5,1,6,8,2,7,9,5};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}

四、归并排序

归并排序相当于结合了插入排序和分治法（merge），时间复杂度为O(NlogN)，主要注意的是，merge需要额外的空间，代码如下

import java.util.Arrays;

public class MergeSort {
	public static void sort(int[] arr,int s,int e) {
		if(s==e)
			return;
		sort(arr,s,(s+e)/2);
		sort(arr,(s+e)/2+1,e);
		merge(arr,s,(s+e)/2,e);
		
	}
	public static void merge(int[] arr,int l_s,int l_e,int r_e) {
		int[] temp=new int[r_e-l_s+1];//记得归并排序需要额外空间
		int i=l_s;
		int j=l_e+1;
		int k=0;
		while(i<=l_e&&j<=r_e) {
			if(arr[i]<=arr[j]) {
				temp[k]=arr[i];
				i++;
			}
			else {
				temp[k]=arr[j];
				j++;
				
			}
			k++;
		}
		while(i<=l_e) {
			temp[k]=arr[i];
			k++;
			i++;
		}
		while(j<=r_e) {
			temp[k]=arr[j];
			k++;
			j++;
		}
		k=0;
		while(k<temp.length) {
			arr[l_s]=temp[k];
			k++;
			l_s++;
		}
	}

	public static void main(String[] args) {
		int[] arr= {4,1,2,4,2,7,4,2,8,3,4,2,2,9,0};
		sort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}

五、希尔排序

分组进行插入排序，代码如下

import java.util.Arrays;

public class ShellSort {
	public static void sort(int[] arr) {
		int m=arr.length/3+1;
		while(m>0) {
			//对每个数组进行插入排序,从每个数组的第二个开始插入前面已经排好的数据中,i为要插入的数据
			for(int i=m;i<arr.length;i++) {
				//以下就是插入排序了
				for(int j=i;j>=m;j-=m) {
					if(arr[j]<arr[j-m])
						swap(arr,j,j-m);
				}
			}
			m--;
		}
		
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

	public static void main(String[] args) {
		int[] arr= {7,1,6,3,5,6,7,9,3,5,3,6,2,4,2,6,7,8,0,10};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}

六、快速排序

主要在于partition这个函数，即划分这个函数，不需要额外空间，代码如下

import java.util.Arrays;

public class QuickSort {
	public static int partition(int[] arr,int start,int end) {
		int p=end;
		int i=start-1,j=end;
		while(true) {
			while(arr[++i]<arr[p]);
			while(j>0&&arr[--j]>arr[p]);
			if(i>=j)
				break;
			else
				swap(arr,i,j);
		}
		swap(arr,p,i);
		return i;
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	public static void quickSort(int[] arr,int start,int end) {
		if(start>=end)
			return;
		int index=partition(arr,start,end);
		quickSort(arr,index+1,end);
		quickSort(arr,start,index-1);
	}

	public static void main(String[] args) {
		int[] arr= {5,7,3,2,1};
		System.out.println(Arrays.toString(arr));
		quickSort(arr,0,4);
		System.out.println(Arrays.toString(arr));
		int i=4;
		while(--i<1);
		System.out.println(i);
		// TODO Auto-generated method stub

	}

}

七、堆排序

主要在建堆，代码如下

import java.util.Arrays;
//堆排序，主要在建队
public class HeapSort {
	public static int leftChild(int i) {
		return i*2+1;
	}
	public static void Precdown(int[] arr,int i,int N) {
		int child=leftChild(i);
		if(child<N-1&&arr[child]<arr[child+1])
			child++;
		if(child<N&&arr[i]<arr[child]) {
			swap(arr,i,child);
			Precdown(arr,child,N);//一定注意需要递归，主要是在（1）处一定要递归
		}
	}
	public static void sort(int[] arr) {
		int m=arr.length/2;
		for(int i=m;i>=0;i--)
			Precdown(arr,i,arr.length);
		for(int i=arr.length-1;i>=0;i--) {
			swap(arr,0,i);
			Precdown(arr,0,i);//（1）处
		}
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	public static void main(String[] args) {
		int[] arr= {4,2,5,1,3,6,6,2,6,9,4,8,1};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		// TODO Auto-generated method stub

	}

}