说明: 对java数据结构中的堆的有关代码整理了一下,以备使用~~~
1. 堆结点:
2. 堆容器:
3. 堆应用测试
4. 堆排序测试:
1. 堆结点:
package boke.heap;
/**
* 堆结点
*
* @since jdk1.5及其以上
* @author 毛正吉
* @version 1.0
* @date 2010.05.24
*
*/
public class Node {
private int iData; // 结点数据是整型
public Node(int key) {
iData = key;
}
/**
* setKey
*
* @param id
*/
public void setKey(int id) {
iData = id;
}
/**
* getKey
*
* @return
*/
public int getKey() {
return iData;
}
}
2. 堆容器:
package boke.heap;
/**
* 堆
*
* @since jdk1.5及其以上
* @author 毛正吉
* @version 1.0
* @date 2010.05.24
*
*/
public class Heap {
private Node[] heapArray; // 堆容器
private int maxSize; // 堆得最大大小
private int currentSize; // 堆得大小
/**
* 构造
*
* @param _maxSize
*/
public Heap(int _maxSize) {
maxSize = _maxSize;
currentSize = 0;
heapArray = new Node[maxSize];
}
/**
* 堆是否为空
*
* @return
*/
public boolean isEmpty() {
return currentSize == 0;
}
/**
* 在堆中插入新元素
*
* @param key
* @return
*/
public boolean insert(int key) {
if (currentSize == maxSize) {
return false;
}
Node newNode = new Node(key);
heapArray[currentSize] = newNode;
trickleUp(currentSize++);
return true;
}
/**
* 堆调整自下而上的调整
*
* @param index
*/
public void trickleUp(int index) {
int parent = (index - 1) / 2;
Node bottom = heapArray[index];
while (index > 0 && heapArray[parent].getKey() < bottom.getKey()) {
heapArray[index] = heapArray[parent]; // 双亲结点值大, 调整
index = parent;
parent = (parent - 1) / 2;
}
heapArray[index] = bottom; // 回送
}
/**
* 删除堆中最大的值
*
* @return
*/
public Node remove() {
Node root = heapArray[0];
heapArray[0] = heapArray[--currentSize];
trickleDown(0);
return root;
}
/**
* 自上而下的调整
*
* @param index
*/
public void trickleDown(int index) {
int largeChild;
Node top = heapArray[index]; // save root
while (index < currentSize / 2) { // while node has at least one child
int leftChild = 2 * index + 1;
int rightChild = leftChild + 1;
if (rightChild < currentSize
&& heapArray[leftChild].getKey() < heapArray[rightChild]
.getKey()) {
largeChild = rightChild;
} else {
largeChild = leftChild;
}
if (top.getKey() >= heapArray[largeChild].getKey()) {
break;
}
heapArray[index] = heapArray[largeChild]; // shift child up
index = largeChild; // go down
}
heapArray[index] = top; // root to index
}
/**
* 改变堆中索引为index处的值
*
* @param index
* @param newValue
* @return
*/
public boolean change(int index, int newValue) {
if (index < 0 || index >= currentSize) {
return false;
}
int oldValue = heapArray[index].getKey(); // remove old
heapArray[index].setKey(newValue); // change to new
if (oldValue < newValue) { // if raised
this.trickleUp(index); // trickle it up
} else { // if lowered
this.trickleDown(index); // trickle it down
}
return true;
}
/**
* 按某种格式输出堆
*/
public void displayHeap() {
System.out.print("heapArray: ");
for (int i = 0; i < currentSize; i++) {
if (heapArray[i] != null) {
System.out.print(heapArray[i].getKey() + " ");
} else {
System.out.print("-- ");
}
}
System.out.println();
int nBlanks = 32; // heap format
int itemsPerRow = 1;
int column = 0;
int j = 0; // current item
String dots = "...............................";
System.out.println(dots + dots); // dotted top line
while (currentSize > 0) { // for each heap item
if (column == 0) { // first item in row
for (int k = 0; k < nBlanks; k++) { // preceding blanks
System.out.print(" ");
}
}
System.out.print(heapArray[j].getKey()); // display item
if (++j == currentSize) { // done?
break;
}
if (++column == itemsPerRow) { // end of row?
nBlanks /= 2; // half the blanks
itemsPerRow *= 2; // twice the items
column = 0; // start over on
System.out.println(); // next row
} else { // next item on row
for (int k = 0; k < nBlanks * 2 - 2; k++) {
System.out.print(' '); // interim blanks
}
}
}
System.out.println("\n" + dots + dots);
}
/**
* 输出堆数组
*/
public void displayArray() {
for (int j = 0; j < maxSize; j++) {
System.out.print(heapArray[j].getKey() + " ");
}
System.out.println("");
}
/**
* 在堆中的索引index出设置新结点
*
* @param index
* @param newNode
*/
public void insertAt(int index, Node newNode) {
heapArray[index] = newNode;
}
/**
* 堆的大小增量
*/
public void incrementSize() {
currentSize++;
}
}
3. 堆应用测试
package boke.heap;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 堆应用测试
*
* @since jdk1.5及其以上
* @author 毛正吉
* @version 1.0
* @date 2010.05.24
*
*/
public class HeapApp {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
int value, value2;
Heap hp = new Heap(31);
boolean success;
hp.insert(70);
hp.insert(40);
hp.insert(50);
hp.insert(20);
hp.insert(60);
hp.insert(100);
hp.insert(80);
hp.insert(30);
hp.insert(10);
hp.insert(90);
while (true) {
System.out.print("Enter first letter of ");
System.out.print("show, insert, remove, change: ");
int choice = getChar();
switch (choice) {
case 's':
hp.displayHeap();
break;
case 'i':
System.out.print("Enter value to insert: ");
value = getInt();
success = hp.insert(value);
if (!success) {
System.out.println("Can't insert; heap is full");
}
break;
case 'r':
if (!hp.isEmpty()) {
hp.remove();
} else {
System.out.println("Can't remove; heap is empty");
}
break;
case 'c':
System.out.print("Enter current index of item: ");
value = getInt();
System.out.print("Enter new key: ");
value2 = getInt();
success = hp.change(value, value2);
if (!success) {
System.out.println("Invalid index");
}
break;
default:
System.out.println("Invalid entry\n");
}
}
}
/**
* 获得控制台输入流
*
* @return
* @throws IOException
*/
public static String getString() throws IOException {
return new BufferedReader(new InputStreamReader(System.in)).readLine();
}
/**
* 获得控制台输入字符
*
* @return
* @throws IOException
*/
public static char getChar() throws IOException {
return getString().charAt(0);
}
/**
* 获得控制台输入整型
*
* @return
* @throws NumberFormatException
* @throws IOException
*/
public static int getInt() throws NumberFormatException, IOException {
return Integer.parseInt(getString());
}
}
4. 堆排序测试:
package boke.heap;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 堆排序测试
*
* @since jdk1.5及其以上
* @author 毛正吉
* @version 1.0
* @date 2010.05.24
*
*/
public class HeapSortApp {
/**
* @param args
* @throws IOException
* @throws NumberFormatException
*/
public static void main(String[] args) throws NumberFormatException,
IOException {
int size, j;
System.out.print("Enter number of items: "); // 输入堆大小
size = getInt();
Heap hp = new Heap(size);
for (j = 0; j < size; j++) { // 随机建立堆
int random = (int) (Math.random() * 100);
Node newNode = new Node(random);
hp.insertAt(j, newNode);
hp.incrementSize();
}
System.out.print("Random: ");
hp.displayArray(); // 输出堆数组
for (j = size / 2 - 1; j >= 0; j--) {
hp.trickleDown(j);
}
System.out.print("Heap: "); // 输出堆
hp.displayArray();
hp.displayHeap();
for (j = size - 1; j >= 0; j--) {
Node largestNode = hp.remove();
hp.insertAt(j, largestNode);
}
System.out.print("Sorted: "); // 输出排序后的数组(升序)
hp.displayArray();
}
/**
* 获得控制台输入流
*
* @return
* @throws IOException
*/
public static String getString() throws IOException {
return new BufferedReader(new InputStreamReader(System.in)).readLine();
}
/**
* 获得控制台输入整型
*
* @return
* @throws NumberFormatException
* @throws IOException
*/
public static int getInt() throws NumberFormatException, IOException {
return Integer.parseInt(getString());
}
}