《征服数据结构》FHQ-Treap

摘要：

1，FHQ Treap的介绍

2，FHQ Treap的两种分裂方式

3，FHQ Treap的合并

4，FHQ Treap节点插入

5，FHQ Treap节点删除和区间删除

6，FHQ Treap节点搜索

7，FHQ Treap计算节点排名

8，FHQ Treap查找排名第 k 的节点

9，FHQ Treap查找前驱节点

10，FHQ Treap查找后继节点

1，FHQ Treap的介绍

FHQ Treap又名无旋Treap，是一种不需要旋转的平衡树，它的每个节点都有两个属性，一个是满足二叉搜索树的，一个是满足堆的，其中满足堆的属性是随机生成的，和我们前面讲的《Treap》类似，只不过FHQ Treap是不需要旋转的，它的所有的操作都是基于树的分裂与合并。

FHQ Treap也是属于二叉搜索树的一种，在学习FHQ Treap之前最好先看下《二叉搜索树》，《Treap》和《笛卡尔树》。我们先来看下节点类。

Java 代码：

class Node {
    int val;// 节点值
    int priority;// 节点优先级，随机生成的
    int size;// 节点个数
    Node left, right;// 左子树和右子树

    Node(int val) {
        this.val = val;
        this.priority = new Random().nextInt();
        this.size = 1;
    }
}

C++ 代码：

struct Node {
    int val;// 节点值
    int priority;// 节点优先级，随机生成的
    int size;// 节点个数
    Node *left = nullptr, *right = nullptr;// 左子树和右子树
    // 节点优先级priority，满足堆的特性，随机生成的
    Node(int val) : val(val), priority(rand()), size(1) {}
};

节点类和前面讲的《Treap》类似，只不过这里多了一个属性size，它记录的是以当前节点为根节点的子树中节点的个数，如下图所示：

Java 代码：

private Node root;// 根节点

// 获取节点个数
public int getSize(Node node) {
    return node == null ? 0 : node.size;
}

// 更新节点个数
private void updateSize(Node node) {
    if (node == null)
        return;
    // 以当前节点为根节点的子树中节点个数。
    node.size = getSize(node.left) + getSize(node.right) + 1;
}

C++ 代码

Node *root = nullptr;// 根节点

// 获取节点个数
int getSize(Node *node) {
    return node == nullptr ? 0 : node->size;
}

// 更新节点个数
void updateSize(Node *node) {
    if (node == nullptr) return;
    // 以当前节点为根节点的子树中节点个数。
    node->size = getSize(node->left) + getSize(node->right) + 1;
}

2，FHQ Treap的两种分裂方式

分裂就是把一棵树分成两棵树，FHQ Treap的分裂主要有两种方式，一种是按值分裂，一种是按大小分裂。

1，按值分裂：根据值val把一棵树分裂成两棵树，一棵树的节点值全部小于等于val，另外一棵树的节点值全部大于val。

2，按大小分裂：根据节点个数size分裂成两棵树，一棵树的节点个数为size，另外一棵为剩下的。

我们先来看下按值分裂，如下图所示，是按值为 5 进行分裂，从上往下不好分，我们采用递归的方式从下往上分。分裂之后左边这棵树所有节点值都小于等于 5 ，右边这棵树所有节点值都大于 5 。（图中圆圈内的是节点的值，满足二叉搜索树的特性，圆圈外的是节点的优先级，满足堆的特性）。

在来看下代码，分裂的时候还要更新节点的个数。

Java 代码：

// 根据值val分裂
private Node[] splitByVal(int val) {
    return splitByVal(root, val);
}

/**
 * 一棵二叉树分裂成两棵子树，其中一棵子树的所有节点都
 * 小于等于val，另一棵子树的所有节点都大于val。
 *
 * @param node 待分裂的二叉树
 * @param val  根据当前值分裂
 * @return 分裂之后的两棵子树
 */
private Node[] splitByVal(Node node, int val) {
    if (node == null) {// 如果节点为空，直接返回两个空的子树。
        return new Node[]{null, null};
    }
    // nodes[0]是分裂之后左边的树，nodes[1]是分裂之后右边的树。
    Node[] nodes;
    if (node.val <= val) {
        // 当前节点值小于等于val，所以它是分裂之后的左树，
        // 它的右子树应该连到分裂后的左树。
        nodes = splitByVal(node.right, val);
        node.right = nodes[0];
        nodes[0] = node;
    } else {
        // 当前节点值大于val，所以它是分裂之后的右树，原理同上。
        nodes = splitByVal(node.left, val);
        node.left = nodes[1];
        nodes[1] = node;
    }
    updateSize(node);// 更新节点node
    return nodes;// 返回分裂后的两棵子树
}

C++ 代码：

/**
 * 一棵二叉树分裂成两棵子树，其中一棵子树的所有节点都
 * 小于等于val，另一棵子树的所有节点都大于val。
 *
 * @param node 待分裂的二叉树
 * @param val  根据当前值分裂
 * @return 分裂之后的两棵子树
 */
vector<Node *> splitByVal(Node *node, int val) {
    if (node == nullptr) {// 如果节点为空，直接返回两个空的子树。
        return {nullptr, nullptr};
    }
    // nodes[0]是分裂之后左边的树，nodes[1]是分裂之后右边的树。
    vector<Node *> nodes;
    if (node->val <= val) {
        // 当前节点值小于等于val，所以它是分裂之后的左树，
        // 它的右子树应该连到分裂后的左树。
        nodes = splitByVal(node->right, val);
        node->right = nodes[0];
        nodes[0] = node;
    } else {
        // 当前节点值大于val，所以它是分裂之后的右树，原理同上。
        nodes = splitByVal(node->left, val);
        node->left = nodes[1];
        nodes[1] = node;
    }
    updateSize(node);// 更新节点node
    return nodes;// 返回分裂后的两个子树
}

// 根据值val分裂
vector<Node *> splitByVal(int val) {
    return splitByVal(root, val);
}

再来看下按照大小分裂，代码和上面类似，分裂之后的左树中节点个数是 k ，剩下的节点在右树上。