Java 中的堆实现

2025年8月4日 | 阅读 16 分钟

在 Java 中，堆是一种特殊的数据结构，其中根节点或父节点与左右子节点进行比较，并根据顺序排列。假设 x 是一个根节点，y 是一个子节点，属性key(x) <= key(y) 会生成最小堆，并且这种关系被称为“堆属性”。

根据父节点和子节点的顺序，堆可以分为两种形式，即最小堆和最大堆。让我们一个一个地理解它们，并在 Java 中实现代码。

堆的操作

插入：将新元素添加到堆（数组）的末尾，然后“向上堆化”，通过将添加的元素与其父节点进行比较并根据需要进行交换，直到找到正确的位置，以维护堆属性。

删除：删除根元素（最小堆的最小值，最大堆的最大值），用堆中的最后一个元素替换它，然后“向下堆化”，通过将新的根与其子节点进行比较并根据需要进行交换，直到找到正确的位置。

堆化：调整堆以维护堆属性。在向上堆化中，将新添加的元素与其父节点进行比较，并在需要时进行交换。在向下堆化中，将根元素与其子节点进行比较，并在需要时进行交换。此过程确保堆仍然是有效的最小堆或最大堆。

最小堆

最小堆是一种特殊的堆数据结构，它本身是一个完全二叉树。最小堆具有以下属性

根节点的值总是小于堆中的其他节点。
每个内部节点的值总是小于或等于其子节点。

我们可以在最小堆中执行以下三个操作

insertNode()

我们可以通过将新键添加到树的末尾来在最小堆中执行插入。如果插入键的值小于其父节点，我们必须向上遍历键以满足堆属性。插入过程需要 O(log n) 时间。

extractMin()

这是最重要的操作之一，我们通过它来删除最小值节点，即堆的根节点。删除根节点后，我们必须确保堆属性得到维护。extractMin() 操作需要 O(Logn) 时间来从堆中删除最小值。

getMin()

getMin() 操作用于以 O(1) 时间获取堆的根节点，即最小值。

示例

最小堆算法

proceduredesign_min_heap
Array arr: of size n => array of elements
// call min_heapify procedure for each element of the array to form min heap
repeat for (k = n/2 ; k >= 1 ; k--)
	call procedure min_heapify (arr, k);
proceduremin_heapify (vararr[ ] , var k, varn)
{
varleft_child  = 2*k;
varright_child = 2*k+1;
var smallest;
if(left_child<= n and arr[left_child ] <arr[ k ] )
smallest = left_child;
else
smallest = k;
if(right_child<= n and arr[right_child ] <arr[smallest] )
smallest = right_child;
if(smallest != k)
    {
swaparr[ k ] and  arr[ smallest ]);
callmin_heapify (arr, smallest, n);
    } 
}

MinHeapJavaImplementation.java

// import required classes and packages
packagejavaTpoint.javacodes;

importjava.util.Scanner;

