Array - 顺序排序

//堆排序
    public static void heap_sort(int[] arr) {

        //构建max堆
        for(int i = arr.length /2 -1 ;i >= 0 ; i -- ) {
            //下滤构建heap
            siftDown(arr, i, arr.length);
        }

        for (int i=arr.length - 1; i > 0; i--) {
            swap(arr,0,i); //交换 索引i 与 0（当前堆中最大元素）
            siftDown(arr, 0, i);    //将最大堆转移到当前堆的最后位置处，并对开始元素做下滤
        }

    }

    //下滤
    public static void siftDown(int[] arr, int i, int j) {
        int parent=arr[i];
        while (i < j/ 2) {
            int child = (i << 1) + 1 ;
            int temp=arr[child];
            int right = child + 1 ;
            //下滤 将每次的j 作为size大小
            if (child != j - 1 && temp < arr[right])
                temp = arr[child =right] ;

            if (temp < parent)
                break;

            arr[i] = temp ;
            i = child ;
        }
        arr[i] = parent ;
    }

 public static void quickly_sort(List<Integer> list) {

        if (list.size() > 1) {
            List<Integer> smaller=new ArrayList<>();
            List<Integer> same=new ArrayList<>();
            List<Integer> larger=new ArrayList<>();
            Integer center=list.get(list.size() / 2);
            for (Integer i : list) {
                if (i < center) {
                    smaller.add(i);
                } else if (i > center) {
                    larger.add(i);
                } else {
                    same.add(i);
                }
            }
            quickly_sort(smaller);   
            quickly_sort(larger);

            list.clear();
            list.addAll(smaller);
            list.addAll(same);
            list.addAll(larger);
        }
    }

 //希尔排序
    public static<T extends Object & Comparable<? super T>> void shell_sort( T[] arr) {
        int inner ,outer ;
        T temp ;
        int h = 1;
        while (h <= arr.length / 3) {
            h = 3 * h + 1 ;    // 最大间隔度
        }
        //依次以最大间隔度进行插入排序 减少排序移动次数
        while (h > 0) {
            for(outer = h ; outer < arr.length ; outer ++ ) {
                temp = arr[outer];
                inner = outer;
                while (inner > h - 1 && arr[inner - h] .compareTo(temp)>= 0) {
                    arr[inner]=arr[inner - h];
                    inner -= h ;
                }
                arr[inner] = temp;
            }
            h = (h - 1) / 3;
        }
    }

  //冒泡排序，每次相邻比较，大值向右移，即先确定最大值
    public static<T extends Object & Comparable<? super T>> void bubble_Sort(T [] arr){
        for(int i = 0 ; i < arr.length - 1; i ++ ) {          // 最小执行 n - 1次 即可
            for(int j = 0 ; j < arr.length - 1 - i ; j ++) {  //比较n - 1 次 ， n - 2 次， .... 1次 ；
                if (arr[j].compareTo(arr[j + 1]) > 0) {
                    swap( arr, j, j+1);
                }
            }
        }
    }

    //选择排序，取 index = 0 ， 与后面所有数字进行比较，确定最小
    public static<T extends Object & Comparable<? super T>> void select_Sort(T [] arr){
        for(int i = 0 ; i < arr.length - 1 ; i ++  ) {    //最小执行n-1 次
            for(int j = i + 1; j < arr.length  ; j ++ ) { //比较n - 1 次 ， n - 2 次， .... 1次 ；
                if (arr[i].compareTo(arr[j]) > 0) {
                    swap(arr, j, i);
                }
            }
        }
    }


    //插入排序 指定数字 与 左边有序进行比较 确定插入位置
    public static<T extends Object & Comparable<? super T>> void insert_Sort(T [] arr){
        int i , j ;
        for ( i = 1 ; i < arr.length ; i ++ ) {  //最少需要有 n - 1 次确定
            T temp = arr [i];  //1.指定一位  2.指定与左边有序的一位 + 1 3........
            j = i ;
            while (j > 0 && arr[j - 1].compareTo(temp) >= 0) {
                arr[j]=arr[j - 1];  // 1.确定左边有序 //2.与左边两位比较，确定插入位置 3........
                --j;
            }
            arr[j] = temp;  //插入数据  j：当前确定的位置
        }
    }



    public static <T extends Object & Comparable<? super T>>void print(T [] arr) {
        for (T t : arr) {
            System.out.print(t + "  ");
        }
    }

    public static <T extends Object & Comparable<? super T>> void swap(T[] arr, int i, int j) {
        T temp =arr [i];
        arr [i] = arr [j];
        arr [j] = temp ;
    }

    public static void main(String[] args) {
        Integer [] iArr={48,12, 25, 14, 1, 34, 28, 17 , 11};
        //bubble_Sort(iArr);  //冒泡排序测试
        //select_Sort(iArr);  //选择排序测试
        insert_Sort(iArr);   //插入排序测试
        print(iArr);
    }