七大基于比较的排序

直接插入排序

每次取待排序区间的第一个元素，在有序区间内找到合适的位置插入

 public static void insertSort(int[] array){
        for(int bound=1;bound<array.length;bound++){
            int v=array[bound];
            int cur=bound-1;
            for(;cur>=0;cur--){
                if(array[cur]>v){
                    array[cur+1]=array[cur];
                }else{
                    break;
                }
            }
            array[cur+1]=v;
        }
    }

希尔排序

 public static void shellSort(int[] array){
        int gap=array.length/2;
        while(gap>1){
            insertSortGap(array,gap);
            gap=gap/2;
        }
        insertSortGap(array,1);
    }

    private static void insertSortGap(int[] array, int gap) {
        for(int bound=gap;bound<array.length;bound++){
            int v=array[bound];
            int cur=bound-gap;
            for(;cur>=0;cur-=gap){
                if(array[cur]>v){
                    array[cur+gap]=array[cur];
                }else{
                    break;
                }
            }
            array[cur+gap]=v;
        }
    }

选择排序

 public static void selectSort(int[] array){
        for(int bound=0;bound<array.length;bound++){
            for(int cur=bound+1;cur<array.length;cur++){
                if(array[cur]<array[bound]){
                    int tmp=array[cur];
                    array[cur]=array[bound];
                    array[bound]=tmp;
                }
            }
        }
    }

堆排序

public static void heapSort(int[] array){
        createHeap(array);
        for(int i=0;i<array.length-1;i++){
            swap(array,0,array.length-1-i);
            shiftDown(array,array.length-i-1,0);
        }
    }

    private static void createHeap(int[] array) {
        for(int i=(array.length-1-1)/2;i<array.length;i++){
            shiftDown(array,array.length,0);
        }
    }
    private static void swap(int[] array,int i,int j){
        //建堆操作，从后往前遍历（向下调整）
        int t=array[i];
        array[i]=array[j];
        array[j]=t;
    }
    private static void shiftDown(int[] array,int heapLength,int index){
        //向下调整
        int parent=index;
        int child=(parent*2)+1;
        while(child<heapLength){
            if(child+1<heapLength&&array[child+1]>array[child]){
                child=child+1;
            }
            if(array[parent]<array[child]){
                swap(array,parent,child);
            }else{
                break;
            }
            parent=child;
            child=(parent*2)+1;
        }
    }

冒泡排序

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

快速排序

 public static void quickSort(int[] array){
        quickSortHelper(array,0,array.length-1);
    }
    private static void quickSortHelper(int[] array,int left,int right){
        if(left>=right){
            return;
        }
        int index=partition(array,left,right);
        quickSortHelper(array,left,index-1);
        quickSortHelper(array,index+1,right);
    }
    private static int partition(int[] array,int left,int right){
        int i=left;
        int j=right;
        int v=array[right];
        while(i<j){
            while(i<j&&array[i]<=v){
                i++;
            }
            while(i<j&&array[j]>=v){
                j--;
            }
            swap(array,i,j);
        }
        swap(array,i,right);
        return i;
    }

快速排序的非递归实现

public static void quickSortByLoop(int[] array){
       //借助栈模拟实现递归操作
       //栈里边存储的是数组下标
        Stack<Integer> stack=new Stack<>();
        stack.push(array.length-1);
        stack.push(0);
        while(!stack.isEmpty()){
            int left=stack.pop();
            int right=stack.pop();
            if(left>=right){
                continue;
            }
            int index=partition(array,left,right);
            stack.push(index-1);
            stack.push(left);
            stack.push(right);
            stack.push(index+1);
        }
  }

归并排序

 public static void mergeSort(int[] array){
        mergeSortHelper(array,0,array.length);
    }

    private static void mergeSortHelper(int[] array, int low, int high) {
        if(high-low<=1){
            return;
        }
        int mid=(low+high)/2;
        mergeSortHelper(array,low,mid);
        mergeSortHelper(array,mid,high);
        merge(array,low,mid,high);
    }

    private static void merge(int[] array, int low, int mid, int high) {
        int[] output=new int[high-low];
        int index=0;
        int cur1=low;
        int cur2=mid;
        while (cur1<mid&&cur2<high){
            if(array[cur1]<=array[cur2]){
                output[index]=array[cur1];
                index++;
                cur1++;
            }else{
                output[index]=array[cur2];
                index++;
                cur2++;
            }
        }
        while(cur1<mid){
            output[index]=array[cur1];
            index++;
            cur1++;
        }
        while(cur2<high){
            output[index]=array[cur2];
            index++;
            cur2++;
        }
        for(int i=0;i<high-low;i++){
            array[low+i]=output[i];
        }
    }

非递归实现

 public static void mergeSortByLoop(int[] array){
        //引入一个gap变量进行分组
        //当gap为1的时候，[0][1]进行合并,[2][3]进行合并，[4][5]进行合并，[6][7]进行合并
        //当gap为2的时候，[0，1]和[2，3]进行合并，[4，5]和[6，7]进行合并
        //当gap为4的时候，[0,1,2,3]进行合并,[4,5,6,7]进行合并
        for(int gap=1;gap<array.length;gap*=2){
            for(int i=0;i<array.length;i+=2*gap){
                int beg=i;
                int mid=i+gap;
                int end=i+2*gap;
                if(mid>array.length){
                    mid=array.length;
                }
                if(end>array.length){
                    end=array.length;
                }
                merge(array,beg,mid,end);
            }
        }
    }

性能分析