java八大基础排序算法

//直接插入排序，数组是引用类型，作为方法的参数，其元素值将被改变
    public static void insertSort(int[] table)
    {
        System.out.println("直接插入排序");
        for (int i=1; i=0 && temp0; delta/=2)  //若干趟扫描，控制增量，增量减半
        {
            for (int i=delta; i=0 && temp=0 && i=0 && jtable[j+1])                   //反序时，交换
                {
                    int temp = table[j];
                    table[j] = table[j+1];
                    table[j+1] = temp;
                    exchange=true;                         //有交换 
                }
            System.out.print("第"+i+"趟: ");
            print(table);
        }
    }

    public static void quickSort(int[] table)              //快速排序
    {
        System.out.println("快速排序");
        quickSort(table, 0, table.length-1);
    }
    //一趟快速排序，begin、high指定序列的下界和上界，递归算法
    private static void quickSort(int[] table, int begin, int end)
    {
        if (begin=0; j--)                       //创建最小堆
            sift_min(table, j, n-1);
        System.out.println("最小堆？ "+isMinHeap(table));
            
        System.out.println("堆排序（降序）");
        for (int j=n-1; j>0; j--)                          //每趟将最小值交换到后面，再调整成堆
        {
            int temp = table[0];
            table[0] = table[j];
            table[j] = temp;
            sift_min(table, 0, j-1);
        }
    }
    //将以begin为根的子树调整成最小堆，begin、end是序列下界和上界
    private static void sift_min(int[] table, int begin, int end)
    {
        int i=begin,j=2*i+1;                               //i为子树的根，j为i结点的左孩子
        int temp=table[i];                                 //获得第i个元素的值
        while (j<=end)                                     //沿较小值孩子结点向下筛选
        { 
            if (jtable[j+1])              //数组元素比较（改成<为最大堆）
                j++;                                       //j为左右孩子的较小者
            if (temp>table[j])                             //若父母结点值较大（改成<为最大堆）
            {
                table[i]=table[j];                         //孩子结点中的较小值上移
                i=j;                                       //i、j向下一层
                j=2*i+1;
            }
            else break;                                    //退出循环
        }
        table[i]=temp;                                     //当前子树的原根值调整后的位置
        System.out.print("sift  "+begin+".."+end+"  ");
        print(table);
    }

    public static void heapSort_max(int[] table)           //堆排序（升序），最大堆
    {
        System.out.println("最大堆？ "+isMaxHeap(table));
        System.out.println("建立最大堆序列");
        int n=table.length;
        for (int j=n/2-1; j>=0; j--)                       //创建最大堆
            sift_max(table, j, n-1);
        System.out.println("最大堆？ "+isMaxHeap(table));
            
        System.out.println("堆排序（升序）");
        for (int j=n-1; j>0; j--)                          //每趟将最大值交换到后面，再调整成堆
        {
            int temp = table[0];
            table[0] = table[j];
            table[j] = temp;
            sift_max(table, 0, j-1);
        }
    }
    //将以begin为根的子树调整成最大堆，begin、end是序列下界和上界
    private static void sift_max(int[] table, int begin, int end)
    {
        int i=begin,j=2*i+1;                               //i为子树的根，j为i结点的左孩子
        int temp=table[i];                                 //获得第i个元素的值
        while (j<=end)                                     //沿较大值孩子结点向下筛选
        { 
            if (j