八大排序算法-代码实现-Java

   // 直接插入排序
    public static void insertSort(int[] nums){
        /*
        * 思想：将一个元素插入一个已经排过序的数组
       *实例：假设数组的第二个元素为要插入的元素，第一个元素为已经排过序的数组
        * */


        // 依次遍历插入
        for(int i=1;i=0&& nums[j]>temp;j--){
                    // 依次往后移动
                    nums[j+1] = nums[j];
                }
                // 此时nums[j] <=temp, 将temp交换至+1处
                nums[j+1] = temp;
            }
        }
    }


    // 希尔排序
    public static void shellSort(int[] nums){

        /*
        *思想：先局部有序，再总体有序
        * 具体思路：
        * 1.通过一个增量（如nums.length/2)，来进行分组，（0->d)的元素的倍数为一组
        * 2. 分组后，通过通过直接插入排序进行排序
        * */

        // 确定初始增量
        int d = nums.length/2;

        // 通过whle 不断改变增量
        while (true){

            // 循环结束条件
            if(d == 1){
                break;
            }
            // 增量递减
            d=d/2;

            // 确定每组的初始值，遍历每组
            for(int x = 0;x=0 && nums[j]>temp;j=j-d){
                            nums[j+d] = nums[j]; // 需要把nums[i] 站住
                        }

                        // 经过循环后，nums[j]<=temp，故调换的位置在nums[j+d]
                        nums[j+d] = temp;
                    }
                }
            }


        }
    }

    //冒泡排序
    public static void bubbleSort(int[] nums){
        /*
        * 思想：依次比较相邻的两个元素，一轮下来会产生一个最大（或最小的元素）
        *
        * */

        for(int i=0;inums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
    }

    //快速排序
    /**
     *
     * @param nums 排序的数组
     * @param left 数组的初始位置
     * @param right 数组的末尾位置
     */
    public static void quickSort(int[] nums,int left,int right){
        /*
        * 思想：
        * 1.以第一个元素为基准（其他数也行）
        * 2. 首先从右侧指针开始，定位到一个比基准数小的元素的位置
        * 3.然后从左侧开始，定位到一个比基准数大的元素的位置
        * 4.交换这两个位置
        * 5.然后继续移动，直到左右指针相等，这时，left == right
        * 6.交换基准数宇nums[left]or nums[right]的位置
        * 7.这时以left or right 位置为中心，分成两个数组，依次使用  递归 ，快排 排序
        * */

        // 递归结束条件
        if(left>right){
            return;
        }

        // 首先记录 left 与right的位置
        int begin = left ;
        int end = right;

        // 基准数
        int baseNum = nums[left];

        // 移动左右指针，交换位置  ，最后交换基准数

        while (begin=baseNum  && begin=0;x--){
            heapAdjust(nums,x,len);
        }


        // 交换元素，重新调整len-1个数组的堆
        for (int i = nums.length-1;i>=0;i--){

            // 交换元素
            swap(nums,0,i);
            len--;
            // 重新调整 剩下元素为大顶推
            heapAdjust(nums,0,len);
        }

    }
    // 调整堆
    public static void heapAdjust(int[] nums,int i,int len){
        /*
        * 思想：调整时，只沿着改变的那个子节点的方向，进行向下调整
        * 原因：因为两个没改变的节点的方向，是最大堆了，不需要再调整了
        * */

        // 左右子节点
        int leftNo = 2*i+1;
        int rightNo = 2*i+2;

        // 先构建这三个节点的最大堆
        // 默认当前父节点，在这三个节点中，值为最大的那个
        int largest  = i;

        // 左子节点与父节点先比较
        if(leftNonums[j]){
                // 先放入临时数组
                tempArray[k++] = nums[j++]; // 放入小的
            }else {
                tempArray[k++] = nums[i++];
            }
        }

        // 如果有数组没有放完
        while (i0){
                    for(int q=0;q