[hihoCoder]#1325 : 平衡树·Treap(平衡树)

#1325 : 平衡树·Treap

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

小Ho：小Hi，我发现我们以前讲过的两个数据结构特别相似。

小Hi：你说的是哪两个啊？

小Ho：就是二叉排序树和堆啊，你看这两种数据结构都是构造了一个二叉树，一个节点有一个父亲和两个儿子。 如果用1..n的数组来存储的话，对于二叉树上的一个编号为k的节点，其父亲节点刚好是k/2。并且它的两个儿子节点分别为k*2和k*2+1，计算起来非常方便呢。

小Hi：没错，但是小Hi你知道有一种办法可以把堆和二叉搜索树合并起来，成为一个新的数据结构么？

小Ho：这我倒没想过。不过二叉搜索树满足左子树<根节点<右子树，而堆是满足根节点小于等于(或大于等于)左右儿子。这两种性质是冲突的啊？

小Hi：恩，你说的没错，这两种性质的确是冲突的。

小Ho：那你说的合并是怎么做到的？

小Hi：当然有办法了，其实它是这样的....

提示：Tree+Heap?

输入

第1行：1个正整数n，表示操作数量，10≤n≤100,000

第2..n+1行：每行1个字母c和1个整数k：

若c为'I'，表示插入一个数字k到树中，-1,000,000,000≤k≤1,000,000,000

若c为'Q'，表示询问树中不超过k的最大数字

输出

若干行：每行1个整数，表示针对询问的回答，保证一定有合法的解

样例输入

5
I 3
I 2
Q 3
I 5
Q 4

样例输出

3
3

利用了平衡树的查询: AC代码

import java.util.Scanner;
import java.util.Vector;
class Node{
	Node left,right;
	int data;
	int height;
	public Node(int data){
		this.data = data;
		this.height = 0;
		this.left = null;
		this.right = null;
	}
}

class TVLTree{
	private Vector<Integer> v;
	//RR旋转
	private Node RR(Node root){
		Node newroot = root.right;
		root.right = newroot.left;
		newroot.left = root;
		newroot.height = setHeight(newroot);
		root.height = setHeight(root);
		return newroot;
	}
	//LL旋转
	private Node LL(Node root){
		Node newroot = root.left;
		root.left = newroot.right;
		newroot.right = root;
		newroot.height = setHeight(newroot);
		root.height = setHeight(root);
		return newroot;
	}
	//RL旋转
	private Node RL(Node root){
		root.right = LL(root.right);
		root = RR(root);
		return root;
	}
	//LR旋转
	private Node LR(Node root){
		root.left = RR(root.left);
		root = LL(root);
		return root;
	}
	//设置节点高度
 	private int setHeight(Node root){
		if(root==null){
			return 0;
		}
		return 1+Math.max((root.left!=null?root.left.height:0),(root.right!=null?root.right.height:0));
	}
	//获取节点高度
	private int getHeight(Node root){
		if(root==null){
			return 0;
		}
		return root.height;
	}
	//得到节点的平衡因子
	private int balance(Node root){
		return getHeight(root.left) - getHeight(root.right);
	}
	//插入节点
	public Node insert(Node root,int data){
		if(root==null){
			root = new Node(data);
		}else if(data>root.data){
			root.right = insert(root.right,data);
			if(balance(root)<-1){
				if(getHeight(root.right.right)>getHeight(root.right.left)){
					root = RR(root);
				}else if(getHeight(root.right.right)<getHeight(root.right.left)){
					root = RL(root);
				}
			}
		}else if(data<root.data){
			root.left = insert(root.left,data);
			if(balance(root)>1){
				if(getHeight(root.left.left)>getHeight(root.left.right)){
					root = LL(root);
				}else if(getHeight(root.left.left)<getHeight(root.left.right)){
					root = LR(root);
				}
			}
		}
		root.height = setHeight(root);
		return root;
	}

	//查询不超过data的最大数
	public int query(Node root,int data){
		int max = 0;
		while(root!=null){
			if(data>=root.data){
				max = root.data;
				root = root.right;
			}else{
				root = root.left;
			}
		}
		return max;
	}
}
public class Main{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int N = scan.nextInt();
		TVLTree tvl = new TVLTree();
		Node root = null;
		Vector<Integer> v = new Vector<>();
		int count = 0;
		while(N--!=0){
			String cp = scan.next();
			int data = scan.nextInt();
			if(cp.equals("I")){
				root = tvl.insert(root,data);
			}else{
				count++;
				v.add(tvl.query(root,data));
			}
		}

		for(int i=0;i<count;i++){
			System.out.println(v.get(i));
		}
	}
}