冒泡、插入、选择排序算法

冒泡、插入、选择排序是最基础的三种算法，这三种算法的最差复杂度都是O(n^2)，相对来说还是比较低效的。后面还会介绍O(nlogn)复杂度的算法。

图片来源：极客时间

相关代码如下：

package com.program;


public class Sort {

    /**
     * 冒泡排序
     * 时间复杂度：最好n,最坏情况下n^2
     * 空间复杂度：O(1)
     */
    public void bubbleSort(int[] data) {
        if (data == null || data.length == 0) {
            return;
        }
        int n = data.length;
        int k = 0;
        for (int i = 0; i < n; i++) {
            boolean flag = false;
            //注意这里需要减1，否则会角标越界
            for (int j = 0; j < n - i - 1; j++) {
                k++;
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                    flag = true;
                }
            }
            //如果这一趟没有数据交换了，那么一定是完全有序了。
            if (!flag) {
                break;
            }
        }
        System.out.println("\nk is " + k);
    }

    /**
     * 插入排序
     * 核心思想：将数据分为两部分，一部分是有序的，一部分是无序的，然后将无序的挨个儿往有序里插，插着插着就有感觉了。
     * 空间复杂度：O(1)
     * 时间复杂度：最好n,最坏n^2
     * 说起来简单，实际上很容易出错，just do it
     */
    public void insertionSort(int[] data) {
        if (data == null || data.length == 0) {
            return;
        }
        int n = data.length;
        //外面的循环是无序列表
        int m = 0;
        for (int i = 1; i < n; i++) {
            int value = data[i];
            //为了方便搬动数据，这里最好选择从后往前遍历插
            int j = i - 1;
            //里边的循环是有序列表
            for (; j >= 0; j--) {
                //找到了插入的位置，在插入之前需要搬迁数据
                m++;
                if (value < data[j]) {
                    data[j + 1] = data[j];
                } else {
                    break;
                }
            }
            data[j + 1] = value;
            for (int k = 0; k < data.length; k++) {
                System.out.print(data[k] + " ");
            }
            System.out.println("\n");
        }
        System.out.println("总共执行了" + m + "次");
    }

    /**
     * 选择排序
     * 核心思想：和插入排序很类似，都分为两区，有序区&无序区，只不过不是从无序中往有序中插，
     * 而是从无序中选择一个最小的放在有序区的末尾，over.
     * 空间复杂度：O(1)
     * 时间复杂度：O(n^2)
     * 缺点:不够稳定
     */
    public void selectionSort(int[] data) {
        if (data == null || data.length == 0) {
            return;
        }
        int n = data.length;
        for (int i = 0; i < n; i++) {
            int min = data[i];
            int tempPosition = i;
            //找出最小数的位置
            for (int j = i; j < n - i; j++) {
                if (data[j] < min) {
                    min = data[j];
                    tempPosition = j;
                }
            }
            //最小数添加到后面
            if (tempPosition != i) {
                int temp = data[i];
                data[i] = data[tempPosition];
                data[tempPosition] = temp;
            }
        }
        for (int k = 0; k < data.length; k++) {
            System.out.print(data[k] + " ");
        }
    }


    public static void main(String[] args) {
        int[] data = new int[]{10,9,8,7,6,5,4,3,2,1};
        Sort sort = new Sort();
        //sort.bubbleSort(data);
        //sort.insertionSort(data);
        sort.selectionSort(data);
    }
}