第十一课 常见的二叉树：基于二叉搜索树的平衡二叉树之树堆Treap

1 定义

Treap是用来排序(Sort)的一种数据结构(Data Structure)。reap是随机查找二叉平衡树。 Treap发音为tree+ Heap。顾名思义，
Treap把 BST和 Heap结合了起来。它和 BST一样满足许多优美的性质，而引入堆目的就是为了维护平衡。 Treap在 BST的基础上，
添加了一个优先级。在满足 BST性质的上，Treap节点的优先级还满足最小堆性质。最小堆性质可以被描述为每个子树根节点都小
于等于其子节点。

2 特点

一棵treap是一棵修改了结点顺序的二叉查找树，通常树内的每个结点x都有一个关键字值key[x]，另外，还要为结点分配priority[x]，
它是一个独立选取的随机数。假设所有的优先级是不同的，所有的关键字也是不同的。treap的结点排列成让关键字遵循二叉查找树性质，
并且优先级(有的地方也叫修正值，是一个随机数)遵循最小堆顺序性质：
（1）如果left是u的左孩子，则key[left] < key[u].
（2）如果right是u的右孩子，则key[right] > key[u].
（3）如果child是u的孩子，则priority[child] > priority[u].
（4）如果priority[vi] < priority[vj].则vi相对于vj而言更接近根节点。

3 旋转

树堆只有左旋和右旋

4 常用操作

4.1 插入

（1）基于二叉搜索树的插入
（2）插入后的平衡调整
只要当前节点比父节点的优先级小，就往上浮，如果是左孩子就右旋父亲，如果是右孩子，就左旋父亲，然后继续递归

4.2 删除

（1）是叶子节点或者只有一个孩子的时候
基于二叉搜索树的删除
（2）如果有两个孩子的时候，将该节点一直旋转下去，直到它是叶子或者只有一个孩子，然后用二叉搜索树的删除，
旋转过程：如果左孩子的优先级小于右孩子优先级，右旋当前节点，如果右孩子的优先级小于左孩子的优先级，
左旋当前节点。

5 代码实现

package com.yc.tree;
 
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import java.util.Random;
 
public class Treap <T extends Comparable<T>>{
	public class Node{
		T data;
		//优先级
		int priority; 
		Node parent;
		Node left;
		Node right;
		public Node(T data, int priority, Node parent, Node left, Node right){
			this.data = data;
			this.priority = priority;
			this.parent = parent;
			this.left = left;
			this.right = right;
		}
	}
	//根
	private Node root;
	
	public Treap(){
		root = null;
	}
	public Treap(T data){
		root = new Node(data, new Random().nextInt(1,10), null, null, null);
	}
	public Treap(T data, int priority){
		root = new Node(data, priority, null, null, null);
	}
	
	/**
	*插入
	*@param data
	*/
	public void insert(T data){
		insert(data, new Random().nextInt(1,10));
	}
	
	/**
	*将优先级为priority，值为data的节点插入
	*param data,priority
	*/
	private void insert(T data, int priority){
		Node newNode = new Node(data, priority, null, null, null);
		if(root == null){
			root = newNode;
		}else{
			Node current = root;
			Node parent = current;
			int result = 0;
			//1 寻找插入位置
			while(current != null){
				parent = current;
				result = data.compareTo(current.data);
				if(result > 0){ 
					current = current.right;
				}else{
					current = current.left;
				}
			}
			//2 插入
			if(result > 0){ 
				parent.right = newNode;
			}else{
				parent.left = newNode;
			}
			newNode.parent = parent;
			parent = null;  
			//3 插入后平衡调整
			reBalanceForAdd(newNode);
			
		}
	}
	
	/**
	*删除
	*param data
	*/
	public void remove(T data){
		Node node = getNode(data);
		if(node != null){
			//如果是叶子节点
			if(node.left == null && node.right == null){ 
				removeNeitherLeftAndRight(node);
			}
			//只有左子节点
			else if(node.left != null && node.right == null){ 
				removeOnlyHasLeft(node);
			}
			//只有右子节点
			else if(node.right != null && node.left == null){ 
				removeOnlyHasRight(node);
			}
			//既有左子树又有右子树
			else{ 
				removeHaveLeftAndRight(node);
			}
		}
	}
	
