排序算法之选择排序

选择排序

(一)直接选择排序

①特点

1.直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2.时间复杂度：O(N^2)
3.空间复杂度：O(1)
4.稳定性：不稳定

②基本思想

已这组数据为例

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

③代码

    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    swap(array, i, j);
                }
            }
        }
    }
     public static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

(二)堆排序

①特点

1.堆排序使用堆来选数，效率就高了很多。
2.时间复杂度：O(N*logN)
3.空间复杂度：O(1)
4.稳定性：不稳定

②基本思想：

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

1.首先要了解大堆和小堆的概念（堆是完全二叉树）

2.堆的构造

这里以升序为例，也就是构造大根堆

    public static void heapInsert(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int curIndex = i;
            int fatherIndex = (curIndex - 1) / 2;
            while (array[curIndex] > array[fatherIndex]) {
                swap(array, curIndex, fatherIndex);
                curIndex = fatherIndex;
                fatherIndex = (curIndex - 1) / 2;
            }
        }
    }

3.利用大根堆排序（向下调整）

public static void heap(int[] array, int index, int size) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        while (left < size) {
            int largeIndex;
            if (array[left] < array[right] && right < size) {
                largeIndex = right;
            } else {
                largeIndex = left;
            }
            if (array[largeIndex] < array[index]) {
                largeIndex = index;
            }
            if (index == largeIndex) {
                break;
            }
            swap(array, largeIndex, index);
            index = largeIndex;
            left = 2 * index + 1;
            right = 2 * index + 2;
        }
    }

4.总体框架

    public static void heapSort(int[] array) {
        //根据数组的升序或是降序来选择大根堆或者小根堆的构建，这里我们构建大根堆（因为我们希望数组升序排列）
        heapInsert(array);
        int size = array.length;
        while (size > 1) {
            //此时，我们已经得到一个大根堆，下面将顶端的数与最后一位数交换，然后将剩余的数再构造成一个大根堆
            swap(array, 0, size - 1);
            size--;
            /**
             * 此时最大数已经来到末尾，则固定不动，后面只需要对顶端的数据进行操作即可，
             * 拿顶端的数与其左右孩子较大的数进行比较，如果顶端的数大于其左右孩子较大的数，则停止，
             * 如果顶端的数小于其左右孩子较大的数，则交换，然后继续与下面的孩子进行比较
             */
            heap(array, 0, size);
            //剩余的数开始构造大根堆 ，然后顶端数与末尾数交换，固定最大值再构造大根堆，重复执行上面的操作，最终会得到有序数组
        }
    }