java數據結構----堆

1.堆：堆是一種樹，由它實現的優先級隊列的插入和刪除的時間復雜度都是O(logn)，用堆實現的優先級隊列雖然和數組實現相比較刪除慢了些，但插入的時間快的多了。當速度很重要且有很多插入操作時，可以選擇堆來實現優先級隊列。
2.java的堆和數據結構堆：java的堆是程序員用new能得到的計算機內存的可用部分。而數據結構的堆是一種特殊的二叉樹。
3.堆是具有如下特點的二叉樹：
　　3.1.它是完全二叉樹，也就是說除了樹的最后一層節點不需要是滿的，其他的每一層從左到右都必須是滿的。

　　　　3.1.1.完全二叉樹圖解：

 

　　3.2.它常常用數組實現。

　　　　3.2.1.數組和堆的對應關系示意圖：

　　3.3.堆中每一個節點都滿足堆的條件，也就是說每一個關鍵字的值都大於或等於這個節點的子節點的關鍵字值。
　　堆是完全二叉樹的事實說明了表示堆的數組中沒有空項，即從0-->n-1的每個數據單元都有數據項。
4.堆在存儲器中的表示是數組，堆只是一個概念上的表示。

5.堆的弱序：堆和二叉搜索樹相比是弱序的，在二叉搜索樹中，當前節點的值總是比左子節點的值大，卻比它的右子節點的值小，因此按序遍歷相對容易。而堆的組織規則弱，它只要求從根到葉子節點的每一條路徑，節點都是按降序排列的。同一節點的左右子節點都沒有規律。因此，堆不支持按序遍歷，也不能在堆上便利的查找指定關鍵字，因為在查找的過程中，沒有足夠的信息決定選擇通過節點的兩個那一個走向下一層。它也不能在少於O(logn)的時間內刪除一個指定的節點，因為沒有辦法找到這個節點。因此，堆的這種近乎無序的規則似乎毫無用處，不過對於快速移除最大節點的操作，以及快速插入新節點的操作，這種順序已經足夠了。這些操作是使用堆作為優先級隊列所需要的全部操作。

6.移除操作：移除是指刪掉關鍵字值最大的節點，即根節點。移除思路如下：

　　6.1.移走根，

　　6.2.把左后一個節點移到根的位置，

　　6.3.一直向下篩選這個節點，知道它在一個大於它的節點之下，小於它的節點之上為止。

　　6.4.過程圖解：

　　說明：在被篩選節點的每個暫時停留的位置，向下篩選的算法總是要檢查那一個子節點更大，然后目標節點和較大的子節點交換位置，如果要把目標節點和較小的子節點交換，那么這個子節點就會變成大子節點的父節點，這就違背了堆的條件。

7.堆的插入：插入使用向上篩選，節點最后插入到數組最后第一個空着的單元中，數組容量大小增加1。

　　7.1.插入圖解：

　　說明：向上篩選的算法比向下篩選的算法相對簡單，因為它不需要比較兩個子節點關鍵字值的大小，節點只有一個父節點。目標節點主要和它的父親節點換位即可。

　　7.2.不是真的交換：

8.用數組表示一棵樹時，如果數組中節點的索引位x，則

　　a.它的父節點的下標是：(x-1)/2；

　　b.它的左子節點的下標為2*x + 1；

　　c.它的右子節點的下標是2*x + 2；

9.堆的代碼：

　　9.1.Node.java

package com.cn.heap;
/**
 * 堆的節點類
 * @author Administrator
 *
 */
public class Node {
private int iData;
public Node(int id){
    iData  = id;
}
public int getkey(){
    return iData;
}
public void setkey(int id){
    iData = id;
}
}

　　9.2.Heap.java

package com.cn.heap;
/**
 * 堆的實現類
 * @author Administrator
 *
 */
public class Heap {
private Node[] heapArray;
private int maxSize;
private int currentSize;
public Heap(int mx){
    maxSize = mx;
    heapArray = new Node[maxSize];
    currentSize = 0;
}
public boolean isEmpty(){
    return currentSize == 0 ;
}
public boolean insert(int key){
    if (currentSize == maxSize)
        return false;
    Node thenode = new Node(key);
    heapArray[currentSize] = thenode;
    trickleUp(currentSize ++);
    return true;
}
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;
}
public Node remove(){
    Node root = heapArray[0];
    heapArray[0] = heapArray[-- currentSize];
    trickleDown(0);
    return root;
}
public void trickleDown(int index){
    int largeChild;
    Node top = heapArray[index];
    while (index < currentSize / 2){
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        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];
        index = largeChild;
    }
    heapArray[index] = top;
}
public boolean change(int index,int newvalue){
    if (index < 0 || index >=currentSize)
        return false;
    int oldvalue = heapArray[index].getkey();
    heapArray[index].setkey(newvalue);
    if (oldvalue < newvalue)
        trickleUp(index);
    else
        trickleDown(index);
    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;
    int itemsPerrow = 1;
    int column = 0;
    int j = 0;
    String dots = "........................";
    System.out.println(dots + dots);
    while (currentSize > 0){
        if (column == 0)
            for (int i = 0; i < nBlanks; i++) {
                System.out.print(" ");
            }
        System.out.print(heapArray[j].getkey());
        if (++ j == currentSize)
            break;
        if (++ column == itemsPerrow){
            nBlanks /= 2;
            itemsPerrow *= 2;
            column = 0;
            System.out.println();
        }
        else
            for (int i = 0; i < nBlanks * 2 - 2; i++) 
                System.out.print(' ');
    }
    System.out.println("\n"+dots + dots);
}
}

