1.快速排序

快速排序主要是基于分治的思想巾表，每次尋找一個pivot汁掠，然后從后往前找比pivot小的，從前往后找比pivot小的集币。

 public static void quicksort(int[] nums, int low, int high){
        if(low > high)
            return;
        int pivot = nums[low];
        int i = low,j =high;
        while(i<j){
            while(i<j && nums[j]>=pivot){
                j--;
            }
            while (i<j && nums[i]<=pivot){
                i++;
            }
            if(i<j){
                swap(nums, i,j);
            }

        }
        swap(nums, low, i);
        quicksort(nums,low, i-1);
        quicksort(nums,i+1, high);
    }

    public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

2.堆排序

堆排序主要分三個步驟

堆調(diào)整考阱，比較當(dāng)前元素及其左右孩子，把最大的調(diào)整上來（大頂堆）,遞歸調(diào)整鞠苟。

建堆乞榨，根據(jù)堆的性質(zhì)，從nums.length/2-1 最后一個非葉子結(jié)點開始從后往前建堆当娱。

排序吃既，從后往前交換堆頂元素和堆最后一個元素，減少堆元素跨细，進(jìn)行堆的調(diào)整琴儿。

    public static void adjustHeadp(int[] arrray, int index ,int size){  //堆調(diào)整
        int left = 2*index+1;    //下表以0開始
        int right = 2*index+2;
        int largest = index;
        if(left < size && arrray[index]<arrray[left]){
            largest = left;
        }
        if(right < size && arrray[largest]<arrray[right]){
            largest = right;
        }
        if(largest != index){
            swap(arrray, index,largest);
            adjustHeadp(arrray, largest, size);
        }

    }

    public static void buildHeap(int[] arrray){  // 從后往前建堆
        for(int i=arrray.length/2-1;i>=0;i--){
            adjustHeadp(arrray, i, arrray.length);
        }
    }

    public static void sortByHeap(int[] array){   // 排序
        buildHeap(array);
        for(int i=array.length-1;i>=0;i--){
            swap(array, 0, i);
            adjustHeadp(array, 0, i);
        }
    }
  public static void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

3.歸并排序

歸并排序是一種穩(wěn)定排序夹界，在歸并排序中常見的是二路歸并耳舅，即講數(shù)組分成兩份羹应，各自排序再合并的過程，其中二路歸并排序是一個遞歸的過程散休，即分割使得數(shù)組大小為1或者2為止媒楼，這樣經(jīng)過一次比較或者不比較就可以得出一個有序的子序列，代碼如下溃槐。

public static void mergeSort(int[] array, int left, int right){
        if(left < right){
            int mid = (left+right)/2;
            mergeSort(array, left, mid);
            mergeSort(array, mid+1, right);
            merge(array, left, mid, right);
        }
    }

    public static void merge(int[] array, int left, int mid, int right){
        int[] temp = new int[array.length];
        for(int i=0; i<array.length;i++){
            temp[i] = array[i];
        }
        int i = 0,j = 0, k=0;
        for(i=left,j=mid+1,k=left; i<=mid && j<=right; k++){
            if(temp[i]<=temp[j]){
                array[k] = temp[i++];
            }else{
                array[k] = temp[j++];
            }
        }
        while (i<=mid){
            array[k++] = temp[i++];
        }
        while (j<=right){
            array[k++] = temp[j++];
        }
    }