排序算法--Java代码详解版

冒泡排序

时间复杂度
最坏O(N^2)、最好O(N)

package com.czx.sort;

import java.util.Arrays;

public class Bubble {
    public static void main(String[] args) {
        int[] arr = {9,13,7,6,8};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
/**
 * 以[9,13,7,6,8]为例
 * 内部循环：
 * 一次冒泡arr.length-1
 * 9，13，7，6，8
 * 9，7，13，6，8
 * 9，7，6，13，8
 * 9，7，6，8，（13）
 * 二次冒泡 注意外层已经+1  arr.length-2
 * 7，9，6，8，13
 * 7，6，9，8，13
 * 7，6，8，9，13
 * 总结：内存循环次数为arr.length-1-i(i为外层循环次数)
 * 外部循环，每次都把最大的冒泡的最后
 * 13
 * 9，13
 * 8，9，13
 * 7，8，9，13
 * 6，7，8，9，13
 * 总共arr.length-1次循环
 */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

直接排序

时间复杂度
O(n^2)

package com.czx.sort;

import java.util.Arrays;

public class Selection {
    public static void main(String[] args) {
        int[] arr = {9,13,7,6,8};
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     *选择排序
     * 内部每循环遍历一次都要找到最小值min，并与初始位置交换
     * 以[9,13,7,6,8]为例
     * 内部一次循环后 （6），13，7，（9），8
     */
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

插入排序

(只介绍直接插入排序，其中希尔排序也是插入排序的一种不介绍)
时间复杂度
最坏O(N^2)、最好O(N)

package com.czx.sort;

import java.util.Arrays;

public class Insertion {
    public static void main(String[] args) {
        int[] arr = {9,13,7,6,8};
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     *默认无序数组往一个有序数里插数
     * 内存循环即保证插入一个数后有序数还保持有序
     * 外层循环即遍历无序数组的每个数，其中注意第一个从i=1开始，默认i=0为有序数
     */
    public static void insertionSort(int[] arr)  {
        for (int i = 1; i < arr.length; i++) {
        //key为待插入的无序数，j为有序数组中的最大值
            int key = arr[i];
            int j = i - 1;
            //j>=0用来跳出循环
            while (j >= 0 && arr[j] > key) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = key;
        }
    }
}

快速排序

对该排序思路不清楚的推荐一篇文章
快排讲解

package com.czx.sort;

import java.util.Arrays;

public class Quick {
    public static void main(String[] args) {
        int[] arr = {9,13,7,6,8};
        quickSort01(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    /**
     *
     * @param arr 数组元素
     * @param left 看作左指针
     * @param right 看作右指针
     *定义一个关键数pivot作为分界点，默认为第一个元素
     */
    public static void quickSort01(int[] arr, int left, int right) {
        int i = left, j = right;
        if (left > right) {
            return;
        }
        int pivot = arr[left];
        while (i < j) {
            //右指针往左遍历
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            //左指针往右遍历
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            //左右指针遍历到触发条件时则进行交换，即right<pivot&&left>pivot
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        
        arr[left] = arr[i];
        arr[i] = pivot;
        quickSort01(arr, left, j - 1);
        quickSort01(arr, j + 1, right);
    }
}