文章标题

public class Sort {

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

    public static  void insertSort(int[] arrayToSort){

        for( int i = 0 ; i < arrayToSort.length; ++i){

            //从i的位置往前去排 保证i前面的分片是有序的
            for( int j = i-1 ; j >= 0 ; --j){
                if( arrayToSort[j+1] < arrayToSort[j]){
                    swap(arrayToSort, j+1,j);
                }
            }
        }
    }


    //选择排序
    public static  void selectSort(int[] arrayToSort){

        //每次选择arrayToSort[i] 后面最小的元素来进行交换
        for( int i = 0 ; i < arrayToSort.length ; ++i){

            int min = i;
            for( int j = i+1; j < arrayToSort.length ; ++j){
                if( arrayToSort[j] < arrayToSort[min]){
                    min = j;
                }
            }
            swap(arrayToSort,min,i);
        }
    }

    //归并排序 时间复杂度O(nlogn) 空间复杂度 O(n)+O(logn)
    //可以将数组分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，
    // 然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序

    public static void mergerSort(int[] arrayToSort){
        sort(arrayToSort,0,arrayToSort.length-1);
    }

    private  static void sort(int[] array ,int left,int  right) {

        if (left < right) {
            int center = (left + right) / 2;
            //对左边递归
            sort(array, left, center);

            //对右边递归
            sort(array, center + 1, right);

            //mergerArray
            mergerArray(array, left, center, right);

        }
    }

    private static void mergerArray(int array[],int left,int mid,int right){



       int[] tmp = new int[array.length];
       int r1 = mid + 1;
       int tIndex = left;       //tmp 数组索引
       int sIndex = left;       //swap 时的索引
       while (left <= mid && r1 <= right){
           if(array[left] <= array[r1]){
               tmp[tIndex++] = array[left++];
           }else {
               tmp[tIndex++] = array[r1++];
           }
       }
       while (left <= mid){
           tmp[tIndex++] = array[left++];
       }

       while (r1 <= right){
           tmp[tIndex++] = array[r1++];
       }
       while (sIndex <= right){
           array[sIndex] = tmp[sIndex++];
       }
    }
    //快速排序的每一轮就是将这一轮的基准数归位，直到所有的数都归为为止，排序结束。（类似冒泡）. partition是返回一个基准值的index, index 左边都小于该index的数，右边都大于该index的数。


    public static void quickSort(int[] arrayToSort,int left ,int right){

        int p ;
        if( left < right){
            p = parition(arrayToSort,left,right);
            quickSort(arrayToSort,left,p-1); // 从[left,p-1]
            quickSort(arrayToSort, p + 1,right);//从[p+1,right]
        }

    }

    //三个指针 一个 是 i  从left开始 j 是从right开始 还有个基准变量
    private static int parition(int[] array,int left,int right){

        int povit = left;
        int j = right;
        int i = left;
        int povitNum = array[povit];
        while (i != j){
            while (array[j] >= povitNum && i != j){
                j--;
            }
            while ( array[i] <= povitNum && i != j){
                i++;
            }
            if(i == j){
                swap(array,povit,i);
            }
            swap(array,i,j);
        }

        return i;
    }


    public static int[] getMinKNumsByHeap(int[] arr,int k){

        if(arr == null || k <= 0){
            return null;
        }
        /*int[] heap = new int[k];
        for(int i = 0  ; i < k; i++){
            heapInsert(heap,arr[i],i);
        }

        for(int i = k ; i < arr.length;i++){
            if(arr[i] < heap[0]){
                heap[0] = arr[i];
                heapify(heap,0,k);
            }
        }
        return heap;
*/
        int[] heap = creatHeap(arr,k);
        for(int i = k ; i < arr.length ; ++i){
            if(arr[i] > heap[0]){
                insert(heap,arr[i]);
            }
        }
        return  heap;
    }

    private static void heapInsert(int[] arr, int value, int index) {
        arr[index] = value;
        while (index != 0){
            int parent = (index-1)/2;
            if(arr[parent] <arr[index]){
                swap(arr,index,parent);
                index = parent;
            }else {
                break;
            }
        }
    }

    public static void heapify(int[] arr,int index,int heapsize){

        int left = index * 2 + 1;
        int right = index * 2 +2 ;
        int largest = index;
        while (left < heapsize){
            if(arr[left] > arr[index]){
                largest = left;
            }
            if(right < heapsize && arr[right] > arr[largest]){
                largest = right;
            }
            if(largest != index){
                swap(arr,largest,index);
            }else {
                break;
            }
            index = largest;
            left = index * 2 + 1;
            right = index * 2 + 2;
        }
    }


    public static int[] creatHeap(int[] a,int k){
        int[] result = new int[k];
        for(int i = 0 ;i < k; ++i){
            result[i] = a[i];
        }

        for(int i = 0 ; i < k; ++i){
            int child = i;
            int parent = (i -1)/2;
            int temp = a[i];
            while(parent >= 0 && child != 0 && result[parent] > temp){
                result[child] = result[parent];
                child = parent;
                parent = (parent -1)/2;
            }
            result[child] = temp;
        }
        return result;
    }

    public static void insert(int[] a,int value){
        a[0] = value;
        int parent = 0;
        while (parent < a.length){
            int lchild = parent*2 + 1;
            int rchild = parent*2 + 2;
            int minIndex = parent;
            if(lchild < a.length && a[parent] > a[lchild]){
                minIndex = lchild;
            }
            if(rchild < a.length && a[minIndex] > a[rchild]){
                minIndex = rchild;
            }
            if(minIndex == parent){
                return ;
            }else {
                swap(a,parent,minIndex);
                parent = minIndex;
            }
        }
    }



    public static void main(String[] args) {
//        int[] array = {2,1,49,30,32,-1,20,50,49};

        int[] array = {26,5,98,108,28,99,100};
/*
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        array = new int[m];
        for(int i = 0 ; i < m;i++){
            array[i] = in.nextInt();
        }
*/
        System.out.println("before sort:" + Arrays.toString(array));
        long start = System.nanoTime();
//        insertSort(array);
//      selectSort(array);
//        mergerSort(array);
//        quickSort(array,0,array.length - 1);
        int[] heap = getMinKNumsByHeap(array,3);
        System.out.println(System.nanoTime() - start);
        System.out.println("After sort:"+Arrays.toString(heap));
    }
}