　　9.3.HTest.java

package com.cn.heap;
/**
 * heap類的測試
 * @author Administrator
 *
 */
public class HTest {
public static void main(String[] args) {
    Heap h = new Heap(10);
    h.insert(10);
    h.insert(30);
    h.insert(20);
    h.insert(18);
    h.insert(12);
    h.displayHeap();
    h.remove();
    h.displayHeap();
}
}

10.堆的效率：上述操作的時間復雜度是：O(logn)。

11.堆排序實現思路：使用insert()向堆中插入所有無序的數據項，然后重復使用remove()方法，就可以按序移除所有數據項，它的效率和快速排序類似，都是O(NlogN)，但快排稍微快些，因為堆插入時的向下篩選多出的比較所占用的時間。

　　11.1.Node.java

package com.cn.heap;
/**
 * 堆的節點類
 * @author Administrator
 *
 */
public class Node {
private int iData;
public Node(int id){
    iData  = id;
}
public int getkey(){
    return iData;
}
public void setkey(int id){
    iData = id;
}
}

　　11.2.Heap.java

package com.cn.heap;
/**
 * 堆的實現類
 * @author Administrator
 *
 */
public class Heap {
private Node[] heapArray;
private int maxSize;
private int currentSize;
public Heap(int mx){
    maxSize = mx;
    heapArray = new Node[maxSize];
    currentSize = 0;
}
public boolean isEmpty(){
    return currentSize == 0 ;
}
public boolean insert(int key){
    if (currentSize == maxSize)
        return false;
    Node thenode = new Node(key);
    heapArray[currentSize] = thenode;
    trickleUp(currentSize ++);
    return true;
}
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;
}
public Node remove(){
    Node root = heapArray[0];
    heapArray[0] = heapArray[-- currentSize];
    trickleDown(0);
    return root;
}
public void trickleDown(int index){
    int largeChild;
    Node top = heapArray[index];
    while (index < currentSize / 2){
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        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];
        index = largeChild;
    }
    heapArray[index] = top;
}
public boolean change(int index,int newvalue){
    if (index < 0 || index >=currentSize)
        return false;
    int oldvalue = heapArray[index].getkey();
    heapArray[index].setkey(newvalue);
    if (oldvalue < newvalue)
        trickleUp(index);
    else
        trickleDown(index);
    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;
    int itemsPerrow = 1;
    int column = 0;
    int j = 0;
    String dots = "........................";
    System.out.println(dots + dots);
    while (currentSize > 0){
        if (column == 0)
            for (int i = 0; i < nBlanks; i++) {
                System.out.print(" ");
            }
        System.out.print(heapArray[j].getkey());
        if (++ j == currentSize)
            break;
        if (++ column == itemsPerrow){
            nBlanks /= 2;
            itemsPerrow *= 2;
            column = 0;
            System.out.println();
        }
        else
            for (int i = 0; i < nBlanks * 2 - 2; i++) 
                System.out.print(' ');
    }
    System.out.println("\n"+dots + dots);
}
public void displayArray(){
    for (int i = 0; i < maxSize; i++) 
        System.out.print(heapArray[i].getkey()+" ");
    System.out.println();
}
public void insertAt(int index,Node newnode){
    heapArray[index] = newnode;
}
public void incrementSize(){
    currentSize ++;
}
}

　　11.3.HeapSort.java

package com.cn.heap;

import java.util.Scanner;

/**
 * 基於堆的排序----堆排序
 * @author Administrator
 *
 */
public class HeapSort {
public static void main(String[] args) {
    int size,j;
    Scanner in = new Scanner(System.in);
    System.out.print("Enter number of items: ");
    size = in.nextInt();
    Heap theheap = new Heap(size);
    for (int i = 0; i < size; i++) {
        int random = (int)(Math.random()*100);
        Node node = new Node(random);
        theheap.insertAt(i, node);
        theheap.incrementSize();
    }
    System.out.print("random: ");
    theheap.displayArray();
    for (int i = size / 2 - 1; i >= 0; i --) {
        theheap.trickleDown(i);
    }
    System.out.print("heap: ");
    theheap.displayArray();
    theheap.displayHeap();
    for (int i = size - 1; i >= 0; i --) {
        Node node = theheap.remove();
        theheap.insertAt(i,node);
    }
    System.out.print("sorted: ");
    theheap.displayArray();
}
}