数据结构--堆

堆有两个特性:

  • 堆是一个完全二叉树
  • 堆中所有父节点都大于(最大堆)或者小于(最小堆)子结点。 在一般的实现中,我们可以用数组来存储堆中的元素,数组的索引用于实现结点左右孩子的查找。 最小堆的实现代码如下:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 
 * 功能描述: 最小堆的实现
 * 
 * @version 2.0.0
 * @author zhiminchen
 */
public class MinHeap<E extends Comparable<E>> {

    // 用于存储数据E对象
    private E[] data;
    // 当前数组已经存储了多少个数据
    private int size;

    public MinHeap(int capacity) {
        data = (E[]) new Comparable[capacity];
        size = 0;
    }

    public MinHeap() {
        this(16);
    }

    /**
     * 传入一个array数组,构造堆
     * 
     * @param array
     */
    public MinHeap(E[] array) {
        data = (E[]) new Comparable[array.length];
        // 将array数据复制到data数组中
        for (int i = 0; i < data.length; i++) {
            data[i] = array[i];
        }
        size = array.length;
        // 对堆中非叶子结点做siftDown操作, 这样堆的特性就维护好了
        for (int i = parent(array.length - 1); i >= 0; i--) {
            siftDown(i);
        }
    }

    /**
     * 
     * 功能描述: 堆是否为空的方法
     * 
     * @return boolean
     * @version 2.0.0
     * @author zhiminchen
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 
     * 功能描述: 返回当前堆的大小
     * 
     * @return int
     * @version 2.0.0
     * @author zhiminchen
     */
    public int size() {
        return size;
    }

    /**
     * 
     * 功能描述: 得到index的父亲结点
     * 
     * @param index
     * @return int
     * @version 2.0.0
     * @author zhiminchen
     */
    private int parent(int index) {
        if (index == 0)
            throw new IllegalArgumentException("index-0 doesn't have parent.");
        return (index - 1) / 2;
    }

    /**
     * 
     * 功能描述: 得到index的左孩子结点
     * 
     * @param index
     * @return int
     * @version 2.0.0
     * @author zhiminchen
     */
    private int left(int index) {
        return 2 * index + 1;
    }

    /**
     * 
     * 功能描述: 得到index下的右孩子结点
     * 
     * @param index
     * @return int
     * @version 2.0.0
     * @author zhiminchen
     */
    private int right(int index) {
        return 2 * index + 2;
    }

    /**
     * 
     * 功能描述: 往堆中增加元素element
     * 
     * @param element void
     * @version 2.0.0
     * @author zhiminchen
     */
    public void add(E element) {
        if (size >= data.length) {
            resize(data.length * 2);
        }

        data[size] = element;

        siftUp(size);
        size++;
    }

    /**
     * 
     * 功能描述: 删除堆顶的元素,并返回
     * 
     * @return E
     * @version 2.0.0
     * @author zhiminchen
     */
    public E remove() {
        if (size <= 0) {
            return null;
        }
        E ret = data[0];
        // 将数组的最后一个元素放到队列的头
        data[0] = data[size - 1];
        data[size - 1] = null;
        // 对size进行维护
        size--;
        // 对零位的数据进行下沉操作, 以保持堆的特性
        siftDown(0);
        return ret;
    }

    /**
     * 
     * 功能描述: 查看堆中最小的元素
     * 
     * @return E
     * @version 2.0.0
     * @author zhiminchen
     */
    public E findMin() {
        if (size == 0)
            throw new IllegalArgumentException("Can not findMin when heap is empty.");
        return data[0];
    }

    /**
     * 
     * 功能描述: 对index的元素进行下沉操作,以保持推的特性
     * 
     * @param index void
     * @version 2.0.0
     * @author zhiminchen
     */
    private void siftDown(int index) {
        int left = left(index);
        // 递归退出条件 left>=size说明当前节点已经是叶子节点了
        if (left >= size) {
            return;
        }
        // 假设index的左节点是最小的节点
        E min = data[left];
        // 如果index节点有右孩子并且右孩子比左孩子还小, index结点需要跟最小的节点进行交换
        if (left + 1 < size && min.compareTo(data[left + 1]) > 0) {
            min = data[left + 1];
            left = left + 1;
        }
        // 当index节点的数据比最小的节点还大的时候,则进行交换,否则结束
        if (data[index].compareTo(min) > 0) {
            swap(index, left);
            siftDown(left);
        }
    }