// create class MinHeap to construct Min heap in Java
classMinHeap { 
	// declare array and variables
privateint[] heapData; 
privateintsizeOfHeap; 
privateintheapMaxSize; 

private static final int FRONT = 1; 
    //use constructor to initialize heapData array
publicMinHeap(intheapMaxSize)  { 
this.heapMaxSize = heapMaxSize; 
this.sizeOfHeap = 0; 
heapData = new int[this.heapMaxSize + 1]; 
heapData[0] = Integer.MIN_VALUE; 
    } 

    // create getParentPos() method that returns parent position for the node 
privateintgetParentPosition(int position)  { 
return position / 2; 
    } 

    // create getLeftChildPosition() method that returns the position of left child 
privateintgetLeftChildPosition(int position)  { 
return (2 * position); 
    } 

    // create getRightChildPosition() method that returns the position of right child
privateintgetRightChildPosition(int position)  { 
return (2 * position) + 1; 
    } 

    // checks whether the given node is leaf or not
privatebooleancheckLeaf(int position)  { 
if (position >= (sizeOfHeap / 2) && position <= sizeOfHeap) { 
return true; 
        } 
return false; 
    } 

    // create swapNodes() method that perform swapping of the given nodes of the heap 
    // firstNode and secondNode are the positions of the nodes
private void swap(intfirstNode, intsecondNode)  { 
int temp; 
temp = heapData[firstNode]; 
heapData[firstNode] = heapData[secondNode]; 
heapData[secondNode] = temp; 
    } 

    // create minHeapify() method to heapify the node for maintaining the heap property
private void minHeapify(int position)  { 

        //check whether the given node is non-leaf and greater than its right and left child
if (!checkLeaf(position)) { 
if (heapData[position] >heapData[getLeftChildPosition(position)] || heapData[position] >heapData[getRightChildPosition(position)]) { 

                // swap with left child and then heapify the left child 
if (heapData[getLeftChildPosition(position)] <heapData[getRightChildPosition(position)]) { 
swap(position, getLeftChildPosition(position)); 
minHeapify(getLeftChildPosition(position)); 
                } 

                // Swap with the right child and heapify the right child 
else { 
swap(position, getRightChildPosition(position)); 
minHeapify(getRightChildPosition(position)); 
                } 
            } 
        } 
    } 

    // create insertNode() method to insert element in the heap
public void insertNode(int data)  { 
if (sizeOfHeap>= heapMaxSize) { 
return; 
        } 
heapData[++sizeOfHeap] = data; 
int current = sizeOfHeap; 

while (heapData[current] <heapData[getParentPosition(current)]) {  
swap(current, getParentPosition(current)); 
current = getParentPosition(current); 
        } 
    } 

    // crreatedisplayHeap() method to print the data of the heap 
public void displayHeap()  { 
System.out.println("PARENT NODE" + "\t" + "LEFT CHILD NODE" + "\t" + "RIGHT CHILD NODE");
for (int k = 1; k <= sizeOfHeap / 2; k++) { 
System.out.print(" " + heapData[k] + "\t\t" + heapData[2 * k] + "\t\t" + heapData[2 * k + 1]); 
System.out.println(); 
        } 
    } 

   // create designMinHeap() method to construct min heap
public void designMinHeap()  { 
for (int position = (sizeOfHeap / 2); position >= 1; position--) { 
minHeapify(position); 
        } 
    } 

    // create removeRoot() method for removing minimum element from the heap
publicintremoveRoot()  { 
intpopElement = heapData[FRONT]; 
heapData[FRONT] = heapData[sizeOfHeap--]; 
minHeapify(FRONT); 
returnpopElement; 
    } 
}

// create MinHeapJavaImplementation class to create heap in Java
classMinHeapJavaImplementation{
	
	// main() method start
public static void main(String[] arg)  { 
	// declare variable
	intheapSize;
	
	// create scanner class object
	Scanner sc = new Scanner(System.in);
	
	System.out.println("Enter the size of Min Heap");
	heapSize = sc.nextInt();
	
	MinHeapheapObj = new MinHeap(heapSize);
	
	for(inti = 1; i<= heapSize; i++) {
		System.out.print("Enter "+i+" element: ");
		int data = sc.nextInt();
		heapObj.insertNode(data);
	}
	
        // close scanner class obj
sc.close();

        //construct a min heap from given data
heapObj.designMinHeap(); 

        //display the min heap data
System.out.println("The Min Heap is "); 
heapObj.displayHeap(); 

        //removing the root node from the heap
System.out.println("After removing the minimum element(Root Node) "+heapObj.removeRoot()+", Min heap is:"); 
heapObj.displayHeap(); 

    } 
}

输出

使用数组

最小堆是一种二叉树，其中父节点的值总是小于其子节点的值，从而确保最小值位于根节点。使用数组在 Java 中实现最小堆可以通过简单的索引算术来实现高效的插入、删除和堆化。这种结构非常适合需要快速访问最小元素的应用程序，例如优先队列。

文件名：RefactoredMinHeap.java

