左倾堆 之 Java的实现

最新推荐文章于 2018-10-08 21:37:00 发布
最新推荐文章于 2018-10-08 21:37:00 发布
阅读量767 收藏
点赞数
分类专栏： 数据结构温习

左倾堆的介绍

左倾堆(leftist tree 或 leftist heap)，又被成为左偏树、左偏堆，最左堆等。
它和二叉堆一样，都是优先队列实现方式。当优先队列中涉及到”对两个优先队列进行合并”的问题时，二叉堆的效率就无法令人满意了，而本文介绍的左倾堆，则可以很好地解决这类问题。

左倾堆的定义

上图是一颗左倾树，它的节点除了和二叉树的节点一样具有左右子树指针外，还有两个属性：键值和零距离。
(01) 键值的作用是来比较节点的大小，从而对节点进行排序。
(02) 零距离(英文名NPL，即Null Path Length)则是从一个节点到一个”最近的不满节点”的路径长度。不满节点是指该该节点的左右孩子至少有有一个为NULL。叶节点的NPL为0，NULL节点的NPL为-1。

左倾堆有以下几个基本性质：
[性质1] 节点的键值小于或等于它的左右子节点的键值。
[性质2] 节点的左孩子的NPL >= 右孩子的NPL。
[性质3] 节点的NPL = 它的右孩子的NPL + 1。

左倾堆的图文解析

合并操作是左倾堆的重点。合并两个左倾堆的基本思想如下：
(01) 如果一个空左倾堆与一个非空左倾堆合并，返回非空左倾堆。
(02) 如果两个左倾堆都非空，那么比较两个根节点，取较小堆的根节点为新的根节点。将”较小堆的根节点的右孩子”和”较大堆”进行合并。
(03) 如果新堆的右孩子的NPL > 左孩子的NPL，则交换左右孩子。
(04) 设置新堆的根节点的NPL = 右子堆NPL + 1

下面通过图文演示合并以下两个堆的过程。

提示：这两个堆的合并过程和测试程序相对应！

第1步：将”较小堆(根为10)的右孩子”和”较大堆(根为11)”进行合并。
合并的结果，相当于将”较大堆”设置”较小堆”的右孩子，如下图所示：

第2步：将上一步得到的”根11的右子树”和”根为12的树”进行合并，得到的结果如下：

第3步：将上一步得到的”根12的右子树”和”根为13的树”进行合并，得到的结果如下：

第4步：将上一步得到的”根13的右子树”和”根为16的树”进行合并，得到的结果如下：

第5步：将上一步得到的”根16的右子树”和”根为23的树”进行合并，得到的结果如下：

至此，已经成功的将两棵树合并成为一棵树了。接下来，对新生成的树进行调节。

第6步：上一步得到的”树16的右孩子的NPL > 左孩子的NPL”，因此交换左右孩子。得到的结果如下：

第7步：上一步得到的”树12的右孩子的NPL > 左孩子的NPL”，因此交换左右孩子。得到的结果如下：

第8步：上一步得到的”树10的右孩子的NPL > 左孩子的NPL”，因此交换左右孩子。得到的结果如下：

至此，合并完毕。上面就是合并得到的左倾堆！

下面看看左倾堆的基本操作的代码

1. 基本定义

public class LeftistHeap<T extends Comparable<T>> {

    private LeftistNode<T> mRoot;    // 根结点

    private class LeftistNode<T extends Comparable<T>> {
        T key;                    // 关键字(键值)
        int npl;                // 零路经长度(Null Path Length)
        LeftistNode<T> left;    // 左孩子
        LeftistNode<T> right;    // 右孩子

        public LeftistNode(T key, LeftistNode<T> left, LeftistNode<T> right) {
            this.key = key;
            this.npl = 0;
            this.left = left;
            this.right = right;
        }

        public String toString() {
            return "key:"+key;
        }
    }

    ...
}

LeftistNode是左倾堆对应的节点类。
LeftistHeap是左倾堆类，它包含了左倾堆的根节点，以及左倾堆的操作。

2. 合并

/*
 * 合并"左倾堆x"和"左倾堆y"
 */
