排序算法 -- (四)堆排序
发布日期:2021-05-10 17:10:05 浏览次数:16 分类:精选文章

本文共 3635 字,大约阅读时间需要 12 分钟。

���������

������������������������������

���������������������������������������������������������������������������������������������������������������heap������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

������������������

���������������������������������������������������������������������������������������������������������������������������������������������

  • ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

  • ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

  • ���������������������������������������������������������������������������������������������������������

  • ���������������������������������������O(n log n)���������������������������������������������������

    ������������������

    ������������������������������������������������������������������������������������������������������������������������

  • ���������������������������������������������������������������������������������������������������������parent���child���������������������������������������������������������������

  • ���������������������������������������������������������������������������������������������������������������������������������

  • ������������������������������������������

    public class HeapSort {
    public static void sort(int[] data) {
    int len = data.length;
    for (int i = 0; i < len; i++) {
    buildMaxHeap(data, len - 1 - i);
    }
    return data;
    }
    private static void buildMaxHeap(int[] data, int lastindex) {
    int k = (lastindex - 1) / 2;
    while (k >= 0) {
    int biggerIndex = 2 * k + 1;
    if (biggerIndex > lastindex) {
    break;
    }
    if (data[biggerIndex] > data[k]) {
    swap(data, k, biggerIndex);
    }
    k--;
    }
    }
    private static void swap(int[] data, int i, int j) {
    int temp = data[i];
    data[i] = data[j];
    data[j] = temp;
    }
    }

    ���������������������������������������

    • buildMaxHeap������������������������������������������������������������������������������������������������������������
    • swap���������������������������������������������������������������������������������������������

    ���������������������������������������������������������������������������������

    ������������������������

    ������������������������������������������������������������������������������������������������������������������������������������������������

  • ������������������������������������������������O(n log n)���������������������������������������������������������������������������������������������

  • ������������������������������������������������O(1)���������������������������������������������������������������

  • ������������������ilities������������������������������������������������������������������Keys���������������������������������������������������������������������

  • ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

    上一篇:排序算法 -- (五)冒泡排序
    下一篇:排序算法 -- (三)简单选择排序

    发表评论

    最新留言

    留言是一种美德,欢迎回访!
    [***.207.175.100]2025年04月05日 07时27分26秒