插入、希尔、归并、快速排序(java实现)
目录
插入排序
希尔排序
归并排序
快速排序
插入排序
排序原理：
1.把所有元素分为两组，第一组是有序已经排好的，第二组是乱序未排序。
2.将未排序一组的第一个元素作为插入元素，倒序与有序组比较。
3.在有序组中找到比插入元素小或者大的元素，将插入元素放入该位置，后面元素向后移动一位。
时间复杂度：O(n^2)
稳定性：当A与B相等，排序前A若在B前，排序后A仍然在B前，就说明该排序是稳定的。
插入排序：稳定
//比较两元素大小方法private static boolean greater(Comparable v,Comparable w){return v.compareTo(w)>0;} //数组中 交换元素位置private static void exch(Comparable[] a,int i,int j){Comparable temp;temp = a[i];a[i] = a[j];a[j] = temp;}插入排序
public static void insertSort(Comparable[] a){for (int i = 1; i < a.length-1; i++) {for (int j = i+1; j >0; j--) {if (greater(a[j-1],a[j])){exch(a,j-1,j);}else break;}}}希尔排序
排序原理：
1.选择一个增长量h，按照h将数据分组。
2.每组进行插入排序。
3.减少增长量h直到h=1，重复步骤2
稳定性：不稳定
public static void shellSort(Comparable[] a){int h = 1;//确定hwhile (h<a.length/2){h = 2*h+1;}// 希尔排序while (h>=1){for (int i = h; i < a.length; i=i+h) {for (int j = i; j >= h; j=j-h) {if (greater(a[j-h],a[j])){exch(a,j-h,j);}else break;}}h=h/2;}}归并排序
排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子
组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
时间复杂度：O(nlogn)
稳定性： 稳定
import java.util.Arrays;public class Merge {//归并需要的辅助数组private static Comparable[] assist;//判断v是否比w小private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}//交换元素private static void exch(Comparable[] a,int i,int j){Comparable t = a[i];a[i] = a[j];a[j] = t;}//对数组a排序public static void sort(Comparable[] a){// 1.初始化辅助数组assistassist= new Comparable[a.length];// 定义lo变量和hi变量。分别记录数组中最小的索引和最大的索引int lo = 0;int hi = a.length-1;sort(a,lo,hi);}//对数组a中从lo到hi元素进行排序private static void sort(Comparable[] a,int lo,int hi){//安全检验if (hi<=lo){return;}// 对lo和hi之间的数据进行分为两组int mid = lo+(hi-lo)/2;// 分别排序sort(a,lo,mid);sort(a,mid+1,hi);//两组归并merge(a,lo,mid,hi);}//归并private static void merge(Comparable[] a,int lo,int mid,int hi){// 定义三个指针int i = lo;int p1 = lo;int p2 = mid+1;// 遍历移动p1指针和p2指针，比较对应 索引处的值，找出小的，放到辅助数组对应分索引处while (p1<=mid&&p2<=hi){if (less(a[p1],a[p2])){assist[i++] = a[p1++];}else {assist[i++] = a[p2++];}}//遍历，如果p1的指针没有走完，将p1剩余遍历到辅助数组中while (p1<=mid){assist[i++] = a[p1++];}//遍历，如果p2的指针没有走完，将p2剩余遍历到辅助数组中while (p2<=hi){assist[i++] = a[p2++];}// 把辅助数组中的元素复制到原数组中for (int index = lo;index<=hi;index++){a[index] = assist[index];}}public static void main(String[] args) {Integer[] a={7,8,4,5,6,1,3,9,2};Merge.sort(a);System.out.println(Arrays.toString(a));// [1, 2, 3, 4, 5, 6, 7, 8, 9]}}
快速排序
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分
中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分
数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处
理。
4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧
部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
时间复杂度：
平均情况：O(nlogn)，最坏情况：O(n^2)
稳定性：不稳定
import java.util.Arrays;public class Quick {private static void exch(Comparable[] a,int i,int j){Comparable t = a[i];a[i] = a[j];a[j] = t;}private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}//对数组内的元素进行排序public static void sort(Comparable[] a){int lo = 0;int hi = a.length-1;sort(a,lo,hi);}//对数组a中从索引hi之间的元素进行排序public static void sort(Comparable[] a,int lo,int hi){if (lo>=hi)return;int partition = partition(a,lo,hi);sort(a,lo,partition-1);sort(a,partition+1,hi);}private static int partition(Comparable[] a,int lo,int hi){//确定分界值Comparable key = a[lo];//定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置int left = lo;int right = hi+1;//切分 扫描while (true){//先从右边向左扫描，移动right指针，找到比分界值小的，停止while (less(key,a[--right])){if (right==lo){break;}}//从左边向右扫描，移动light指针，找到比分界值大的，停止while (less(a[++left],key)){if (left==hi){break;}}//right<right时交换if (left>=right){break;}else {exch(a,left,right);}}//交换分界值exch(a,lo,right);return right;}public static void main(String[] args) {Integer a[] = {3,6,9,2,5,8,4,7,1};Quick.sort(a);System.out.println(Arrays.toString(a));// [1, 2, 3, 4, 5, 6, 7, 8, 9]}}