算法-基础-排序算法

八大排序算法

排序算法时间复杂度

排序算法

1, 选择排序(最容易想到)

• 时间复杂度: O(n²)
• 最好的情况下也是：O(n²)

大体思路：
第一轮从数组中选取最大的数据，放在最后一位。
第二轮从除了倒数第一位之外剩余的那些数中选择最大的，放在倒数第二位
第三轮从除了倒数后两位之外剩余的那些数中选取最大的，放在倒数第三位
…
n个数字经过(n-1)轮后，即可保证有序

package com.shangguigu.dachang.algrithm.A08_sort;

import java.util.Arrays;

/**
 * @author : 不二
 * @date : 2022/4/17-上午12:46
 * @desc : 选择排序
 **/
public class A03_SelectSort {
   
    public static void main(String[] args) {
   
        int[] nums = {
   9, -2, -1, 3, 10, 100, -3, 3, 4, 20};
        selectSort(nums);
        System.out.println(Arrays.toString(nums));
    }

    private static void selectSort(int[] nums) {
   
        for (int i = 0; i < nums.length; i++) {
   
            int maxIndex = 0;
            for (int j = 1; j < nums.length - i; j++) {
   
                if (nums[maxIndex] < nums[j]) {
   
                    maxIndex = j;
                }
            }
            // 然后把最大的数据和对应的位置交换
            if (maxIndex != (nums.length - i - 1)) {
   
                int temp = nums[nums.length - i - 1];
                nums[nums.length - i - 1] = nums[maxIndex];
                nums[maxIndex] = temp;
            }
        }
    }
}

2, 冒泡排序算法

• 时间复杂度： O(n²)

相邻的两个进行比较，如果前者比后者大，那么就把大的移动到后面。
第一轮把最大的移动到最后一位
第二位把次大的移动到倒数第二位
依次进行，直到有序(n个数最大进行n-1轮即可有序)

package com.shangguigu.dachang.algrithm.A08_sort;

import java.util.Arrays;

/**
 * @author : 不二
 * @date : 2022/4/16-下午9:26
 * @desc : 冒泡排序
 **/
public class A01_BubbuleSort {
   
    public static void main(String[] args) {
   
        int[] nums = {
   9, -2, -1, 3, 10, 100, -3, 3, 4, 20};
        bubbleSort(nums);
        System.out.println(Arrays.toString(nums));
    }

    /**
     * 每次遍历， 把最大的通过冒泡的方式移动到顶端
     * 然后下一次遍历，把剩余最大的通过冒泡的方式移动到剩余数据的顶端
     */
    public static void bubbleSort(int[] arr) {
   
        for (int i = 0; i < arr.length; i++) {
   
            // 这里要多减去1
            for (int j = 0; j < arr.length - i -1; j++) {
   
                if (arr[j] > arr[j + 1]) {
   
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }
}

3, 快速排序(常用)(平分移动+迭代排序)-冒泡算法的优化

• 时间复杂度： O(n${\log }_{2}n$)

快速排序思路
首先以中间一个数字为基准，把该数右侧大于该数的移至该数左侧，把该数左侧大于数的移至该数右侧。这样大于该数的数字都在右侧，小于该数的都在该数左侧。
接着再使用迭代算法, 依次对左侧的进行相同方法的移动。
接着再使用迭代算法, 依次对右侧的进行相同方法的移动。
当迭代结束，该数组数字即是有序

思路1: 中间值作为pivot，左右双指针移动

package com.shangguigu.dachang.algrithm.A08_sort;

import java.util.Arrays;

/**
 * @author : 不二
 * @date : 2022/4/16-下午9:43
 * @desc : 快速排序
 **/
public class A02_QuickSort_mid_pivot {
   
    public static void main(String[] args) {
   
        int[] nums = {
   9, -2, -1, 3, 10, 100, -3, 3, 4, 20};
        quickSort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }

    /**
     * 思路1：以中间为界限，通过左右双指针，把大于中间界限的数据移动到右侧，小于中间界限的数据移动到左侧
     * 然后左侧部分数据和右侧部分数据分别迭代调用上述规则
     * 这里用的左右指针
     */
    private static void quickSort(int[] nums, int left,