常用的排序算法

排序算法归总：

一、冒泡排序

/**
     * 冒泡排序
     * 时间复杂度：与数组的初始序列相关
     * 平均时间复杂度：O(n^2) 空间复杂度：O(1) 稳定
     * 最好：O(n)
     * 最差：O(n^2)
     */
    public static void maoPaoSort(int[] nums){
        for(int i = 0;i<nums.length-1;i++)
            for(int j = 0;j<nums.length-1-i;j++){
                if(nums[j+1]<nums[j]){
                    int temp = nums[j+1];
                    nums[j+1] = nums[j];
                    nums[j] = temp;
                }
            }
    }

    //改进版
    public static void maoPaoSort2(int[] nums){
        for(int i = 0;i<nums.length-1;i++){
            //定义一个布尔值
            boolean flag = true;
            for(int j = 0;j<nums.length-1-i;j++){
                if(nums[j+1]<nums[j]){
                    int temp = nums[j+1];
                    nums[j+1] = nums[j];
                    nums[j] = temp;
                    flag = false;
                }
            }

            if(flag) break;
        }

    }

二、插入排序

/**
     * 插入排序
     * 时间复杂度：与数组的初始序列相关
     * 平均时间复杂度：O(n^2) 空间复杂度：O(1) 稳定
     * 最好：正序：O(n)
     * 最差：逆序：O(n^2)
     * @param nums
     */
    public static void insertSort(int[] nums){
        if(nums.length>1){
            for(int i=1;i<nums.length;i++){
                int temp = nums[i];
                int j = i-1;
                while(j>=0 && nums[j]>temp){
                    nums[j+1] = nums[j];
                    j--;
                }
                nums[j+1] = temp;
            }
        }

    }

三、选择排序

/**
     * 选择排序
     * 时间复杂度：O(n^2) 空间复杂度：O(1) 不稳定
     */
    public static void selectSort(int[] nums){
        for(int i = 0;i<nums.length-1;i++){
            int min = i;
            for(int j = i+1;j<nums.length;j++){
                if(nums[j]<nums[min]){
                    min = j;
                }
            }
            if(min!=i){
                int temp = nums[min];
                nums[min] = nums[i];
                nums[i] = temp;
            }
        }
    }

四、快速排序

/**
     * 快速排序
     * 时间复杂度：O(nlogn) 不稳定
     */
    public static void quickSort(int[] nums,int left,int right){

        int begin = left;
        int end = right;
        if(begin>=end) return;

        //定义基准
        int pivot = nums[begin];
        while(begin<end){
            //从右往左遍历
            while(begin<end && nums[end]>pivot) end--;
            if(begin<end){
                nums[begin] = nums[end];
                begin++;
            }
            //从左往右遍历
            while(begin<end && nums[begin]<pivot) begin++;
            if(begin<end){
                nums[end] = nums[begin];
                end--;
            }
        }
        nums[begin] = pivot;
        quickSort(nums,left,begin-1);
        quickSort(nums,begin+1,right);
    }