二项堆

public class BinaryHeap<E extends Comparable<? super E>> 
{
    
    public static void main(String[] args)
    {
        Integer[] array = {0, 12, 90, 1, 85, 12, 3, 13, 49,
            55, 10, 3, 31, 97, 19, 93, 41, 55, 56, 82, 2};
        
        BinaryHeap<Integer> heap = new BinaryHeap<Integer>();
        
        for (int i = 0; i < array.length; i++) {
            heap.insert(array[i]);
        }
        
        heap.traversal(heap.head);
        System.out.println();
        
        Integer item = (Integer) heap.find(new Integer(55));
        
        if (item == null)
            System.out.println("节点不存在");
        else 
            System.out.println("要找的节点为" + item.toString());
        
        System.out.println(heap.findMinNode().value);
        
        heap.traversal();
        heap.delete(new Integer(31), new Integer(-Integer.MIN_VALUE));
        System.out.println();
        heap.traversal();
    }
    
    
    HeapNode head = null;
    
    /*
     * 查询最小关键字节点
     * 由于二项堆中每个二项树都遵循最小堆性质，
     * 从heap节点依次遍历其兄弟节点，找出最小关键字节点
     */
    private HeapNode findMinNode()
    {
        if (head == null) return null;
        
        HeapNode node = head, min = head;
        
        while (node != null) {
            int compare = min.value.compareTo(node.value); 
            if (compare > 0) min = node;
            node = node.sibling;
        }
        return min;
    }
    
    /*
     * 插入节点
     */
    public void insert(E value)
    {
        if (value == null) return;
        
        HeapNode node = new HeapNode(value);
        BinaryHeap<E> bh = new BinaryHeap<E>();
        bh.head = node;
        union(bh);
    }
    
    /*
     * 合并节点
     */
    public void merge(BinaryHeap<E> heap)
    {
        HeapNode node;
        HeapNode head1 = this.head;
        HeapNode head2 = heap.head;
        
        // 确定head
        if (head1.degree < head2.degree) {
            node = head1;
            head1 = head.sibling;
        }
        else {
            this.head = head2;
            node = head2;
            head2 = head2.sibling;
        }
        
        // 归并合并二项堆
        while (head1 != null && head2 != null) {
            if (head1.degree < head2.degree) {
                node.sibling = head1;
                node = head1;
                head1 = head1.sibling;
            }
            else {
                node.sibling = head2;
                node = head2;
                head2 = head2.sibling;
            }
        }
        
        node.sibling = (head1 == null) ? head2 : head1;
    }
    
    /*
     * 查找节点
     */
    private HeapNode find(E value, HeapNode node)
    {
        if (node == null) return null;
        if (value.compareTo(node.value) == 0) return node;
        
        HeapNode node1 = find(value, node.sibling);
        HeapNode node2 = find(value, node.child);
        
        if (node1 != null) return node1;
        if (node2 != null) return node2;
        return null;
    }
    
    /*
     * 查询节点
     */
    public E find(E value)
    {
        HeapNode node = find(value, head);
        if (node == null) return null;
        return node.value;
    }
    
    /*
     * 合并二项堆
     * 将this和heap合并成一个新二项堆
     */
    private void union(BinaryHeap<E> heap)
    {
        if (heap.head == null) return;
        if (this.head == null) { 
            this.head = heap.head;
            return;
        }
        
        merge(heap);
        
        HeapNode prev = null;
        HeapNode node = this.head;
        HeapNode next = node.sibling;
        /*
         * 情况1 degree[x] != degree[next], x为B-k书的根,next为B-l书的根且l > k
         * 动作  将指针移向表中下一个位置
         * 
         * 情况2 degree[x] = degree[next] = degree[sibling[next]]
         * 动作  将指针移向表中下一个位置，下一次迭代将执行情况3或4，将第二和第三个根联合起来
         * 
         * 情况3 x为具有相同度数的两个根中的第一个发生时
         *      degree[x] = degree[next] != degree[sibling[next]]
         * 动作  value[x] <= value[next] 将next连接到x上作为x的左孩子
         * 
         * 情况4 x为具有相同度数的两个根中的第一个发生时
         *      degree[x] = degree[next] != degree[sibling[next]]
         * 动作  value[x] > value[next] 将x连接到next上作为next的左孩子
         */
        while (next != null) {
            if ((node.degree != next.degree) || 
                    (next.sibling != null && next.sibling.degree == node.degree)) {
                prev = node;
                node = next;
            }
            else if (node.value.compareTo(next.value) <= 0) {
                node.sibling = next.sibling;
                link(next, node);
            }
            else {
                if (prev == null) {
                    this.head = next;
                }
                else {
                    prev.sibling = next;
                }
                link(node, next);
                node = next;
            }
            next = node.sibling;
        }
    }
    
    public void delete(E value, E min)
    {
        HeapNode node = find(value, head);
        if (node == null) return;
        decreaseKey(value, min);
        extractMin();
    }
    
    /*
     * 减小某解点的值
     */
    private void decreaseKey(E source, E target)
    {
        HeapNode node = find(source, head);
        if (node == null) return;
        node.value = target;
        HeapNode parent = node.parent;
        
        while (parent != null && 
            node.value.compareTo(parent.value) < 0) 
        {
            // 交换当前结点与父节点的值
            E temp = node.value;
            node.value = parent.value;
            parent.value = temp;
            
            node = parent;
            parent = parent.parent;
        }
    }
    
    /*
     * 抽取关键字最小的节点
     */
    private void extractMin()
    {
        HeapNode min = findMinNode();
        HeapNode minPrev = head;
        
        // 独立最小值所在二项数
        if (min != head) {
            while (minPrev.sibling != min) {
                minPrev = minPrev.sibling;
            }
            minPrev.sibling = min.sibling;
        }
        else {
            head = head.sibling;
        }
        min.sibling = null;
        
        BinaryHeap<E> bh = new BinaryHeap();
        
        // 将min与子节点分离
        HeapNode child = min.child;
        child.parent = min.child = null;
        
        // 
        HeapNode prev, node, next;
        prev = child;
        node = child.sibling;
        prev.sibling = null;
        
        while (node != null) {
            next = node.sibling;
            node.parent = null;
            node.sibling = prev;
            prev = node;
            node = next;
        }
        
        bh.head = prev;
        
        // 将分离出来的二项堆与原来的合并
        union(bh);
    }
    
    /*
     * 连接两个节点
     */
    private void link(HeapNode big, HeapNode small)
    {
        big.parent = small;
        big.sibling = small.child;
        small.child = big;
        small.degree++;
    }
    
    public void traversal(HeapNode node)
    {
        if (node == null) return;
        System.out.print(node.value + ",");
        traversal(node.sibling);
        traversal(node.child);
    }
    
    /*
     * 遍历二项堆
     */
    public void traversal()
    {
        traversal(head);
    }
    
    
    class HeapNode
    {
        private HeapNode parent;
        
        private HeapNode sibling;
        
        private HeapNode child;
        
        private E value;
        
        private int degree = 0;

        
        public HeapNode(E value)
        {
            this.value = value;
        }
    }
}