常见7种排序算法 java

归纳的7种算法，仅供参考。
基本无注释，以记录为主，其中后四种排序需要重点掌握。

import java.util.Arrays;

//常见7种排序算法
public class sort {

    public static void main(String[] args) {
        int[] nums={5,9,8,10,2};

        //冒泡排序
        bubbleSort(nums.clone());

        //选择排序
        selectSort(nums.clone());

        //插入排序
        insertSort(nums.clone());

        //希尔排序
        shellSort(nums.clone());

        //快速排序
        int[] nums1=nums.clone();
        quickSort(nums1,0,nums1.length-1);
        System.out.println(Arrays.toString(nums1));

        //归并排序
        int[] nums2=nums.clone();
        mergeSort(nums2,0,nums2.length-1);
        System.out.println(Arrays.toString(nums2));

        //堆排序
        int[] nums3=nums.clone();
        heapSort(nums3);
        System.out.println(Arrays.toString(nums3));
    }

    //每次都将当前最大的顶到后面
    private static void bubbleSort(int[] nums) {
        int len= nums.length;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                if (nums[j]>nums[j+1])
                    swap(nums,j,j+1);
            }
        }
        System.out.println(Arrays.toString(nums));
    }

    //每一次都找到最小的数依次放前面
    private static void selectSort(int[] nums) {
        int len= nums.length;
        for (int i = 0; i < len-1; i++) {
            int idx=i;
            for (int j = i; j < len; j++) {
                if (nums[idx]>nums[j])
                    idx=j;
            }
            swap(nums,i,idx);
        }
        System.out.println(Arrays.toString(nums));
    }

    //以一个数为基准，后面的数依次与前面作比较插入到合适的位置
    private static void insertSort(int[] nums) {
        int len=nums.length;
        for (int i = 1; i < len; i++) {
            int preIdx=i-1;
            int curNum=nums[i];
            while (preIdx>=0 && curNum<nums[preIdx]){
                nums[preIdx+1]=nums[preIdx--];
            }
            nums[preIdx+1]=curNum;
        }
        System.out.println(Arrays.toString(nums));
    }

    //缩小增量排序，步长每次减半，依次比较相距步长之间的数
    private static void shellSort(int[] nums) {
        int len= nums.length;
        for (int step = len/2; step >0 ; step/=2) {
            for (int i = step; i < len; i++) {
                for (int j = i; j >= step; j-=step) {
                    if (nums[j]<nums[j-step])
                        swap(nums,j,j-step);
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }

    /*以一个数为基准，将小于这个数的数放左边，大于这个数的数放右边，这样每次都能确定一个数的位置
        然后循环递归继续排序，是从整体到局部，运用分治算法的思想。
     */
    private static void quickSort(int[] nums,int left,int right) {
        if (left>=right)
            return;
        //每次以最右的数为基准
        int stand=nums[right];
        int idx=left;
        for (int i = left; i < right; i++) {
            if (nums[i]<stand)
                swap(nums,idx++,i);
        }
        swap(nums,idx,right);
        quickSort(nums,idx+1,right);
        quickSort(nums,left,idx-1);
    }

    /*
    将数组进行拆分，然后再进行合并比较排序，这样得到的数组是从局部到整体形成有序的
     */
    private static void mergeSort(int[] nums, int left, int right) {
        if (left<right){
            int mid=(right+left)/2;
            mergeSort(nums,left,mid);
            mergeSort(nums,mid+1,right);
            merge(nums,left,mid,right);
        }
    }

    //将[left,mid],[mid+1,right]两个区间的数进行比较合并
    private static void merge(int[] nums, int left, int mid, int right) {
        int i=left,j=mid+1;
        int[] temp=new int[right-left+1];
        int idx=0;
        while (i<= mid && j<= right){
            if (nums[i]<nums[j])
                temp[idx++]=nums[i++];
            else
                temp[idx++]=nums[j++];
        }
        while (i<=mid) temp[idx++]=nums[i++];
        while (j<=right) temp[idx++]=nums[j++];
        idx=0;
        for (int k = left; k <= right ; k++) {
            nums[k]=temp[idx++];
        }
    }

    /*运用完全二叉树的性质，每个节点的值都大于（小于）它的左右子节点
    当前节点的序号为i，则它的左节点为2*i+1，右节点为2*i+2
    如果求升序排序，需要构建大顶堆；降序排序，则构建小顶堆
    构建顶堆之后，将顶部的数与最后的数进行替换，能得到当前最大的（最小的）数，然后再进行建大顶堆（小顶堆）
    重复此操作
     */
    private static void heapSort(int[] nums) {
        //找最后一个非叶子节点
        int idx=nums.length/2-1;
        for (int i = idx; i >= 0; i--) {
            //建大顶堆
            adjustHeap(nums,i,nums.length);
        }
        for (int i = nums.length-1; i >= 0 ; i--) {
            swap(nums,0,i);
            adjustHeap(nums,0,i);
        }
    }

    private static void adjustHeap(int[] nums, int start, int len) {
        int cur=nums[start];
        for (int i = 2*start+1; i <len ; i=2*i+1) {
            if (i+1<len && nums[i]<nums[i+1])
                i++;
            if (nums[i]>cur){
                swap(nums,start,i);
                start=i;
            }
            else
                break;
        }
    }

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

}