七大排序算法详解——排序（二）选择排序（附Java代码，堆排序流程图解）

排序的相关概念

        排序：所谓排序，就是使一串记录，按照其中的某个或某几个关键字的大小，递增或递减排列起来的操作。

        稳定性：在待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种排序算法是稳定的。

        内部排序：把数据全部加载到内存中进行排序。

        外部排序：数据太多，内存不能存储了，将数据放到磁盘、U盘上进行排序。

排序算法的分类

插入排序：直接插入排序、希尔排序

选择排序：选择排序、堆排序

交换排序：冒泡排序、快速排序

归并排序：归并排序

排序算法实现

1.选择排序

1.1直接选择排序

基本思想：每一次从待排序的数据元素arr[i]~arr[n-1]中选出最小（最大）的一个元素，若它不是这组元素中的第一个元素（最后一个元素），则将它与该组元素arr[i]~arr[n-1]的第一个（最后一个）元素交换，直到全部待排序的数据元素排完。

代码实现：

public class Sort {
    public static void main(String[] args) {
        int[] arr = {2, 3, 1, 6, 5};
        sort3(arr);
        System.out.println(Arrays.toString(arr));
    }
 //直接选择排序
    public static void sort3(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]){
                    //找到[i,arr.length]中最小元素的索引
                    minIndex=j;
                }
            }
            swap(arr,i,minIndex);
        }

    }
    public static void swap(int[] arr,int i,int j){
       int tmp = arr[i];
       arr[i] = arr[j];
       arr[j]=tmp;

    }
}

特性总结：

1.时间复杂度：O(n^2)    

2.空间复杂度：O(1)

3.不稳定。例如数组：[3, 3, 1]，第一趟确定最小值后就变成[1, 3, 3]，原数组中的两个3的相对顺序就被改变了，所以我们说直接选择排序是不稳定的。

1.2堆排序

基本思想：利用堆这种数据结构设计的一种算法，是选择排序的一种。通过堆来选择数据，排升序建大堆，排降序建小堆。

大根堆：

 堆排序（大根堆）的详细图解：

1.待排序数组：

2.将点(len-2)/2作为父节点parent，点2*parent+1作为左孩子，在孩子节点不大于数组长度的情况下，判断右孩子是否存在 且 比较左孩子和右孩子的大小，选出最大的和父亲节点比较，若孩子节点大于父亲节点，交换父亲节点和孩子节点。否则parent+1。 

注：如果出现如下图的情况，到第三步后，导致子根[2,3,5]结构混乱，此时需要调整子根，即将孩子节点作为父亲节点parent，将2*parent+1作为左孩子，继续重复上述操作。

 此时完成大根堆的构建。

3.将堆顶元素与末尾元素进行交换，使末尾元素最大。将arr[0]作为父节点，然后继续向下调整堆，此时数组长度len-1,再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

代码实现：

1.升序建大堆

public class Sort {
    public static void main(String[] args) {
        int[] arr = {2, 3, 1, 6, 5};
        sort4(arr);
        System.out.println(Arrays.toString(arr));
    }
//堆排序
    public static void sort4(int[] arr){
        createHeap(arr);
        int len = arr.length-1;
        while(len>0){
            swap(arr,0,len);
            shiftDown(0,len,arr);
            len--;
        }
    }
    public static void createHeap(int[] arr) {
        int usedSize=arr.length;
        for (int parent = (usedSize - 1 - 1) / 2; parent >= 0; parent--) {
            shiftDown(parent, usedSize,arr);
        }
    }

    //parent：父亲下标  len:每棵树的结束下标
    public static void shiftDown(int parent, int len,int[] elem) {
        //parent的左孩子
        int child = 2 * parent + 1;
        while (child < len) {
            //有右孩子的情况下，找到左右孩子的最大值
            if (child + 1 < len && elem[child] < elem[child + 1]) {
                child++;
            }
            if (elem[child] > elem[parent]) {
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child;
                child = 2 * parent + 1;
            }else {
                break;
            }
        }
    }
}

2.降序建小堆 

//降序建小根堆
    public static void sort5(int[] arr) {
        int len = arr.length;
        createHeap2(arr, len);
        while(len>0){
            swap(arr,0,len-1);
            shiftDown2(arr,0,len-1);
            len--;
        }

    }

    public static void createHeap2(int[] arr, int len) {
        for (int parent = (len - 2) / 2; parent >= 0; parent--) {
            shiftDown2(arr, parent, len);
        }
    }

    public static void shiftDown2(int[] arr, int parent, int len) {
        int child = 2 * parent + 1;
        while (child < len) {
            if (child + 1 < len && arr[child] > arr[child + 1]) {
                child++;
            }
            if (arr[parent] > arr[child]) {
                int tmp = arr[parent];
                arr[parent] = arr[child];
                arr[child] = tmp;
                parent = child;
               child=2*parent+1;
            } else {
                break;
            }
        }
    }

特性总结：

1.时间复杂度：O(nlogn)    

2.空间复杂度：O(1)

3.不稳定