Java 排序算法: 选择排序 (简单选择排序+堆排序)

五大类内部排序算法

1. 插入排序
2. 交换排序
3. 选择排序

• 简单选择排序
• 堆排序

4. 归并排序
5. 基数排序

简单选择排序: SelectSort

算法思路

1. 选择排序一共有[数组大小-1]轮排序
2. 每一轮排序, 又是一个循环, 循环的规约如下

• 先设定当前的这个数是最小值
• 与后面的数据逐个比较, 选出本轮最小的数值, 并且用 minIndex 和 minValue 分别记录下它的下标和值
• 与本轮设置的最小值进行交换位置[即与本轮循环的首位置进行交换]

实现

package com.com.beyond.dhl.utils.sort;

import java.util.Arrays;

public class SelectSort {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 5, 3, 2, 6, 7, 0, -3};

        System.out.println(Arrays.toString(arr));
        selectSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void selectSort(int[] arr) {
    
    

        for (int i = 0; i < arr.length - 1; i++) {
    
    
            int minIndex = i;  // 定义最小值的下标索引
            int minValue = arr[i]; // 保存最小值的临时变量

            for (int x = i + 1; x < arr.length; x++) {
    
    
                if (arr[x] < arr[i]) {
    
    
                    minIndex = x;
                    minValue = arr[x];
                }
            }
            if (minIndex != i) {
    
    
                arr[minIndex] = arr[i];    // 循环完后找到最小值进行交换位置
                arr[i] = minValue;
            }

        }

    }
}

简单选择排序 测试80000个随机数据的排序效率

 public static void main(String[] args) {
    
    
//        int[] arr = {1, 5, 3, 2, 6, 7, 0, -3};
//
//        System.out.println(Arrays.toString(arr));
//        selectSort(arr);
//        System.out.println(Arrays.toString(arr));

        int[] test = new int[80000];  // 测试数据
        for (int i = 0; i < test.length; i++) {
    
    
            test[i] = (int) (Math.random() * 1000000);  // 随机生成一个 [0,1000000) 数
        }

//        Date date = new Date();
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        System.out.println(dateFormat.format(date));

        long start = System.currentTimeMillis();
        selectSort(test);
        long end = System.currentTimeMillis();
        System.out.println("80000个随机数使用简单选择排序所耗时间为: " +(end - start) / 1000 + "秒");

    }

堆排序: HeapSort

算法思路:

1. 将待排序序列构成一个大顶堆
2. 此时, 整个序列的最大值就是堆顶的根节点
3. 将其与末尾元素进行交换, 此时末尾就是最大值
4. 然后将剩下的n-1个元素重新构造成一个堆, 只需要从 0 开始调用 调整堆(adjustHeap)方法即可[因为在之前第一步已经将该堆调整成了大顶堆, 交换数据只是与最后一个数据节点交换, 这是最后一个变为了第一个节点,我们调整该节点即可达到目的], 循环执行 n-1 次 交换与调整, 便可以得到一个有序序列了.

实现:

package com.com.beyond.dhl.utils.sort;

public class HeapSort {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 5, 3, 2, 6, 7, 0, -3};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));

    }


    public static void heapSort(int[] arr) {
    
    
        int temp = 0; // 用于交换位置

         /*          说明
        arr.length() = i * 2 + 2,  i 表示该完全二叉树中节点的个数
        k = n * 2 + 1,    k 表示当前以 n 为节点的 左子节点, k+1 即为右子节点
        */

        // 构建 大顶堆(升序排列)
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
    
      // i 表示最后一个非叶子结点, 由下到上进行 大顶堆的构建
            adjustHeap(arr, i, arr.length);
        }

        // 交换
        for (int j=arr.length-1; j>0;j--){
    
    
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, j); // 大顶堆中每次只是交换了第一个的节点, 即重新遍历该节点即可
        }

    }

    /**
     * 将一个数组(二叉树)调整为一个大顶堆
     *
     * @param arr       需要调整的数组
     * @param nodeValue 表示非叶子节点在数组中的索引
     * @param length    表示对多少个元素进行继续调整, length 是在逐渐的减少
     */
    public static void adjustHeap(int[] arr, int nodeValue, int length) {
    
    
        int temp = arr[nodeValue];  // 先取出当前非叶子节点的值, 保存临时变量

        /*          说明

        arr.length() = i * 2 + 2,  i 表示该完全二叉树中节点的个数
        k = n * 2 + 1,    k 表示当前以 n 为节点的 左子节点, k+1 即为右子节点

        */
        for (int k = nodeValue * 2 + 1; k < length; k = nodeValue * 2 + 1) {
    
    
            if (k + 1 < length && arr[k] < arr[k + 1]) {
    
       // 判断出较大的子节点用于与父结点进行比较
                k++;
            }
            if (arr[k] > temp) {
    
       // 选出的大的子节点与父节点进行交换
                arr[nodeValue] = arr[k];  // 完成大顶堆的赋值
                nodeValue = k;   // 该根节点移动到子节点k的位置, 继续判断k节点的子节点是否满足大顶堆(即for循环的 k = nodeValue * 2 + 1 )
                arr[nodeValue] = temp;   // 将temp值放到调整后的位置
            } else {
    
    
                break;
            }
        }
        // for 循环结束后, 我们将以 nodeValue 为父节点的树的最大值放到了最顶


    }
}

堆选择排序 测试八百万个随机数据的排序效率 (还是快排更胜一筹)

 public static void main(String[] args) {
    
    
//        int[] arr = {1, 5, 3, 2, 6, 7, 0, -3};
//        heapSort(arr);
//        System.out.println(Arrays.toString(arr));

        int[] test = new int[8000000];  // 测试数据
        for (int i = 0; i < test.length; i++) {
    
    
            test[i] = (int) (Math.random() * 1000000);  // 随机生成一个 [0,1000000) 数
        }
        long start = System.currentTimeMillis();
        heapSort(test);
        long end = System.currentTimeMillis();
        System.out.println("8百万个随机数使用堆排序所耗时间为: " +(end - start) + "毫秒");



    }