    /**
     * 
     * 功能描述: 对index元素进行上浮操作, 以维持队的特性
     * 
     * @param size2 void
     * @version 2.0.0
     * @author zhiminchen
     */
    private void siftUp(int index) {
        // 递归退出的条件
        if (index <= 0) {
            return;
        }
        // index节点比父亲节点小, 则进行上浮
        if (data[index].compareTo(data[parent(index)]) < 0) {
            swap(index, parent(index));
            // 递归调用,继续上浮
            siftUp(parent(index));
        }
    }

    /**
     * 
     * 功能描述: 交换索引为a, b的数据
     * 
     * @param a
     * @param b void
     * @version 2.0.0
     * @author zhiminchen
     */
    private void swap(int a,
                      int b) {
        E temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }

    /**
     * 
     * 功能描述: 对堆进行扩容
     * 
     * @param capacity void
     * @version 2.0.0
     * @author zhiminchen
     */
    private void resize(int capacity) {
        E[] temp = (E[]) new Object[capacity];
        for (int i = 0; i < data.length; i++) {
            temp[i] = data[i];
        }
        data = temp;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("heap size : %d capacity : %d ", size, data.length));
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    public static void main(String[] args) {
        Random random = new Random();
        int n = 100;
        Integer array[] = new Integer[n];
        for (int i = 0; i < 100; i++) {
            array[i] = random.nextInt(Integer.MAX_VALUE);
        }

        MinHeap<Integer> heap = new MinHeap<Integer>(array);

        System.out.println(heap);

        List<Integer> list = new ArrayList<Integer>();
        while (!heap.isEmpty()) {
            list.add(heap.remove());
        }

        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1) > list.get(i)) {
                throw new RuntimeException();
            }
        }

    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏java一日一条

Java 容器&泛型(1):认识容器

容器是Java语言学习中重要的一部分。泥瓦匠我的感觉是刚开始挺难学的,但等你熟悉它,接触多了,也就“顺理成章”地知道了。Java的容器类主要由两个接口派生而出:...

13820
来自专栏自学笔记

Data Structurestackheapheap的实现索引堆tree并查集图 Graph

堆的基本性质: ①堆中的某一个节点总是不小于或不大于其父节点的值。 ②堆总是一棵完全二叉树 比较经典的堆有二叉堆,费波纳茨堆等等。如果一棵二叉树最下层上的...

11530
来自专栏老马说编程

(43) 剖析TreeMap / 计算机程序的思维逻辑

40节介绍了HashMap,我们提到,HashMap有一个重要局限,键值对之间没有特定的顺序,我们还提到,Map接口有另一个重要的实现类TreeMap,在Tre...

22580
来自专栏用户3030674的专栏

Java 工具类—日期获得,随机数,系统命令,数据类型转换

16310
来自专栏Java爬坑系列

【Java入门提高篇】Day28 Java容器类详解(十)LinkedHashMap详解

  今天来介绍一下容器类中的另一个哈希表———》LinkedHashMap。这是HashMap的关门弟子,直接继承了HashMap的衣钵,所以拥有HashMap...

9620
来自专栏架构之路

Combination Sum II 组合数求和之2-Leetcode

原题: Given a collection of candidate numbers (C) and a target number (T), find al...

32050
来自专栏芋道源码1024

Jedis 对 Redis 的操作详解

本篇主要阐述Jedis对redis的五大类型的操作:字符串、列表、散列、集合、有序集合。

27230
来自专栏haifeiWu与他朋友们的专栏

聊聊HashSet源码

今天聊一下HashSet源码,HashSet内部基本使用HashMap来实现,本博客将通过一下几个方向讲解。

9930
来自专栏java系列博客

Java ConcurrentModificationException异常原因和解决方法

89120
来自专栏码匠的流水账

聊聊storm nimbus的mkAssignments

storm-2.0.0/storm-server/src/main/java/org/apache/storm/daemon/nimbus/Nimbus.jav...

14320

扫码关注云+社区

领取腾讯云代金券