快速排序和堆排序

快速排序
递归
左边通过遍历找到比当前基准数小的数，右边通过遍历找到比当前基准数大的数，在俩指针相遇的地方插入基准数，将数组分为两部分，然后用递归再对这两部分分别排序，最终排完

    public static int[] quickS(int[] arr,int left,int right) {
        // TODO Auto-generated method stub
        
        if(left >=right) {
            return arr;
        }
        
        int i = left;
        int j = right;
            
        int base =arr[left];
        while(i != j) {
            while(arr[j] >= base && j>i) {
                j--;
                }
            while(arr[i] <= base && j>i) {
                i++;
                }
            int temp =arr[i];
            arr[i] =arr[j];
            arr[j] =temp;
        }
        arr[left] =arr[i];
        arr[i] =base;
        
        quickS(arr,left,i-1);
        quickS(arr,i+1,right);
        return arr;
    }

堆排序
第一步：构建大顶堆
第二步：堆顶元素和堆底元素互换   互换之后的元素就不会再被遍历了
    public static void heapSoet(int[] arr) {
        for(int i=(arr.length-1)/2;i>=0;i--) {
            HeapSort(arr, i, arr.length);
        }
        for(int i=arr.length-1;i>0;i--) {
            //将堆顶元素与堆尾元素进行交换
            int temp=arr[i];
            arr[i]=arr[0];
            arr[0]=temp;
            HeapSort(arr,0, i);
        }
    }
    
    public static void HeapSort(int[] arr,int parent, int length) {
        int temp=arr[parent];
        int lChild =2*parent+1;
        while(lChild<length) {
            int rChild=lChild+1;
            if(rChild<length&&arr[lChild]<arr[rChild])
            {lChild ++;}
            if(temp>=arr[lChild]) {
                break;
            }
            arr[parent]=arr[lChild];
            parent=lChild;
            lChild=2*lChild+1;
        }
        arr[parent]=temp;
    }