import java.util.Arrays; // Importing the Arrays class for array manipulation
public class RefactoredMinHeap {
    private int[] heapArray; // Array to store heap elements
    private int currentSize; // Current number of elements in the heap
    private int maxSize; // Maximum capacity of the heap
    // Constructor to initialize the heap with a given capacity
    public RefactoredMinHeap(int maxSize) {
        this.maxSize = maxSize; // Set the maximum size
        this.currentSize = 0; // Initialize current size to 0
        heapArray = new int[maxSize]; // Create a new array of the given capacity
    }
    // Method to get the index of the parent of a given node
    private int getParentIndex(int index) {
        return (index - 1) / 2; // Return the parent index
    }
    // Method to get the index of the left child of a given node
    private int getLeftChildIndex(int index) {
        return (index * 2) + 1; // Return the left child index
    }
    // Method to get the index of the right child of a given node
    private int getRightChildIndex(int index) {
        return (index * 2) + 2; // Return the right child index
    }
    // Method to check if a node is a leaf node
    private boolean isLeafNode(int index) {
        return getRightChildIndex(index) >= currentSize || getLeftChildIndex(index) >= currentSize; // Check if the node is a leaf node
    }
    // Method to insert a new element into the heap
    public void addElement(int element) {
        if (currentSize >= maxSize) { // If the heap is full, return
            return;
        }
        heapArray[currentSize] = element; // Add the new element to the heap
        int currentIndex = currentSize; // Initialize current index
        // Bubble up the new element to maintain heap property
        while (heapArray[currentIndex] < heapArray[getParentIndex(currentIndex)]) {
            swapElements(currentIndex, getParentIndex(currentIndex)); // Swap with parent if smaller
            currentIndex = getParentIndex(currentIndex); // Update current index to parent index
        }
        currentSize++; // Increase the current size of the heap
    }
    // Method to remove and return the minimum element from the heap
    public int removeMin() {
        int minElement = heapArray[0]; // The root element is the minimum element
        heapArray[0] = heapArray[--currentSize]; // Replace the root with the last element
        heapifyDown(0); // Heapify down from the root to maintain heap property
        return minElement; // Return the minimum element
    }
    // Method to heapify down from a given index
    private void heapifyDown(int index) {
        // If the node is not a leaf node
        if (!isLeafNode(index)) {
            // If the current node is greater than either of its children
            if (heapArray[index] > heapArray[getLeftChildIndex(index)] || 
                heapArray[index] > heapArray[getRightChildIndex(index)]) {
                // Swap with the smaller child and heapify down recursively
                if (heapArray[getLeftChildIndex(index)] < heapArray[getRightChildIndex(index)]) {
                    swapElements(index, getLeftChildIndex(index));
                    heapifyDown(getLeftChildIndex(index));
                } else {
                    swapElements(index, getRightChildIndex(index));
                    heapifyDown(getRightChildIndex(index));
                }
            }
        }
    }
    // Method to build a min heap from an arbitrary array
    public void buildMinHeap() {
        // Heapify down from the last non-leaf node to the root
        for (int i = (currentSize / 2) - 1; i >= 0; i--) {
            heapifyDown(i);
        }
    }
    // Method to display the heap elements
    public void displayHeap() {
        // Loop through each parent node and print its children
        for (int i = 0; i < currentSize / 2; i++) {
            System.out.print("Parent : " + heapArray[i]);
            if (getLeftChildIndex(i) < currentSize)
                System.out.print(" Left : " + heapArray[getLeftChildIndex(i)]);
            if (getRightChildIndex(i) < currentSize)
                System.out.print(" Right : " + heapArray[getRightChildIndex(i)]);
            System.out.println();
        }
    }
    // Method to swap two elements in the heap
    private void swapElements(int index1, int index2) {
        int temp = heapArray[index1]; // Temporary variable to hold one element
        heapArray[index1] = heapArray[index2]; // Swap the elements
        heapArray[index2] = temp; // Complete the swap
    }
    // Main method to test the heap implementation
    public static void main(String[] args) {
        RefactoredMinHeap minHeap = new RefactoredMinHeap(7); // Create a new heap of size 7
        minHeap.addElement(3); // Insert element 3
        minHeap.addElement(13); // Insert element 13
        minHeap.addElement(7); // Insert element 7
        minHeap.addElement(16); // Insert element 16
        minHeap.addElement(21); // Insert element 21
        minHeap.addElement(12); // Insert element 12
        minHeap.addElement(9); // Insert element 9
        minHeap.buildMinHeap(); // Build the min heap
        // Display the heap
        System.out.println("The Min Heap is: " + Arrays.toString(minHeap.heapArray));
        minHeap.displayHeap(); // Display the heap elements
        System.out.println("\nThe Min Value is: " + minHeap.removeMin()); // Remove and print the minimum value
        System.out.println("\nThe Min Heap is: " + Arrays.toString(minHeap.heapArray)); // Display the heap after removal
        minHeap.displayHeap(); // Display the heap elements
    }
}

输出

The Min Heap is: [3, 13, 7, 16, 21, 12, 9]
Parent : 3 Left : 13 Right : 7
Parent : 13 Left : 16 Right : 21
Parent : 7 Left : 12 Right : 9

The Min Value is: 3

The Min Heap is: [7, 13, 9, 16, 21, 12, 9]
Parent : 7 Left : 13 Right : 9
Parent : 13 Left : 16 Right : 21
Parent : 9 Left : 12

