（一）、堆排序

最新推荐文章于 2024-10-31 22:20:13 发布

Harrrold

最新推荐文章于 2024-10-31 22:20:13 发布

阅读量99

点赞数

分类专栏：左神算法笔记文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/leoBETT/article/details/121192849

版权

左神算法笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中实现堆排序的过程，包括heapInsert、heapify和swap等关键步骤。堆排序的时间复杂度为O(NlogN)，适用于大规模数据的排序。通过阅读，你可以理解堆排序的工作原理并学习到如何在实际编程中应用该算法。

摘要由CSDN通过智能技术生成

/**
 * @Description: 堆排序
 * @author: harold
 * @date: 2021年06月15日 22:09
 */
public class HeapSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        int heapSize = arr.length;
        swap(arr, 0, --heapSize);
        while (heapSize > 0) {
            heapfy(arr, 0, heapSize);
            swap(arr, 0, --heapSize);
        }
    }

    private static void heapfy(int[] arr, int index, int heapSize) {
        int left = 2 * index + 1;
        while (left < heapSize) {
            int largest = (left + 1) < heapSize && arr[left + 1] > arr[left]
                    ? (left + 1) : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, index, largest);
            index = largest;
            left = 2 * index + 1;
        }
    }

    /**
     * 时间复杂度：log1+log2+...+logn = O(N)
     * @param arr
     * @param index
     */
    private static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

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