数据结构与算法学习笔记（七）选择、冒泡、快排排序

1. 选择排序

1.1 概述

选择排序（Selectionsort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

选择排序是不稳定的排序方法。

1.2 基本原理

(一). i=0。找出a[1…5]中的最小值a[3]=10，然后将a[0]和a[3]互换。 数列变化：20,40,30,10,60,50 – > 10,40,30,20,60,50

(二). i=1。找出a[2…5]中的最小值a[3]=20，然后将a[1]和a[3]互换。 数列变化：10,40,30,20,60,50 – > 10,20,30,40,60,50

(三). i=2。找出a[3…5]中的最小值，由于该最小值大于a[2]，该趟不做任何处理。

(四). i=3。找出a[4…5]中的最小值，由于该最小值大于a[3]，该趟不做任何处理。

(五). i=4。交换a[4]和a[5]的数据。 数列变化：10,20,30,40,60,50 – > 10,20,30,40,50,60

1.3 代码逻辑

 // 选择排序
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++){
                if (array[j] < array[min]){
                    min = j;
                }
            }
            if (min != i){
                swap(array,i,min);
            }
        }
    }

    /**
     * 交换数组元素
     * @param array 数组
     * @param i 交换元素
     * @param j 交换元素
     */
    public static void swap(int[] array,int i,int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

1.4 时间&空间复杂度

• 时间复杂度：O(N^2)
• 空间复杂度：O(1)

2. 冒泡排序

2.1 概述

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

2.2 基本原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

2.3 代码逻辑

    // 冒泡排序
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++){
            for (int j = 0; j < array.length - 1 - i; j++){
                // 相邻两个元素作比较，如果前面元素大于后面，进行交换
                if (array[j] > array[j + 1]){
                    int temp = array[j + 1];
                    array[j + 1] = array[i];
                    array[j] = temp;
                }
            }
        }
    }

2.4 时间&空间复杂度

• 时间复杂度：O(N^2)
• 空间复杂度：O(1)

3. 快排排序

3.1 概述

快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分。

3.2 基本原理

1. 从数列中挑出一个元素，称为 “基准”（pivot）
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序

3.3 代码逻辑

    // 快速排序
    public static void quickSort(int[] array,int left,int right){
        if (left < right){
            int pivot = getIndex(array, left, right);
            // 进行迭代对pivot之前和之后的数组进行相同的操作使整个数组变成有序
            quickSort(array, left, pivot - 1);
            quickSort(array, pivot + 1, right);
        }
    }

    public static int getIndex(int[] array, int left, int right) {
        // 设定基准值（pivot）
        int pivot = array[left];
        while (left < right){
            // 当队尾的元素大于等于基准数据时,向前挪动left指针
            while (left < right && array[right] >= pivot){
                right--;
            }
            // 如果队尾元素小于pivot了,需要将其赋值给left
            array[left] = array[right];
            // 当队首元素小于等于pivot时,向前挪动left指针
            while (left < right && array[left] < pivot){
                left++;
            }
            // 当队首元素大于pivot时,需要将其赋值给right
            array[right] = array[left];
        }
        // 跳出循环时left和right相等
        array[left] = pivot;
        return left;
    }

3.4 时间&空间复杂度

• 最好时间复杂度为：O(n log2 n )
• 最坏时间复杂度为：O(n^2 )
• 平均时间复杂度为: O(n log2 n )
• 空间复杂度为：O(1)