最大堆

最大堆是另一种特殊的堆数据结构，它在 Java 中也是一个完全二叉树。最大堆具有以下属性

根节点的值总是大于堆中的其他节点。
每个内部节点的值总是大于或等于其子节点。

我们可以在最大堆中执行以下三个操作

insertNode()

我们可以通过将新键添加到树的末尾来在最大堆中执行插入。如果插入键的值大于其父节点，我们必须向上遍历键以满足堆属性。插入过程需要 O(log n) 时间。

extractMax()

这是最重要的操作之一，我们通过它来删除最大值节点，即堆的根节点。删除根节点后，我们必须确保堆属性得到维护。extractMax() 操作需要 O(Log n) 时间来从堆中删除最大值。

getMax()

getMax() 操作用于以 O(1) 时间获取堆的根节点，即最大值。

示例

最小堆算法

proceduredesign_max_heap
Array arr: of size n => array of elements
// call min_heapify procedure for each element of the array to form max heap
repeat for (k = n/2 ; k >= 1 ; k--)
	call procedure max_heapify (arr, k);
proceduremin_heapify (vararr[ ] , var k, varn)
{
varleft_child  = 2*k + 1;
varright_child = 2*k+ 2;
if(left_child<= n and arr[left_child] >arr[ largest ] )
largest = left_child;
else
largest = k;
if(right_child<= n and arr[right_child] >arr[largest] )
largest = right_child;
if(largest != k)
    {
swaparr[ k ] and  arr[ largest ]);
callmax_heapify (arr, largest, n);
    } 
}

MaxHeapJavaImplementation.java

//import required classes and packages
packagejavaTpoint.javacodes;

importjava.util.Scanner;

//create class MinHeap to construct Min heap in Java
classMaxHeap { 
	// declare array and variables
	privateint[] heapData; 
	privateintsizeOfHeap; 
	privateintheapMaxSize; 

	private static final int FRONT = 1; 

	//use constructor to initialize heapData array
	publicMaxHeap(intheapMaxSize)  { 
		this.heapMaxSize = heapMaxSize; 
		this.sizeOfHeap = 0; 
		heapData = new int[this.heapMaxSize];
	} 

	// create getParentPos() method that returns parent position for the node 
	privateintgetParentPosition(int position)  { 
		return (position - 1) / 2; 
	} 

	// create getLeftChildPosition() method that returns the position of left child 
	privateintgetLeftChildPosition(int position)  { 
		return (2 * position); 
	} 

	// create getRightChildPosition() method that returns the position of right child
	privateintgetRightChildPosition(int position)  { 
		return (2 * position) + 1; 
	} 

	// checks whether the given node is leaf or not
	privatebooleancheckLeaf(int position)  { 
		if (position > (sizeOfHeap / 2) && position <= sizeOfHeap) { 
			return true; 
		} 
		return false; 
	} 

	// create swapNodes() method that perform swapping of the given nodes of the heap 
	// firstNode and secondNode are the positions of the nodes
	private void swap(intfirstNode, intsecondNode)  { 
		int temp; 
		temp = heapData[firstNode]; 
		heapData[firstNode] = heapData[secondNode]; 
		heapData[secondNode] = temp; 
	} 

	// create maxHeapify() method to heapify the node for maintaining the heap property
	private void maxHeapify(int position)  { 

	     //check whether the given node is non-leaf and greater than its right and left child
	if (!checkLeaf(position)) { 
	if (heapData[position] <heapData[getLeftChildPosition(position)] || heapData[position] <heapData[getRightChildPosition(position)]) { 
	
	             // swap with left child and then heapify the left child 
	if (heapData[getLeftChildPosition(position)] >heapData[getRightChildPosition(position)]) { 
	swap(position, getLeftChildPosition(position)); 
	maxHeapify(getLeftChildPosition(position)); 
	             } 
	
	             // Swap with the right child and heapify the right child 
	else { 
	swap(position, getRightChildPosition(position)); 
	maxHeapify(getRightChildPosition(position)); 
	             } 
	         } 
	     } 
	} 

	// create insertNode() method to insert element in the heap
	public void insertNode(int data)  { 
		heapData[sizeOfHeap] = data; 
		int current = sizeOfHeap; 

		while (heapData[current] >heapData[getParentPosition(current)]) {  
			swap(current, getParentPosition(current)); 
			current = getParentPosition(current); 
		} 
		sizeOfHeap++;
	} 

	// create displayHeap() method to print the data of the heap 
	public void displayHeap()  { 
		System.out.println("PARENT NODE" + "\t" + "LEFT CHILD NODE" + "\t" + "RIGHT CHILD NODE");
		for (int k = 0; k <sizeOfHeap / 2; k++) { 
			System.out.print(" " + heapData[k] + "\t\t" + heapData[2 * k + 1] + "\t\t" + heapData[2 * k + 2]); 
			System.out.println(); 
		} 
	} 

	// create designMaxHeap() method to construct min heap
	public void designMaxHeap()  { 
		for (int position = 0;  position < (sizeOfHeap / 2); position++) { 
			maxHeapify(position); 
		} 
	} 

	// create removeRoot() method for removing maximum element from the heap
	publicintremoveRoot()  { 
		intpopElement = heapData[FRONT]; 
		heapData[FRONT] = heapData[sizeOfHeap--]; 
		maxHeapify(FRONT); 
		returnpopElement; 
	} 
}

