堆-数据结构-Java实现

最新推荐文章于 2024-08-19 21:18:51 发布
最新推荐文章于 2024-08-19 21:18:51 发布
阅读量174 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 堆 堆排序 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaogzhen/article/details/116123118
版权
堆-数据结构-Java实现
目录

文章目录



内容

1、基础理论

关于堆的概念、性质、结构等相关基本理论知识，可自行百度或者参考如下文章：

  1. 堆与C++实现
  2. 堆-百度百科
  3. 基本数据结构――堆的基本概念及其操作

数据结构与算法动态演示网址：
1.https://visualgo.net/zh/heap
2. https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

等等很多文章关于堆的介绍，这里我主要用Java语言，参考ArrayList源码，实现堆的基本操作：插入、上浮、弹出、下沉、打印等

2、基本操作实现

这里以最小堆为例。

2.1、插入与上浮

  • 上浮：默认新元素插入最后
    • 算法
      1. 以指定元素为启点
      2. 比较当前节点元素与其父元素大小
      3. 如果当前节点元素小于其父节点元素，则交互2个节点元素的值，把其父节点置为当前节点；否则算法结束。
      4. 重复步骤2~3，直到当前节点为根元素。
    • 代码：
/**
 * 上浮
 * @param index 其实元素索引
 */
public void floatUp(int index) {
	int i = index;
	for (int p = parentIndex(index); p >= 0; i = p, p = parentIndex(p)) {
		if (((E) elementData[p]).compareTo((E) elementData[i]) <= 0)
			return;
		Object o = elementData[p];
		elementData[p] = elementData[i];
		elementData[i] = o;

	}
}
  • 插入
    1. 新元素默认插入末尾
    2. 指定最后一个元素为当前元素，执行上浮操作
    3. 堆大小加1

2.2、取最小值、弹出、下沉

  • 下沉
    • 算法
      1. 以指定元素为启点
      2. 比较当前节点元素与其子节点元素大小，取最小值
      3. 如果当前节点元素为最小元素，则结束算法；如果左子节点为最小元素，则交互2个节点元素的值，把其左子节点节点置为当前节点；如果右子节点为最小元素，则交互2个节点元素的值，把其右子节点节点置为当前节点；
      4. 重新获取当前节点的左右子节点
      5. 重复步骤2~4，直到当前节点的左右子节点都为空。.
    • 代码：
 /**
 * 下沉
 * @param index     起始节点索引
 */
