总结了几种常见的排序算法

总结了简单排序和高级排序总共六种算法的代码。
直接贴

1.简单排序（冒泡排序、选择排序、插入排序）

package com.it.demo02.test;
import java.util.Arrays;

/**
 * @ClassName demo
 * @Description 三种简单排序
 * @Author zhangxin
 * @Date 2020/10/12 15:30
 */
public class demo {
    // 封装交换元素的方法，方便后面调用
    public static int[] exchange(int[] numbers, int previous, int next) {
        int temp = numbers[previous];
        numbers[previous] = numbers[next];
        numbers[next] = temp;
        return numbers;
    }

    //冒泡排序算法
    //冒泡排序每次遍历需要交换多次
    public static int[] bubbleSort(int[] numbers) {
        // 1. 设置每次遍历的长度,每遍历一次，长度 - 1
        for (int i = numbers.length-1; i >= 0; i--) {
            // 2. 从最左边的数开始，依次比较相邻元素
            for (int j = 0; j < i; j++) {
                // 3. 如果左边的数大于右边的数，则交换一下两个元素
                if (numbers[j] > numbers[j+1]){
                    exchange(numbers,j,j+1);
                }
            }
        }
        return numbers;
    }

    //选择排序算法
    //简单来说就是选择排序是每次遍历交换一次，而冒泡排序每次遍历需要交换多次，因此选择排序一般来说是要比冒泡排序效率高一点的。
    public static int[] selectionSort(int[] numbers) {
        // 1. 设定遍历的范围
        for (int i = 0; i < numbers.length-1; i++) {
            // 2. 先将遍历的起始索引设为最小值的索引
            int min = i;
            // 3. 从索引为min的后一个值开始遍历全部元素
            for (int j = min; j < numbers.length; j++) {
                // 4. 将每个遍历到的元素与 numbers[min]比较
                if (numbers[min] > numbers[j]){
                    min = j;
                }
            }
            // 4. 将得到的最小值的索引min上的元素与我们初始遍历的位置上的元素交换
            exchange(numbers,min,i);
        }
        return numbers;
    }

    //插入排序算法
    //插入排序是一种将指定元素与某个有序区域元素比较并交换位置的排序算法。
    public static int[] insertionSort(int[] numbers) {
        // 1. 从索引为1的元素开始向后遍历数组
        for (int i = 1; i < numbers.length; i++) {
            // 2. 取出有序区域右边第一个元素
            int temp = numbers[i];
            int j = i;
            // 3. 从右往左将有序区域内的元素与temp比较
            while(numbers[j - 1] > temp && j > 0) {
                numbers[j] = numbers[j - 1];
                j--;
            }
            // 4. 将temp插入到合适的位置
            numbers[j] = temp;
        }
        return numbers;
    }

    public static void main(String[] args) {
        int[] numbers = new int[]{45, -6, 1, 19, 34, 80, 2};
        int[] ints1 = bubbleSort(numbers);
        int[] ints2 = selectionSort(numbers);
        int[] ints3 = insertionSort(numbers);
        System.out.println("冒泡排序 比较次数：O(n²),交换次数：O(n²) 从小到大排序后的结果是:"+ Arrays.toString(ints1));
        System.out.println("选择排序 比较次数：O(n²),交换次数：O(n)  从小到大排序后的结果是:"+ Arrays.toString(ints2));
        System.out.println("插入排序 比较次数：O(n²),交换次数：O(n²) 从小到大排序后的结果是:"+ Arrays.toString(ints3));
    }
}

输出结果：

冒泡排序 比较次数：O(n²),交换次数：O(n²) 从小到大排序后的结果是:[-6, 1, 2, 19, 34, 45, 80]
选择排序 比较次数：O(n²),交换次数：O(n)  从小到大排序后的结果是:[-6, 1, 2, 19, 34, 45, 80]
插入排序 比较次数：O(n²),交换次数：O(n²) 从小到大排序后的结果是:[-6, 1, 2, 19, 34, 45, 80]

2.高级排序（希尔排序、归并排序、快速排序）

在这里插入代码片