//create MinHeapJavaImplementation class to create heap in Java
classMaxHeapJavaImplementation{
	
	// main() method start
public static void main(String[] arg)  { 
	// declare variable
	intheapSize;
	
	// create scanner class object
	Scanner sc = new Scanner(System.in);
	
	System.out.println("Enter the size of Max Heap");
	heapSize = sc.nextInt();
	
	MaxHeapheapObj = new MaxHeap(50);
	
	for(inti = 1; i<= heapSize; i++) {
		System.out.print("Enter "+i+" element: ");
		int data = sc.nextInt();
		heapObj.insertNode(data);
	}
	
     // close scanner class obj
sc.close();

     //construct a max heap from given data
heapObj.designMaxHeap(); 

     //display the max heap data
System.out.println("The Max Heap is "); 
heapObj.displayHeap(); 

     //removing the root node from the heap
System.out.println("After removing the maximum element(Root Node) "+heapObj.removeRoot()+", Max heap is:"); 
heapObj.displayHeap(); 

 } 
}

输出

使用 Collections.reverseOrder() 方法通过库函数

Java 中的 Collections.reverseOrder() 方法是一个强大的实用程序，用于反转集合中元素的自然顺序。此方法返回一个比较器，该比较器对实现 Comparable 接口的对象集合施加与自然顺序相反的顺序。通过利用此方法，开发人员可以轻松地将最小堆转换为最大堆，反转已排序列表的顺序，或调整优先队列中元素的优先级。

文件名：MaxHeapDemo.java

// Java program to demonstrate working
// of PriorityQueue as a Max Heap
// Using Collections.reverseOrder() method
// Importing necessary classes
import java.util.*;
// Main class
class MaxHeapDemo {
    // Main method
    public static void main(String args[]) {
        // Creating empty priority queue
        PriorityQueue<Integer> maxHeap
                = new PriorityQueue<Integer>(
                        Collections.reverseOrder());
        // Adding items to our priority queue
        // using add() method
        maxHeap.add(10);
        maxHeap.add(30);
        maxHeap.add(20);
        maxHeap.add(400);
        // Printing the most priority element
        System.out.println("Head value using peek function:"
                + maxHeap.peek());
        // Printing all elements
        System.out.println("The queue elements:");
        Iterator<Integer> iterator = maxHeap.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());
        // Removing the top priority element (or head) and
        // printing the modified maxHeap using poll()
        maxHeap.poll();
        System.out.println("After removing an element "
                + "with poll function:");
        Iterator<Integer> iterator2 = maxHeap.iterator();
        while (iterator2.hasNext())
            System.out.println(iterator2.next());
        // Removing 30 using remove() method
        maxHeap.remove(30);
        System.out.println("After removing 30 with"
                + " remove function:");
        Iterator<Integer> iterator3 = maxHeap.iterator();
        while (iterator3.hasNext())
            System.out.println(iterator3.next());
        // Check if an element is present using contains()
        boolean contains20 = maxHeap.contains(20);
        System.out.println("Priority queue contains 20 "
                + "or not?: " + contains20);
        // Getting objects from the queue using toArray()
        // in an array and print the array
        Object[] array = maxHeap.toArray();
        System.out.println("Values in array: ");
        for (int i = 0; i < array.length; i++)
            System.out.println("Value: "
                    + array[i].toString());
    }
}

输出

Head value using peek function:400
The queue elements:
400
30
20
10
After removing an element with poll function:
30
10
20
After removing 30 with remove function:
20
10
Priority queue contains 20 or not?: true
Values in array: 
Value: 20
Value: 10

