BST树二叉搜索树
左子树比根节点小，右子树比根节点大
BST树节点
public class BSTNode {
int data;
BSTNode left;
BSTNode right;
public BSTNode(int data, BSTNode left, BSTNode right) {
this.data = data;
this.left = left;
this.right = right;
}
}BST树常见操作：
public class BinarySearchTree {
//BST树的根节点的引用
public BSTNode root;
public BinarySearchTree() {
this.root = null;
}
/**
* 非递归实现BST树的插入操作
* @param val
*/
public void insert_non(int val){
//1.考虑根节点的特殊情况
if(root == null){
root = new BSTNode(val, null, null);
return;
}
//2.寻找val值需要插入的地方
BSTNode parent = null;
BSTNode cur = root;
while(cur != null){
if(val < cur.data){
parent = cur;
cur = cur.left;
} else if(val > cur.data){
parent = cur;
cur = cur.right;
} else {
return;
}
}
//3.把val值生成新节点插入到BST树当中
if(val < parent.data){
parent.left = new BSTNode(val, null, null);
} else {
parent.right = new BSTNode(val, null, null);
}
}
/**
* 递归实现BST树的插入操作
* @param val
*/
public void insert(int val){
root = insert(root, val);
}
/**
* 从root节点开始寻找位置，插入val
* @param root
* @param val
* @return
*/
private BSTNode insert(BSTNode root, int val) {
if(root == null){
return new BSTNode(val, null, null);
}
if(val < root.data){
root.left = insert(root.left, val);
} else if(val > root.data){
root.right = insert(root.right, val);
}
return root;
}
/**
* 非递归实现BST的删除操作
* 1.有两个孩子 用前驱或者后继节点代替一下
* 2.有一个孩子
* 3.叶子节点
* @param val
*/
public void remove_non(int val){
//1.找到值为val的节点
BSTNode parent = null;
BSTNode cur = root;
while(cur != null){
if(val < cur.data){
parent = cur;
cur = cur.left;
} else if(val > cur.data){
parent = cur;
cur = cur.right;
} else {
break;
}
}
//要删除的结点不存在
if(cur == null){
return;
}
//2.处理有两个孩子的节点
if(cur.left != null && cur.right != null){
parent = cur;
//用前驱节点来代替（左孩子的最后一个右子树结点）
/*BSTNode p = cur.left;
while(p.right != null){
parent = p;
p = p.right;
}*/
//用后继节点来代替 （右孩子的最后一个左子树结点）
BSTNode p = cur.right;
while(p.left != null){
parent = p;
p = p.left;
}
cur.data = p.data;
cur = p;
}
//3.删除cur引用的节点 处理2,3的情况
BSTNode child = cur.left;
if(child == null){
child = cur.right;
}
if(parent==null){ //删除根结点 根节点只有一个孩子
root=child;
} else if(cur.data < parent.data){ // cur在parent左孩子上
parent.left = child;
} else {
parent.right = child;
}
}
/**
* 用递归删除BST树中值为val的节点
* @param val
*/
public void remove(int val){
root = remove(root, val);
}
/**
* 递归删除值为val的节点，删除以后，把根节点返回回去
* @param root
* @param val
* @return
*/
private BSTNode remove(BSTNode root, int val) {
if(root == null){
return null;
}
if(val < root.data){
root.left = remove(root.left, val);
} else if(val > root.data){
root.right = remove(root.right, val);
} else {
//表示找到值为val的节点了
if(root.left != null && root.right != null){
//后继节点替换
BSTNode p = root.right;
while(p.left != null){
p = p.left;
}
root.data = p.data;
root.right = remove(root.right, p.data);
} else {
//有一个孩子或者叶子节点
if(root.left != null){
return root.left;
}
if(root.right != null) {
return root.right;
}
return null;
}
}
return root;
}
/**
* BST树的搜索，找值为val的节点是否存在
* @param val
* @return
*/
public boolean query1(BSTNode root,int val){
boolean res=false;
if(root==null) {
return false;
}else if(root.data==val){
return true;
}else{
res=query1(root.left,val);
if(res==false){
res=query1(root.right,val);
}
return res;
}
}
/**
* BST树的搜索，找值为val的节点是否存在 返回结点
* @param val
* @return
*/
public BSTNode query(int val){
return query(root, val);
}
/**
* 递归搜索值为val的节点
* @param root
* @param val
* @return
*/
private BSTNode query(BSTNode root, int val) {
if(root == null){
return null;
}
if(val < root.data){
return query(root.left, val);
} else if(val > root.data){
return query(root.right, val);
} else{
return root;
}
}
/**
* BST的前序遍历递归 VLR
*/
public void preOrder(BSTNode root){
if(root==null) return;
System.out.print(root.data +" ");
preOrder(root.left);
preOrder(root.right);
}
/**
* 非递归前序遍历（栈来实现） 根节点入栈（从根结点开始的左子树的左孩子一直入栈直到NULL ），且在入栈之前打印结点的data，
* 出栈，root指向栈顶元素（当前结点）的右孩子 右孩子不为null 时 打印 并入栈 ；右孩子为NULL 继续出栈下一个元素；
*
* @param root
*/
public void NicePreOrder(BSTNode root){
if(root==null){
return;
}
Stack<BSTNode> st=new Stack<BSTNode>();
while(!st.isEmpty() || root!=null) {
while (root != null) {
System.out.print(root.data + " ");
st.push(root);
root = root.left;
}
if (!st.isEmpty()) {
root = st.peek();
st.pop();
root = root.right;
}
}
}
/**
* BST的中序遍历递归 LVR
*/
public void inOrder(BSTNode root){
if(root==null){
return;
}
inOrder(root.left);
System.out.print(root.data +" ");
inOrder(root.right);
}
/**
* 非递归中序遍历
* 从根节点开始到左孩子的left一直入栈
*
* 出栈，并打印 ，如果当前出栈元素的右孩子不为NULL(以及右孩子的左子树不为NULL)就全部入栈，如果为null 继续出栈下一个元素；
* @param root
*/
public void NiceInOder(BSTNode root){
if(root==null){
return;
}
Stack<BSTNode> st=new Stack<BSTNode>();
while(!st.isEmpty() || root!=null) {
while (root != null) {
st.push(root);
root = root.left;
}
root = st.peek();
st.pop();
System.out.print(root.data + " ");
root = root.right; //右孩子以及右孩子的左子树都入栈；
}
}
/**
* BST树的后序遍历 LRV 对每课树都是LRV
*/
public void lastOrder(BSTNode root){
if(root==null){
return;
}
lastOrder(root.left);
lastOrder(root.right);
System.out.print(root.data +" ");
}
/**
* 非递归后序
*
* 从根节点开始往left一直入栈
* 出栈之前先判断当前栈顶元素的右孩子以及右孩子的左子树是否为NULL 不为null时先入栈
* 为NULL时，就出栈并 打印栈顶元素
* @param root
*
*/
//LRV 出栈之前先把右孩子以及右孩子的左子树都入栈
public void NiceLastOrder(BSTNode root){
if(root==null){
return;
}
Stack<BSTNode> st=new Stack<BSTNode>();
BSTNode tag=null;
while (!st.isEmpty() || root!=null){
while(root!=null){
st.push(root);
root=root.left;
}
root=st.peek();
st.pop();
if(root.right==null || root.right==tag){ //找栈顶值的右孩子
System.out.print(root.data+" ");
tag=root;
root=null;
}else{ //有右孩子
st.push(root);
root=root.right;
}
}
}
/**
* 层序遍历 出队打印后把左右孩子都入队
*/
public void levelOrder(BSTNode root){
if(root==null){
return;
}
Queue<BSTNode> qu=new LinkedList<BSTNode>();
qu.add(root);
while (!qu.isEmpty()){
root=qu.peek(); //从对头获取元素
qu.poll(); //从队中移出
System.out.print(root.data+" ");
if(root.left!=null){
qu.add(root.left);
}
if(root.right!=null){
qu.add(root.right);
}
}
}
/**
*
* @param root
*/
public void LeveOrder(BSTNode root){
int height=height(root);
for(int i=0;i<=height;i++){
leve(root,i);
}
System.out.println();
}
private void leve(BSTNode root, int i) {
if(root==null){ //BST不一定是一颗完全树
return;
}
if(i==1) {
System.out.print(root.data +" ");
}
leve(root.left,i-1);
leve(root.right,i-1);
}
/**
* 递归实现求BST树的高度/层数
* @return
*/
public int height(BSTNode root){
if(root==null){
return 0;
}
return height(root.left)>height(root.right)?height(root.left)+1:height(root.right)+1;
}
/**
* 递归实现求BST树节点的个数
* @return
*/
public int number(BSTNode root){
if(root==null){
return 0;
}
return number(root.right)+number(root.left)+1;
}
/**
* 求二叉树满足某一个区间[begin, end]的所有节点的值，放入list当中
*/
public List<Integer> findAreaValue(int begin, int end){
List<Integer> list=new ArrayList<Integer>();
findValue(root,list,begin,end);
return list;
}
private void findValue(BSTNode root, List<Integer> list, int begin, int end) {
if(root!=null){
findValue(root.left,list,begin,end);
if(root.data>begin && root.data<end){
list.add(root.data);
}else if(root.data>end){
return;
}
findValue(root.right,list,begin,end);
}
}
/**
* 求BST的镜像 交换每一颗子树的左右孩子
*/
public void mirror(BSTNode root){
if(root == null){
return;
}
Stack<BSTNode> stack = new Stack<BSTNode>();
stack.push(root);
while(!stack.isEmpty()){
BSTNode node = stack.pop();
if(node.left != null||node.right != null){
BSTNode temp = node.left;
node.left = node.right;
node.right = temp;
}
if(node.left!=null){
stack.push(node.left);
}
if(node.right!=null){
stack.push(node.right);
}
}
}
/**
* 递归求镜像
* @param root
*/
public void mirror1(BSTNode root){
if(root==null){
return;
}
BSTNode temp =root.left;
root.left = root.right;
root.right = temp;
mirror1(root.left);
mirror1(root.right);
}
/**
* 判断形参bst树，是不是当前BST树(this)的一颗子树结构
* @param bst
* @return
*/
public boolean isChildTree(BinarySearchTree bst){
boolean res=false;
//当Tree1和Tree2都不为null的时候才可以比较
if(this!=null && bst!=null) {
//如果找到了对应的Tree2的根节点的点
if (this.root.data == bst.root.data) {
res=HaveTree(this.root,bst.root);
//如果未找到，则以根节点的左孩子为起点，去判断是否包含Tree2
if(!res){
res=HaveTree(this.root.left,bst.root);
}
//如果未找到，则以根节点的右孩子为起点，去判断是否包含Tree2
if(!res){
res=HaveTree(this.root.right,bst.root);
}
}
}
return res;
}
private boolean HaveTree(BSTNode root1, BSTNode root2) {
//root2遍历完了 全部匹配
if(root2==null){
return true;
}else if(root1==null){ //root1先遍历完了 root2中存在在root1没有的结点；
return false;
}
if(root1==null && root2==null){ //两棵树的结点一直相等，直到结点遍历完了
return true;
}
if(root1.data!=root2.data){
return false;
}
//如果根节点对应的上，那么就分别去子节点里面匹配
return HaveTree(root1.left, root2.left)&& HaveTree(root1.right, root2.right);
}
/**
* 从root节点开始，求val1和val2的最近公共祖先节点，并返回该祖先节点的值val LCA
* @param val1
* @param val2
* @return
*/
public int getLCA1(int val1, int val2){
BSTNode node1 = query(val1);
BSTNode node2 = query(val2);
return getLCA(root, node1, node2);
}
/**
*
* @param root
* @param node1
* @param node2
* @return
*/
private int getLCA(BSTNode root, BSTNode node1, BSTNode node2) {
if(node1.data < root.data && node2.data < root.data){
return getLCA(root.left, node1, node2);
} else if(node1.data > root.data && node2.data > root.data){
return getLCA(root.right, node1, node2);
} else {
return root.data;
}
}
/**
* 从root节点开始，求val1和val2的最近公共祖先节点，并返回该祖先节点的值val LCA
* @param val1
* @param val2
* @return
*/
public int getLCA(int val1, int val2){
if(root==null){
return -1;
}
while(root!=null){
if(root.data>val1 && root.data>val2){
root=root.left;
}else if(root.data<val1 && root.data<val2){
root=root.right;
}else {
return root.data;
}
}
return -1;
}
/**
* 寻找中序遍历第K个节点
* @param k
* @return
*/
public int getInOrderNoK(BSTNode root,int k){
int count=0;
Stack<BSTNode> st=new Stack<BSTNode>();
if(count>k || root==null){
return -1;
}
while(!st.isEmpty()|| root!=null) {
while (root != null) {
st.push(root);
root = root.left;
}
root = st.peek();
count++;
if (count == k) {
return root.data;
}
st.pop();
root = root.right;
}
return -1;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