private LeftistNode<T> merge(LeftistNode<T> x, LeftistNode<T> y) {
    if(x == null) return y;
    if(y == null) return x;

    // 合并x和y时，将x作为合并后的树的根；
    // 这里的操作是保证: x的key < y的key
    if(x.key.compareTo(y.key) > 0) {
        LeftistNode<T> tmp = x;
        x = y;
        y = tmp;
    }

    // 将x的右孩子和y合并，"合并后的树的根"是x的右孩子。
    x.right = merge(x.right, y);

    // 如果"x的左孩子为空" 或者 "x的左孩子的npl<右孩子的npl"
    // 则，交换x和y
    if (x.left == null || x.left.npl < x.right.npl) {
        LeftistNode<T> tmp = x.left;
        x.left = x.right;
        x.right = tmp;
    }
    if (x.right == null || x.left == null)
        x.npl = 0;
    else
        x.npl = (x.left.npl > x.right.npl) ? (x.right.npl + 1) : (x.left.npl + 1);

    return x;
}

public void merge(LeftistHeap<T> other) {
    this.mRoot = merge(this.mRoot, other.mRoot);
}

merge(x, y)是内部接口，作用是合并x和y这两个左倾堆，并返回得到的新堆的根节点。
merge(other)是外部接口，作用是将other合并到当前堆中。

3. 添加

/* 
 * 新建结点(key)，并将其插入到左倾堆中
 *
 * 参数说明：
 *     key 插入结点的键值
 */
public void insert(T key) {
    LeftistNode<T> node = new LeftistNode<T>(key,null,null);

    // 如果新建结点失败，则返回。
    if (node != null)
        this.mRoot = merge(this.mRoot, node);
}

insert(key)的作用是新建键值为key的节点，并将其加入到当前左倾堆中。

4. 删除

/* 
 * 删除根结点
 * 
 * 返回值：
 *     返回被删除的节点的键值
 */
public T remove() {
    if (this.mRoot == null)
        return null;

    T key = this.mRoot.key;
    LeftistNode<T> l = this.mRoot.left;
    LeftistNode<T> r = this.mRoot.right;

    this.mRoot = null;          // 删除根节点
    this.mRoot = merge(l, r);   // 合并左右子树

    return key;
}

remove()的作用是删除左倾堆的最小节点。

注意：关于左倾堆的”前序遍历”、”中序遍历”、”后序遍历”、”打印”、”销毁”等接口就不再单独介绍了。后文的源码中有给出它们的实现代码，Please RTFSC(Read The Fucking Source Code)！

左倾堆的Java实现(完整源码)

左倾堆的实现文件(LeftistHeap.java)

/**
 * Java 语言: 左倾堆
 *
 * @author skywang
 * @date 2014/03/31
 */


public class LeftistHeap<T extends Comparable<T>> {

    private LeftistNode<T> mRoot;    // 根结点

    private class LeftistNode<T extends Comparable<T>> {
        T key;                    // 关键字(键值)
        int npl;                // 零路经长度(Null Path Length)
        LeftistNode<T> left;    // 左孩子
        LeftistNode<T> right;    // 右孩子

        public LeftistNode(T key, LeftistNode<T> left, LeftistNode<T> right) {
            this.key = key;
            this.npl = 0;
            this.left = left;
            this.right = right;
        }

        public String toString() {
            return "key:"+key;
        }
    }

    public LeftistHeap() {
        mRoot = null;
    }

    /*
     * 前序遍历"左倾堆"
     */
    private void preOrder(LeftistNode<T> heap) {
        if(heap != null) {
            System.out.print(heap.key+" ");
            preOrder(heap.left);
            preOrder(heap.right);
        }
    }

    public void preOrder() {
        preOrder(mRoot);
    }

    /*
     * 中序遍历"左倾堆"
     */
    private void inOrder(LeftistNode<T> heap) {
        if(heap != null) {
            inOrder(heap.left);
            System.out.print(heap.key+" ");
            inOrder(heap.right);
        }
    }

    public void inOrder() {
        inOrder(mRoot);
    }

    /*
     * 后序遍历"左倾堆"
     */
    private void postOrder(LeftistNode<T> heap) {
        if(heap != null)
        {
            postOrder(heap.left);
            postOrder(heap.right);
            System.out.print(heap.key+" ");
        }
    }

    public void postOrder() {
        postOrder(mRoot);
    }

    /*
     * 合并"左倾堆x"和"左倾堆y"
     */
    private LeftistNode<T> merge(LeftistNode<T> x, LeftistNode<T> y) {
        if(x == null) return y;
        if(y == null) return x;

        // 合并x和y时，将x作为合并后的树的根；
        // 这里的操作是保证: x的key < y的key
        if(x.key.compareTo(y.key) > 0) {
            LeftistNode<T> tmp = x;
            x = y;
            y = tmp;
        }

        // 将x的右孩子和y合并，"合并后的树的根"是x的右孩子。
        x.right = merge(x.right, y);

        // 如果"x的左孩子为空" 或者 "x的左孩子的npl<右孩子的npl"
        // 则，交换x和y
        if (x.left == null || x.left.npl < x.right.npl) {
            LeftistNode<T> tmp = x.left;
            x.left = x.right;
            x.right = tmp;
        }
        if (x.right == null || x.left == null)
            x.npl = 0;
        else
            x.npl = (x.left.npl > x.right.npl) ? (x.right.npl + 1) : (x.left.npl + 1);

        return x;
    }