堆的应用

优先队列：堆通常用于实现优先队列，其中优先级最高的元素首先被提取。这在任务调度、中断处理和事件处理等应用程序中至关重要。

排序算法：堆排序是一种基于比较的排序算法，它依赖于堆数据结构。它的时间复杂度为 O(n log n)，因此对于对大型数据集进行排序非常有效。

图算法：堆在 Dijkstra 的最短路径算法、Prim 的最小生成树算法和 A* 搜索算法等图算法中是不可或缺的。

文件压缩：堆在霍夫曼编码等数据压缩技术中起着至关重要的作用。在这里，一个优先队列（通常实现为最小堆）用于构建霍夫曼树。

动态规划：堆在动态规划算法中使用，特别是在贪心算法中，其中元素根据其优先级进行处理。

医疗应用：在医疗环境中，堆用于管理患者信息，包括生命体征、治疗和检查结果，这些信息根据其危急程度或紧急程度进行管理。

外部排序：堆用于外部排序算法，以有效地对超出内存容量的大型数据集进行排序。数据块使用优先队列进行处理。

负载均衡：堆应用于负载均衡算法，以在服务器之间分配任务或请求。任务通常根据其优先级或负载进行处理。

在线算法：堆在处理实时到达数据的在线算法中使用，例如在推荐系统、事件处理和流数据管理中。

金融应用：堆用于股票市场分析和算法交易等金融应用程序，它们根据优先级管理和处理股票数据。

堆的优点

高效的插入和删除：堆结构支持高效的元素插入和删除。当插入新元素时，它最初放在堆的末尾，然后使用堆化操作移动到其正确的位置。同样，当删除元素时，它被堆中的最后一个元素替换，并使用堆化操作重新组织堆。

高效的优先队列实现：堆通常用于实现优先队列，其中最高优先级的元素始终位于堆的顶部。这允许对最高优先级元素进行常数时间访问，从而使堆成为实现优先队列的高效数据结构。

保证访问极端值：在最大堆中，最大元素始终位于根部，而在最小堆中，最小元素始终位于根部。此属性确保堆提供对最大或最小元素的保证访问，这在需要快速访问极端值的算法中很有用。

空间效率：堆结构是空间高效的，因为它将元素组织在一个完全二叉树中，与链表或动态数组等其他数据结构相比，它通常占用更少的内存。

堆排序算法：堆数据结构是堆排序算法的基础，堆排序是一种有效的方法，其最坏情况时间复杂度为 O(n log n)。这使得堆排序成为对大型数据集进行排序的稳健选择。

堆的缺点

灵活性差：堆结构旨在维护元素的特定顺序，这限制了其灵活性。这使其不太适合需要更灵活数据结构的应用程序。

搜索效率低下：虽然堆提供了对顶部元素的有效访问，但它们并不适合搜索特定元素。在堆中查找元素需要遍历整个树，导致时间复杂度为 O(n)。

不稳定性：堆不是稳定的数据结构，这意味着具有相等值的元素的相对顺序在插入或修改过程中可能不会保留。

内存管理挑战：堆需要动态内存分配，这在内存资源有限的系统中可能会出现问题。此外，管理堆的分配内存可能很复杂，并且容易出错。

复杂性考虑：虽然堆允许高效的插入、删除和优先队列操作，但最坏情况时间复杂度为 O(n log n)。对于需要更快的算法的应用程序来说，这可能不是最佳选择。

下一个主题Java-arraylist-length

Java 中的堆实现

堆的操作

最小堆

insertNode()

extractMin()

getMin()

使用数组

最大堆

insertNode()

extractMax()

getMax()

使用 Collections.reverseOrder() 方法通过库函数

堆的应用

堆的优点

堆的缺点

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的堆实现

堆的操作

最小堆

insertNode()

extractMin()

getMin()

使用数组

最大堆

insertNode()

extractMax()

getMax()

使用 Collections.reverseOrder() 方法通过库函数

堆的应用

堆的优点

堆的缺点

相关帖子

Java 中集合位计数最多为 K 的最大整数

Java 中的 Eratosthenes 筛法算法

在 Java 中创建不可变的自定义类

Java 中二叉树的锯齿形遍历

Java employee details program

Java 中数组中最长可整除子集的大小

Java TDD

Java 中 deprecated 的含义

设计 Java 中的作业调度器

如何压缩 Java 源代码中的图像

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器