使用Java实现最大堆

最大堆和最小堆是二叉堆的两种形式。

最大堆：根结点的键值是所有堆结点键值中最大者，且每个结点的值都比其孩子的值大。

最小堆：根结点的键值是所有堆结点键值中最小者，且每个结点的值都比其孩子的值小。

堆实际上是一种完全二叉树。最大（小）堆建堆的复杂度是o（n），也就是说可以在线性时间内把一个无序的序列转化为堆。插入的时间复杂度为o(log2(n))(2为底n的对数的时间复杂度)，删除的时间复杂度也是这么多，因为对于插入删除，在最坏的情况下，插入将整个树从最低的一端比较到树的最高一端，而删除是从树的最高的一端比较到树最低的一端。

PS、这里有个疑问，就是从算法上大致看过去，会认为建堆的复杂度是o（nlog2(n)），实际计算出来结果是o（n），证明过程如下：

建堆的计算时间为2^i（log2(n)-1）从i=0加到i=log2（n），因为第i层的结点最多2^i个，每个元素在建堆调整位置的时候最坏情况是从最底层调整到最高层，因此第i层最坏情况下的总共调整次数应该是2^i（log2(n)-1），这个结果经过整理计算出来实际上复杂度是o(n)。

在之前我们用Java实现了二叉树的顺序存储和链式存储，这次用Java实现的最大堆是基于前面写的链式存储的二叉树实现的。

在实现最大堆的时候，需要在之前的TreeNode<E>类的基础上加上一个变量num表示当前结点在堆中的编号，而且要求泛型要是整形，所以我定义了一个HeapNode继承了TreeNode<Integer>（优先考虑复用，但是这里明显出现了HeapNode is TreeNode<Integer>的情形，因此采用继承）：