public void sink(int index) {
	int p = index;
	int l = leftChildIndex(p);
	int r = rightChildIndex(p);
	// 当当前节点没有子节点的时候,结束循环
	while (l < size || r < size) {
		// 取当前节点、左子树、右子树最小元素
		Object o = elementData[p];
		int f = 0;
		if (l < size) {
			if (((E) elementData[l]).compareTo((E) o) < 0) {
				o = elementData[l];
				f = 1;
			}
		}
		if (r < size) {
			if (((E) elementData[r]).compareTo((E)o) < 0) {
				o = elementData[r];
				f = 2;
			}
		}
		// 如果当前节点元素不大于其左右子树元素，则结束。
		if (f == 0) return;

		if (f == 1) {
			// 如果左子树为最小元素,交换元素，把其左子树节点置为当前节点
			elementData[l] = elementData[p];
			elementData[p] = o;
			p = l;
		}
		else {
			// 如果右子树为最小元素,交换元素，把其右子树节点置为当前节点
			elementData[r] = elementData[p];
			elementData[p] = o;
			p = r;
		}
		l = leftChildIndex(p);
		r = rightChildIndex(p);
	}
  • 弹出、取最小值
    1. 因为是最小堆，取最小值与弹出操作都是取堆顶元素
    2. 取根元素
    3. 把最后一个元素赋值为根节点
    4. 指定根节点为起始节点，执行下沉操作
    5. 堆大小减1

2.3、完整代码

  • 完整代码：
package com.gaogzhen.datastructure;

import java.util.Arrays;

public class Heap<E extends Comparable<E>> {
    // 数组默认容量大小
    private static final int DEFAULT_CAPACITY = 10;
    // 默认数组为空
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //默认数组为空
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 堆默认内置容器数组
    transient Object[] elementData;
    // 堆大小
    private int size;

    // 最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    // 操作计数器-实现迭代器时使用
    protected transient int modCount = 0;

    /**
     * 构造器
     * @param initialCapacity       初始容量
     */
    public Heap(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }
    }

    /**
     * 使用默认容量构造堆
     */
    public Heap() {
        this.elementData = new Object[DEFAULT_CAPACITY];
        ;
    }

    /**
     * 确保内置数组容量
     * @param minCapacity       最小容量
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                // any size if not default element table
                ? 0
                // larger than default for default empty table. It's already
                // supposed to be at default size.
                : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * 扩容
     * @param minCapacity   最小容量
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
     * 最大容量
     * @param minCapacity   最小容量
     * @return
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

 /**
     * 批量添加新元素
     * @param c     目标元素集合
     * @return      添加新元素是否成功
     */
    public boolean addAll(E[] c) {
        int l = c.length;
        for (E e : c) add(e);
        return true;
    }

    /**
     * 添加新元素
     * @param e     新元素
     * @return      添加新元素是否成功
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size] = e;
        // 向上调整
        if (size > 0)
            floatUp(size);
        size++;
        return true;
    }

    /**
     * 上浮
     * @param index 其实元素索引
     */
    public void floatUp(int index) {
        int i = index;
        for (int p = parentIndex(index); p >= 0; i = p, p = parentIndex(p)) {
            if (((E) elementData[p]).compareTo((E) elementData[i]) <= 0)
                return;
            Object o = elementData[p];
            elementData[p] = elementData[i];
            elementData[i] = o;

        }
    }

    /**
     * 获取左子树元素索引
     * @param index     目标元素索引
     * @return          左子树元素索引
     */
    private int leftChildIndex(int index) {
        return index * 2 + 1;
    }

    /**
     * 获取右子树元素索引
     * @param index     目标元素索引
     * @return          右子树元素索引
     */
    private int rightChildIndex(int index) {
        return index * 2 + 2;
    }

    /**
     * 获取父节点元素索引
     * @param index     目标元素索引
     * @return          父节点元素索引
     */
    private int parentIndex(int index) {
        // 如果节点为根节点，则返回-1
        return index <= 0 ? -1 : (index - 1) / 2;
    }

    /**
     * 下沉
     * @param index     起始节点索引
     */
    public void sink(int index) {
        int p = index;
        int l = leftChildIndex(p);
        int r = rightChildIndex(p);
        // 当当前节点没有子节点的时候,结束循环
        while (l < size || r < size) {
            // 取当前节点、左子树、右子树最小元素
            Object o = elementData[p];
            int f = 0;
            if (l < size) {
                if (((E) elementData[l]).compareTo((E) o) < 0) {
                    o = elementData[l];
                    f = 1;
                }
            }
            if (r < size) {
                if (((E) elementData[r]).compareTo((E)o) < 0) {
                    o = elementData[r];
                    f = 2;
                }
            }
            // 如果当前节点元素不大于其左右子树元素，则结束。
            if (f == 0) return;

            if (f == 1) {
                // 如果左子树为最小元素,交换元素，把其左子树节点置为当前节点
                elementData[l] = elementData[p];
                elementData[p] = o;
                p = l;
            }
            else {
                // 如果右子树为最小元素,交换元素，把其右子树节点置为当前节点
                elementData[r] = elementData[p];
                elementData[p] = o;
                p = r;
            }
            l = leftChildIndex(p);
            r = rightChildIndex(p);
        }
    }


    /**
     * 弹栈、弹出
     * @return
     */
    public E pop() {
        if (size <= 0) return null;

        Object item = elementData[0];
        elementData[0] = elementData[size -1];
        size--;
        sink(0); // 下沉
        return (E) item;
    }

	/**
     * 获取堆顶元素
     * @return      堆顶元素
     */
    public E peek() {
        return size == 0 ? null: (E) elementData[0];
    }
    
    /**
     * 判断堆是否空
     * @return      空，返回true;不空，返回false
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取堆大小
     * @return  堆大小
     */
    public int size() {
        return size;
    }

    /**
     * 打印堆
     * @return  打印堆，例如[1, 2, 3]
     */
    @Override
    public String toString() {
        if (size <= 0) return "[]";
        int iMax = size - 1;
        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(elementData[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
}

完整代码包括测试、其他数据结构与算法等等可查看下面仓库。

后记 ：

  欢迎交流，本人QQ:806797785

项目源代码地址：https://gitee.com/gaogzhen/algorithm
gaog2zh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构【java】| 堆
Cherils的博客
09-09 277
堆定义构建堆（Java实现）大顶堆小顶堆建堆 定义  堆(Heap)是一种数据结构。通常是一个能被看作树结构的数组对象，即可以理解为树结构，但是用数组存储。堆需要满足的性质：  1、堆中某个节点的值总是不大于或不小于其父节点的值；  2、堆总是一颗完全二叉树。 　常见的堆有二叉堆，斐波那契堆等。 　大根堆：也叫大顶堆，最大堆，所有父节点都满足大于等于其子节点的值的堆。 　小根堆：也叫小顶堆，最小堆，所有父节点都满足小于等于其子节点的值的堆。 　堆是一个完全二叉树，但是存储在数组中，父节点和孩子节点的关系由数
【数据结构】堆的实现
a778129656的博客
12-09 883
教你实现一个堆
最大堆 最小堆
woaichikaoya的博客
05-06 73
最大堆 public class MaxHeap <E extends Comparable<E>>{ private Array<E> data; public MaxHeap(int capacity){ data = new Array<>(capacity); } public MaxHeap() { data = new Array<>(); } pu
排序——冒泡、归并、快速、选择、插入、堆
x_k的专栏
05-30 645
冒泡排序，归并排序，快速排序，选择排序，插入排序，堆排序等Java代码实现以及原理分析
堆的结构学习
jiqiren1994的博客
08-12 125
一、定义 堆树的定义如下： （1）堆树是一颗完全二叉树； （2）堆树中某个节点的值总是不大于或不小于其孩子节点的值； （3）堆树中每个节点的子树都是堆树。 当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。 二、规范 ...
Java数据结构--堆
m0_74808313的博客
05-06 2341
当一颗二叉树的每个节点都大于等于它的两个子字节时，它被称为堆有序。而堆是一组能够用堆有序的完全二叉树排序的元素，并在数组中按照层级储存总而言之堆具有一下性质:①堆逻辑上是一颗完全二叉树，但本质上确是数组②堆中的某个节点总是不大于或不小于其父节点的值其中最主要且需要我们掌握的就是增( offer ) 删( poll )查( peek )等方法。
【堆】堆的实现（Java）
每天更新大数据面经和技术
04-23 2322
  今天学习堆这种数据结构。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： 堆中某个结点的值总是不大于或不小于其父结点的值； 堆总是一棵完全二叉树。 将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。 1.用优先队列实现 一般我们直接用优先队列实现堆： // 小顶堆，以 Integer 为例 PriorityQueue<Integer> pq = new PriorityQueue<>(); // 大顶堆 PriorityQueue<Int
java-数据结构代码实现
11-15
8. **排序算法**：包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等，这些排序算法的Java实现可以帮助你理解它们的工作原理和效率。 9. **查找算法**：如二分查找、哈希查找等，这些算法在处理大...
邓俊辉-数据结构，python实现.zip
06-16
《邓俊辉-数据结构，python实现》是针对数据结构这一计算机科学核心概念的一套学习资源，主要面向C/C++/JAVA/Python等编程语言的学习者。数据结构是计算机科学中处理数据组织方式的重要理论，它研究如何在内存中有效...
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构-堆(Heap)介绍和Java示例代码
07-01
堆（Heap）是一种特殊的数据结构，它以完全二叉树的形式存在，分为最大堆和最小堆。在最大堆中，每个父节点的值都大于或等于其子节点的值；相反，在最小堆中，父节点的值小于或等于其子节点的值。这种特性使得堆在...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
数据结构与算法（java）：堆
lalala_dxf的博客
03-01 1197
栈
数据结构与算法（Java）——堆
qq_45910820的博客
04-19 858
它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个。堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置。上浮：最后面的结点一直与父结点比较，如果比父结点大，就交换。而它的两个子结点的位置则分别为。，则它的父结点的位置为。
Java数据结构之堆(Heap)
qq15035899256的博客
08-04 3134
本文是Java数据结构的学习，认识了堆，学习了堆的上浮、下沉操作原理，以及自己手写一个大根堆。之后的学习内容将持续更新！！！
【JavaSE专栏17】用最简单的方法，实现 Java 的堆栈
Designer 小郑的技术博客
07-01 1367
本文简单对 Java 中的堆栈数据结构进行了介绍，讲解了堆栈实现原理，并给出了样例代码。
Java数据结构之堆
qq_39537400的博客
03-29 4327
堆的概念 堆逻辑上是一棵完全二叉树 堆物理上是保存在数组中 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 反之，则是小堆，或者小根堆，或者最小堆 堆的基本作用是快速找集合中的最值 二叉树的顺序存储 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的用法就是堆的表示。 顺序存储中的双亲与孩子的下标关系 已知双亲的下标： 左孩子下标 = 2*parent+1; 右孩子下标 = 2*parent
数据结构----栈
最新发布
新手嵌入式学习的博客
08-19 898
数据结构顺序栈和链式栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gaog2zh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值