    public void merge(LeftistHeap<T> other) {
        this.mRoot = merge(this.mRoot, other.mRoot);
    }

    /* 
     * 新建结点(key)，并将其插入到左倾堆中
     *
     * 参数说明：
     *     key 插入结点的键值
     */
    public void insert(T key) {
        LeftistNode<T> node = new LeftistNode<T>(key,null,null);

        // 如果新建结点失败，则返回。
        if (node != null)
            this.mRoot = merge(this.mRoot, node);
    }

    /* 
     * 删除根结点
     * 
     * 返回值：
     *     返回被删除的节点的键值
     */
    public T remove() {
        if (this.mRoot == null)
            return null;

        T key = this.mRoot.key;
        LeftistNode<T> l = this.mRoot.left;
        LeftistNode<T> r = this.mRoot.right;

        this.mRoot = null;          // 删除根节点
        this.mRoot = merge(l, r);   // 合并左右子树

        return key;
    }

    /*
     * 销毁左倾堆
     */
    private void destroy(LeftistNode<T> heap) {
        if (heap==null)
            return ;

        if (heap.left != null)
            destroy(heap.left);
        if (heap.right != null)
            destroy(heap.right);

        heap=null;
    }

    public void clear() {
        destroy(mRoot);
        mRoot = null;
    }

    /*
     * 打印"左倾堆"
     *
     * key        -- 节点的键值 
     * direction  --  0，表示该节点是根节点;
     *               -1，表示该节点是它的父结点的左孩子;
     *                1，表示该节点是它的父结点的右孩子。
     */
    private void print(LeftistNode<T> heap, T key, int direction) {

        if(heap != null) {

            if(direction==0)    // heap是根节点
                System.out.printf("%2d(%d) is root\n", heap.key, heap.npl);
            else                // heap是分支节点
                System.out.printf("%2d(%d) is %2d's %6s child\n", heap.key, heap.npl, key, direction==1?"right" : "left");

            print(heap.left, heap.key, -1);
            print(heap.right,heap.key,  1);
        }
    }

    public void print() {
        if (mRoot != null)
            print(mRoot, mRoot.key, 0);
    }
}

左倾堆的测试程序(LeftistHeapTest.java)

/**
 * Java 语言: 左倾堆
 *
 * @author skywang
 * @date 2014/03/31
 */

public class LeftistHeapTest {

    public static void main(String[] args) {
        int a[]= {10,40,24,30,36,20,12,16};
        int b[]= {17,13,11,15,19,21,23};
        LeftistHeap<Integer> ha=new LeftistHeap<Integer>();
        LeftistHeap<Integer> hb=new LeftistHeap<Integer>();

        System.out.printf("== 左倾堆(ha)中依次添加: ");
        for(int i=0; i<a.length; i++) {
            System.out.printf("%d ", a[i]);
            ha.insert(a[i]);
        }
        System.out.printf("\n== 左倾堆(ha)的详细信息: \n");
        ha.print();


        System.out.printf("\n== 左倾堆(hb)中依次添加: ");
        for(int i=0; i<b.length; i++) {
            System.out.printf("%d ", b[i]);
            hb.insert(b[i]);
        }
        System.out.printf("\n== 左倾堆(hb)的详细信息: \n");
        hb.print();

        // 将"左倾堆hb"合并到"左倾堆ha"中。
        ha.merge(hb);
        System.out.printf("\n== 合并ha和hb后的详细信息: \n");
        ha.print();
    }
}

左倾堆的Java测试程序

左倾堆的测试程序已经包含在它的实现文件(LeftistHeapTest.java)中了，这里仅给出它的运行结果：

== 左倾堆(ha)中依次添加: 10 40 24 30 36 20 12 16 
== 左倾堆(ha)的详细信息: 
10(2) is root
24(1) is 10's   left child
30(0) is 24's   left child
36(0) is 24's  right child
12(1) is 10's  right child
20(0) is 12's   left child
40(0) is 20's   left child
16(0) is 12's  right child

== 左倾堆(hb)中依次添加: 17 13 11 15 19 21 23 
== 左倾堆(hb)的详细信息: 
11(2) is root
15(1) is 11's   left child
19(0) is 15's   left child
21(0) is 15's  right child
13(1) is 11's  right child
17(0) is 13's   left child
23(0) is 13's  right child