    /**
	*删除的节点是叶子
	*param node
	*/
	private void removeNeitherLeftAndRight(Node node){
		if(root == node){
			root = null;
		}else{
			if(node == node.parent.left){
				node.parent.left = null;
				node.parent = null;
			}else{
				node.parent.right = null;
				node.parent = null;
			}
		}
	}
	
	/**
	*删除的节点有左孩子
	*param node
	*/
	private void removeOnlyHasLeft(Node node){
		node.left.parent = node.parent;
		if(node.parent != null){
			if(node == node.parent.left){
				node.parent.left = node.left;
			}else{
				node.parent.right = node.left;
			}
		}
		
		if(root == node){
			root = node.left;
		}
		node.parent = node.left = node.right = null;
	}
	
	/**
	*删除的节点有右孩子
	*param node
	*/
	private void removeOnlyHasRight(Node node){
		node.right.parent = node.parent;
		if(node.parent != null){
			if(node == node.parent.left){
				node.parent.left = node.right;
			}else{
				node.parent.right = node.right;
			}
		}
		
		if(root == node){
			root = node.right;
		}
		node.parent = node.left = node.right = null;
	}
	
	/**
	*删除的节点有左右孩子
	*param node
	*/	
	private void removeHaveLeftAndRight(Node node){
		int result = 0;
		while(node.left != null && node.right != null){
			result = node.left.priority - node.right.priority;
			//左孩子的优先级小于右孩子
			if(result <= 0){ 
				rotateright(node);
			}
			//右孩子的优先级小于左孩子
			else{
				rotateLeft(node);
			}
		}
		//如果是叶子节点
		if(node.left == null && node.right == null){ 
			removeNeitherLeftAndRight(node);
		}
		//只有左子节点
		else if(node.left != null && node.right == null){ 
			removeOnlyHasLeft(node);
		}
		//只有右子节点
		else if(node.right != null && node.left == null){ 
			removeOnlyHasRight(node);
		}
	}
	
	/**
	 * 左旋
	 */
	private IBinaryTreeNode<E> rotateLeft(IBinaryTreeNode<E> nodeA) {
		IBinaryTreeNode<E> nodeB = nodeA.getRightNode();
		nodeB.setParentNode(nodeA.getParentNode());
		nodeA.setRightNode(nodeB.getLeftNode());
		if (nodeB.getParentNode() != null) {
			if (nodeA.isLeft()) {
				nodeB.getParentNode().setLeftNode(nodeB);
			} else {
				nodeB.getParentNode().setRightNode(nodeB);
			}
		}
		nodeB.setLeftNode(nodeA);
		return nodeB;
	}
 
	/*
	 *右旋
	 */
	private IBinaryTreeNode<E> rotateRight(IBinaryTreeNode<E> nodeA) {
		IBinaryTreeNode<E> nodeB = nodeA.getLeftNode();
		nodeB.setParentNode(nodeA.getParentNode());
		nodeA.setLeftNode(nodeB.getRightNode());
		if (nodeB.getParentNode() != null) {
			if (nodeA.isLeft()) {
				nodeB.getParentNode().setLeftNode(nodeB);
			} else {
				nodeB.getParentNode().setRightNode(nodeB);
			}
		}
		nodeB.setRightNode(nodeA);
		return nodeB;
	}
	
	/**
	*插入后调整
	*param node
	*/
	private void reBalanceForAdd(Node node) {
		if(node.parent != null){
			int result = node.priority - node.parent.priority;
			if(result < 0){
				if(node == node.parent.left){
					type_right(node.parent);
				}else if(node == node.parent.right){
					type_left(node.parent);	
				}
				reBalanceForAdd(node.parent);
			}else{
				return;
			}
		}
	}
 
	
	
	/**
	*查找指定元素的节点
	*param data
	*/
	private Node getNode(T data){
		Node current = root;
		if(current == null){
			return null;
		}else{
			int result = 0;
			while(current != null){
				result = data.compareTo(current.data);
				if(result > 0){
					current = current.right;
				}else if(result < 0){
					current = current.left;
				}else{
					return current;
				}
			}
			return null;
		}
	}
	
}