优先队列之左式堆(JAVA实现)

一、定义：

1.零路径长度：某节点的零路径长度为该节点到没有两个儿子的节点最短距离。

2.左式堆性质：

• 父节点属性值小于子节点属性值；
• 堆中的任何节点，其左儿子的零路径长>=右儿子的零路径长的二叉树。
• 任一结点的零路径长比他的诸儿子结点的零路径长的最小值多1。

二、实现思路：

1.合并：
左式堆的合并操作基于递归实现，算法思路如下:

1. 若有一棵树是空树，则返回另一棵树；否则将根节点较大的堆与根节点较小的堆的右子树合并。
2. 使形成的新堆作为较小堆的右子树。
3. 如果违反了左式堆的特性，交换两个子树的位置。
4. 更新npl(零路径长度)。

2.插入
将需要插入的节点当做一棵左式堆树，进行合并。

3.删除最小值
删除根节点，将形成的两个堆合并

三、代码实现

public class LeftistHeap<T extends Comparable> {    /**     * Created by Administrator on 2017/6/13.     */    class Node<T> {        T element;        Node<T> left;//左儿子        Node<T> right;//右儿子        int npl;//零路径长        Node(T element) {            this(element, null, null);        }        Node(T element, Node<T> left, Node<T> right) {            this.element = element;            this.left = left;            this.right = right;            npl = 0;        }    }    private Node<T> root;    /**     * 构造方法     */    public LeftistHeap() {        root = null;    }    /**     * 合并堆     *     * @param rhs 另一个左式堆     */    public void merge(LeftistHeap<T> rhs) {        if (this == rhs) {            return;        }        root = merge(root, rhs.root);        rhs.root = null;    }    public void insert(T x) {        root = merge(root, new Node(x));    }    /**     * 找出最小元素     *     * @return     */    public T findmin() {        if(isEmpty()){            System.out.println("该左式堆为空");        }        return root.element;    }    /**     * 删除最小元素     *     * @return     */    public T deleteMin() {        if (isEmpty()) {            System.out.println("该左式堆为空");        }        T minElement = root.element;        root=merge(root.left, root.right);        return minElement;    }    /**     * 是否为空     *     * @return     */    public boolean isEmpty() {        return root == null;    }    /**     * 置空     */    public void makeEmpty() {        this.root = null;    }    /**     * 合并两个左式堆(判断过程，真正合并过程由merge1操作)     *     * @param h1     * @param h2     * @return     */    private Node<T> merge(Node<T> h1, Node<T> h2) {        if (h1 == null)            return h2;        if (h2 == null)            return h1;        if (h1.element.compareTo(h2.element) > 0)            return merge1(h2, h1);        else            return merge1(h1, h2);    }    /**     * 合并两个左式堆的真正操作  h1的元素小于h2(即h2与h1的右子堆合并)     *     * @param h1     * @param h2     * @return     */    private Node<T> merge1(Node<T> h1, Node<T> h2) {        if (h1.left == null) {//h1为单节点            h1.left = h2;        } else {//h1不是单节点            h1.right = merge(h1.right, h2);            if (h1.right.npl > h1.left.npl) {//比较零路径长，确保左式堆性质不被破坏                swapChildren(h1);            }            h1.npl = h1.right.npl + 1;//零路径长为右儿子的零路径长+1        }        return h1;    }    /**     * 交换左右儿子     *     * @param t     * @return     */    private void swapChildren(Node<T> t) {        Node<T> temp = t.right;        t.right = t.left;        t.left = temp;    }    private void print(Node t){        if(t==null)            return;        print(t.left);        System.out.println(t.element+":"+t.npl);        print(t.right);    }    public static void main(String[] args) {        int numItems = 100;        LeftistHeap<Integer> h  = new LeftistHeap<>( );        LeftistHeap<Integer> h1 = new LeftistHeap<>( );        int i = 37;        for( i = 37; i != 0; i = ( i + 37 ) % numItems )            if( i % 2 == 0 )                h1.insert( i );            else                h.insert( i );        h.merge( h1 );        for( i = 1; i < numItems; i++ )            if( h.deleteMin( ) != i )                System.out.println( "Oops! " + i );    }}