package com.maxHeap;import com.linkedTree.TreeNode;public class HeapNode extends TreeNode<Integer> {//HeapNode is TreeNode<Integer>    private HeapNode leftChild;    private HeapNode rightChild;    private int num;//编号    public HeapNode(Integer e) {        super(e);    }    public int getNum() {        return num;    }    public void setNum(int num) {        this.num = num;    }    @Override    public TreeNode<Integer> getRightChild() {        return rightChild;    }    @Override    public void setRightChild(TreeNode<Integer> rightChild) {        this.rightChild = (HeapNode) rightChild;    }    @Override    public TreeNode<Integer> getLeftChild() {        return this.leftChild;    }    @Override    public void setLeftChild(TreeNode<Integer> leftChild) {        this.leftChild = (HeapNode) leftChild;    }    }

紧接着，同理写了一个MaxHeap类继承LinkedTree<Integer>：

package com.maxHeap;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;import com.linkedTree.LinkedTree;import com.linkedTree.TreeNode;public class MaxHeap extends LinkedTree<Integer> {//MaxHeap is LinkedTree<Integer> MaxHeap要求是完全二叉树//    private int size;//不用定义size，因为nodeMap.size()就是树的大小    private Map<Integer,HeapNode> nodeMap = new HashMap<Integer,HeapNode>();//编号与结点的映射    private void setRoot(HeapNode root){        this.root = root;    }    @Override    //重写getParent方法 因为节点有编号之后 有更快的方法获得父节点    public TreeNode<Integer> getParent(TreeNode<Integer> node) {//获取node结点的父节点        HeapNode heapNode = (HeapNode)node;         int nodeNum = heapNode.getNum();        return (nodeNum%2==0)?nodeMap.get((nodeNum>>1)-1):nodeMap.get((nodeNum-1)>>1);//获取nodeMap中对应结点 采用位运算增加效率    }    private void swapNode(HeapNode node1 , HeapNode node2){//交换node1和node2以及它的映射        int item1 = node1.getItem();        node1.setItem(node2.getItem());        node2.setItem(item1);        nodeMap.put(node1.getNum(), node1);        nodeMap.put(node2.getNum(), node2);    }    public void add(int data){//添加一个元素        HeapNode heapNode = new HeapNode(data);        shiftUpNode(nodeMap.size(),heapNode);//从最新的位置移到应该放的位置    }    public void add(Set<Integer> dataSet){//添加一个集合 迭代添加集合中的每个元素        Iterator<Integer> i = dataSet.iterator();        while(i.hasNext()){            add(i.next());        }    }    public MaxHeap(Set<Integer> set){//通过一个set创建一个MaxHeap        Iterator<Integer> i = set.iterator();        int num = 0;        while(i.hasNext()){            Integer e = i.next();            HeapNode node = new HeapNode(e);            shiftUpNode(num, node);//从最新的一个位置的结点移到他应该在的位置            num++;        }    }    private void shiftUpNode(int num, HeapNode node) {//从最靠后的结点移到准确的位置        if(this.root==null){            this.setRoot(node);//没有根则设置根            node.setNum(num);//设置编号        }        else{            boolean right = (num%2 == 0);//是否是父节点的右子树            if(right){                nodeMap.get((num>>1)-1).setRightChild(node);            }            else{                nodeMap.get((num-1)>>1).setLeftChild(node);            }            node.setNum(num);            HeapNode heapNode = node;//中间量            while(this.getParent(heapNode).getItem()<heapNode.getItem()){//构建最大堆                swapNode((HeapNode) this.getParent(heapNode),heapNode);//交换节点                heapNode = (HeapNode) this.getParent(heapNode);//交换完之后 保存父节点的位置 继续与其父节点进行比较                if(this.getParent(heapNode)==null)                    break;            }        }        nodeMap.put(num, node);//保存映射    }    private void shiftDownNode(){//把根节点下移到准确的位置        HeapNode pointer = (HeapNode) root;        while(true){            HeapNode leftChild = (HeapNode) pointer.getLeftChild();            HeapNode rightChild = (HeapNode) pointer.getRightChild();            boolean left = leftChild != null;            boolean right = rightChild != null;            if(left&&(pointer.getItem()<leftChild.getItem())||(right&&pointer.getItem()<rightChild.getItem())){//有左结点或者右结点并且可交换                if(left&&right){//左右节点都有                    if(leftChild.getItem()<rightChild.getItem()){//谁大谁上                        swapNode(pointer,(HeapNode) pointer.getRightChild());                        pointer = (HeapNode) pointer.getRightChild();//继续跟踪被下放的根节点                    }                    else{                        swapNode(pointer,(HeapNode) pointer.getLeftChild());                        pointer = (HeapNode) pointer.getLeftChild();                    }                }                else if(!left){//没有左结点                    swapNode(pointer,(HeapNode) pointer.getRightChild());                    pointer = (HeapNode) pointer.getRightChild();                }                else{//没有右结点                    swapNode(pointer,(HeapNode) pointer.getLeftChild());                    pointer = (HeapNode) pointer.getLeftChild();                }            }            else                return;        }    }    public int peek(){//获取最大的结点 不删除        return this.root.getItem();    }        public int pop(){//获取最大的结点 并且删除        int size = nodeMap.size();//映射个数        swapNode((HeapNode) this.root, nodeMap.get(size-1));//交换根结点和最后一个结点        int maxNum = nodeMap.get(size-1).getItem();//最大值        if((size-1)%2==0)//最后一个结点是父节点的右结点            getParent(nodeMap.get(size-1)).setRightChild(null);//将父节点的右结点置空 help gc 下同        else            getParent(nodeMap.get(size-1)).setLeftChild(null);        nodeMap.remove(size-1);//删除最大的        shiftDownNode();//将根结点调到适当的位置        return maxNum;    }}

最后写一个测试类Test来进行测试：

class Test{    public static void main(String[] args){        System.out.println("MaxHeap Test:");        MaxHeap maxHeap = new MaxHeap(set);        maxHeap.breadFirstOrder();        maxHeap.preOrder();        System.out.println(maxHeap.getRoot().getItem());        maxHeap.add(9);        maxHeap.breadFirstOrder();        Set<Integer> set2 = new HashSet<Integer>();        set2.add(9);        set2.add(11);        set2.add(10);        set2.add(19);        maxHeap.add(set2);        maxHeap.breadFirstOrder();        maxHeap.pop();               maxHeap.breadFirstOrder();    }}

我的实现思路在注释里。欢迎拍砖。