== 合并ha和hb后的详细信息: 
10(2) is root
11(2) is 10's   left child
15(1) is 11's   left child
19(0) is 15's   left child
21(0) is 15's  right child
12(1) is 11's  right child
13(1) is 12's   left child
17(0) is 13's   left child
16(0) is 13's  right child
23(0) is 16's   left child
20(0) is 12's  right child
40(0) is 20's   left child
24(1) is 10's  right child
30(0) is 24's   left child
36(0) is 24's  right child

转载自：左倾堆(三)之 Java的实现

Coding-lover
关注
专栏目录
数据结构之——“优先队列”的理论基础知识(Java语言）
zhoucheng05_13的博客
01-15 854
优先队列 一、什么是优先队列？ 在实际应用中，以打印机为例，有的作业虽然排在后面，但很重要，需要优先打印，这种带有优先级的队列，叫做优先队列（priority queue）。 优先队列是允许至少下面两种操作的数据结构： insert（插入） deleteMin（删除最小者）：找出、返回并删除优先队列中最小的元素。 优先队列的应用场景：操作系统、外部排序算法、贪婪算法…… 二
C++基础之类和对象
最新发布
m0_63204338的博客
01-28 1382
n c语言struct只有变量n c++语言struct 既有变量，也有函数我们编写程序的目的是为了解决现实中的问题，而这些问题的构成都是由各种事物组成，我们在计算机中要解决这种问题，首先要做就是要将这个问题的参与者：事和物抽象到计算机程序中，也就是用程序语言表示现实的事物。那么现在问题是如何用程序语言来表示现实事物？现实世界的事物所具有的共性就是每个事物都具有自身的属性，一些自身具有的行为，所以如果我们能把事物的属性和行为表示出来，那么就可以抽象出来这个事物。比如我们要表示人这个对象，在c语言中，我们可以
java 左倾堆
woyixinyiyi的博客
04-10 185
package com.algorithm.charactor1; import java.util.Random; /** *左迁堆， *npl，为节点到子节点中没有两个节点的节点最短路径长，定义null节点的 npl为-1，叶子节点的npl为0 * *左迁堆和null 合并的时候 返回 当前堆 *左迁堆的父节点的 小于 左右儿子节点 *节点的左儿子节点npl &gt;= 右儿...
左倾堆以及Java实现
weixin_34144450的博客
12-19 104
左倾堆的定义 左倾堆是一棵二叉树，它的节点除了和二叉树的节点一样具有左右子树指针外，还有两个属性：键值和零距离。 键值的作用是来比较节点的大小，从而对节点进行排序。 零距离(英文名NPL，即Null Path Length)则是从一个节点到一个"最近的不满节点"的路径长度。不满节点是指该该节点的左右孩子至少有有一个为NULL。叶节点的NPL为0，NULL节点的NPL为-1。 基本性质 节点...
左堆
canwang_sjtu的博客
11-12 712
由于oj上有这道题，于是自己写一下左堆是由于递归的定义来的，所以merge的时候自然也是递归，代码如下：struct node { int val; int npl; node *left, *right; node(int x = 0, node* p = NULL, node* q = NULL) :val(x), left(p), right(q) {} }; /
左倾堆(三)之 Java的实现
kk的博客
04-10 85
概要 前面分别通过C和C++实现了左倾堆，本章给出左倾堆的Java版本。还是那句老话，三种实现的原理一样，择其一了解即可。 目录1.左倾堆的介绍2.左倾堆的图文解析3.左倾堆的Java实现(完整源码)4.左倾堆的Java测试程序 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3638384.html 更多内容：数据结...
左倾堆（对两个优先队列合并）
weixin_30781433的博客
10-08 400
一、左倾堆的介绍 左倾堆(leftist tree 或 leftist heap)，又被成为左偏树、左偏堆，最左堆等。它和二叉堆一样，都是优先队列实现方式。当优先队列中涉及到"对两个优先队列进行合并"的问题时，二叉堆的效率就无法令人满意了，而本文介绍的左倾堆，则可以很好地解决这类问题。 左倾堆的定义 上图是一颗左倾树，它的节点除了和二叉树的节点一样具有左右子树指针外，还有两个属...
Java实现的左倾树算法解析
Java提供了PriorityQueue类，该类底层实现实际上是一个优先队列，可以视为左倾树（或其他堆结构）的高级封装。了解左倾树的实现有助于深入理解PriorityQueue的工作原理，甚至在需要更高效或特定功能时，可以考虑自行...
Java中的树旋转：AVL与红黑树维护秘籍
[数据结构 树 java实现](https://media.geeksforgeeks.org/wp-content/uploads/20221129094006/Treedatastructure.png) # 1. Java中树结构的基本概念 在计算机科学中，树结构是一种非常重要的非线性数据结构，它...
JAVA知识点全总结——（八）算法与数据结构
QuinnNorris的博客
07-25 1078
上一篇：JAVA知识点全总结——（七）设计模式 8. 算法与数据结构 8.1 排序算法 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 8.2 查找算法 遍历查找 二分查找 二叉树查找 红黑树查找 跳表查找 8.3 拓扑排序 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，...
左倾堆（一种可高效合并的优先队列)
热门推荐
ljsspace的专栏
08-21 1万+
左倾堆(Leftist Heap)是一个便于merge操作的数据结构，通过左倾树(Leftist Tree)实现。左倾树是一种特殊的二叉树,树中结点除了满足普通二叉堆的key大小规定外，还要求每一个结点X的左子树的Null Path Length（NPL)值不小于右子树的NPL值
左高树
carter的专栏
02-22 2489
template class MaxHBLT;template class HBLTNode { friend MaxHBLT;public: HBLTNode(const T& e, const int sh) {data = e; s = sh; LeftChild = RightChild = 0;}private: int s; // s valu
数据结构——左高树
weixin_30781775的博客
05-18 157
一、扩充二叉树 考察一棵二叉树，它有一类特殊的节点叫做外部节点（ external node），用来代替树中的空子树，其余节点叫做内部节点（ internal node）。增加了外部节点的二叉树被称为扩充二叉树（extended binary tree），图9-6a 给出了一棵二叉树，其相应的扩充二叉树如图9-6b 所示，外部节点用阴影框表示，为了方便起见，这些节点用a～f标注。 令s (x)...
可合并堆-左偏树 初级入门教程
HT008的Blog
01-07 1295
引言 对于维护一串数的最大值，最小值，插入，查询，删除优先值。 我们仅需要使用二叉堆也就是STL中的优先队列即可维护！ 但如果有多个堆并且需要我们对堆进行合并，该怎么办？ 于是引入可合并堆。 可合并堆有四种，这里介绍左偏树。 支持合并，查询，插入，删除优先值操作。 性质 1：根节点大于（小于）任何一个子节点（堆的性质） 2：节点的左儿子的距离不小于右儿子的距离。 3：根节点
算法详解——左偏树
dilei7762的博客
06-07 592
可并堆是啥 给你两个优先队列，要你合并这两个优先队列，而且还要保证合并后符合优先队列的性质，时间复杂度要限制在log⁡(s1+s2)\log (s_1+s_2)log(s1​+s2​)之内。 怎么做？现在普通的堆已经满足不了要求了。 这个时候，就要用一种神奇的数据结构：左偏树了。 （二项堆，斐波那契堆不在本文的考虑范围内） 左偏树 顾名思义...
左堆（Leftist Heaps）
changyuanchn的专栏
11-09 5860
0）引论 为什么要提出左堆这么一个概念呢？有了二插堆还不够么。这是因为前面提到的数据结构在支持合并（merge）操作的时候是比较差的。比如对于一个二叉查找树来说，要把两个二叉查找树合并，那么可能需要把一个二叉树的结点一个一个的插入到另一个二叉树中，这个的时间消耗是一个很恐怖的事情。因此我们引入左堆。 1） 左堆的一些基本概念 零路径长（null path length）Npl(X)：结点X到
Java数据结构与算法：堆
JackChan
01-04 2611
堆的定义设有n个数据元素的关键字为（k0、k1、…、kn-1），如果它们满足以下的关系：ki<= k2i+1且ki<= k2i+2（或ki>= k2i+1且ki>= k2i+2）（i=0、1、…、(n-2)/2）则称之为堆(Heap)。如果将此数据元素序列用一维数组存储，并将此数组对应一棵完全二叉树，则堆的含义可以理解为：在完全二叉树中任何非终端结点的关键字均不大于（或不小于）其左、右孩子结点的
左偏树/斜堆——可并堆详解
来自Fop_zz的辣鸡题解或教程
03-02 1650
所谓可并堆，顾名思义，就是可以合并的堆。 最常用的堆应该大家都知道，优先队列二叉堆，是吧 可是如果要求把两个堆合并，要怎么做？ 一个个数pop提取出来然后再重新构造一个堆？ 显然这种方法太暴力了.. 有了可并堆，这个问题就可以被完美的解决了=V= 可并堆定义： 可并堆(Mergeable Heap)也是一种抽象数据类型，它除了支持优先队列的三个基本操作(Insert, Minimum
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值