冒泡排序、插入排序、选择排序、快速排序、归并排序【基础排序算法详解(java)】

前言

这几天复习排序算法的时候，发现之前写的那篇关于排序算法的文章有点过于复杂，所以想把经典的排序算法重新梳理一遍。争取让大家可以一遍就看懂。

1、冒泡算法

1. 算法介绍
冒泡算法是一种简单直观的排序算法，它需要重复的走访过要排序的数列，一次比较两个元素，如果顺序错误就交换过来，最小的元素会慢慢的“浮”到数列的顶端，这也是算法名字的由来

2.算法步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

我们可以在算法中加入一个flag标志，如果flag标志在某个数值的所有对比中没有发生变化，则说明已经排序好，可以直接返回答案

3. 代码实现

    private void bubbleSort(int[] arr) {
        for (int i = 1; i < arr.length; ++i) {
            boolean flag = true;
            for (int j = 0; j < arr.length - 1; ++j) {
                if (arr[j] >arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }

2、插入排序

1. 算法介绍
插入排序它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

2. 算法步骤

1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

3. 代码实现

    private static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; ++i) {
            int temp = arr[i];
            int j = i;
            while (j > 0 && temp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                --j;
            }
            if (i != j) {
                arr[j] = temp;
            }
        }
    }

3、选择排序

1. 算法介绍
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。好处可能就是不占用额外的内存空间。

2. 算法步骤

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3. 重复第二步，直到所有元素均排序完毕。

3. 代码实现

    private void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; ++i) {
            int min = i;
            for (int j = i + 1; j < arr.length; ++j) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            if (min != i) {
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
    }

4、快速排序

1. 算法介绍
快速排序使用分治法策略来把一个串行分为两个子串行。
快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

2. 算法步骤

1. 从数列中挑出一个元素，称为 “基准”（pivot）;

2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

3. 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序；
   
   3. 代码实现

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
	
	private int partition(int[] arr, int left, int right) {
        int pivot = left;
        int index = left + 1;
        for (int i = left + 1; i <= right; ++i) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                ++index;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

	private void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
    }

在这个示例中，我一直选择最左边的元素为基准，并进行分区

5、归并排序

1. 算法介绍
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。

2. 算法步骤

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

4. 重复步骤 3 直到某一指针达到序列尾；

5. 将另一序列剩下的所有元素直接复制到合并序列尾。

3. 代码实现

    private int[] mergeSort(int[] arr) {
        int[] arr_copy = Arrays.copyOf(arr, arr.length);
        if (arr_copy.length < 2) {
            return arr_copy;
        }
        int middle = (int)Math.floor(arr_copy.length / 2);
        int[] left = Arrays.copyOfRange(arr_copy, 0, middle);
        int[] right = Arrays.copyOfRange(arr_copy, middle, arr_copy.length);
        return merge(mergeSort(left), mergeSort(right));
    }

    private int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            }
            else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }
        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }
        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        return result;
    }