文章目录
1. 二叉搜索树概念
- 二叉树的一种变形
- 对于BST中的任意一个节点，其左子节点值比它小，右子节点值比它大
- BST的节点类型和普通二叉树一样
- 对BST进行中序遍历可以得到一个升序序列
2. BST的一些操作
2.1 查找某个元素
public static Node find(Node root,Node target) {
if(root==null)
return null;
if(root.val<target.val)
return find(root.right, target);
else if(root.val>target.val)
return find(root.left, target);
else if(root.val==target.val)
return root;
return null;
}
public static Node find(Node root,Node target) {
if(root==null)
return null;
while(root!=null) {
if(root.val<target.val)
root=root.right;
else if(root.val>target.val)
root=root.left;
else if(root.val==target.val)
return root;
}
return null;
}
2.2 查找最小的元素
/*
* 一直沿着左子树找 找到最左边的节点，该节点没有左子节点
*/
public static Node findMin(Node root) {
if(root==null)
return null;
if(root.left==null)
return root;
return findLeast(root.left);
}
/*
* 一直沿着左子树找 找到最左边的节点，该节点没有左子节点
*/
public static Node findMin(Node root) {
if(root==null)
return null;
while(root.left!=null) {
root=root.left;
}
return root;
}
2.2 查找最大的元素
/*
* 一直沿着右子树找 找到最右边的节点，该节点没有右子节点
*/
public static Node findMax(Node root) {
if(root==null)
return null;
if(root.right==null)
return root;
return findMax(root.right);
}
/*
* 一直沿着右子树找 找到最右边的节点，该节点没有右子节点
*/
public static Node findMax(Node root) {
if(root==null)
return null;
while(root.right!=null) {
root=root.right;
}
return root;
}
2.4 寻找中序序列的前驱和后继
情形1：节点X的左右子节点都存在
对于BST中的一个节点X而言，中序序列中在该节点前面的是其左子树中的最大值，在该节点后面的是其右子树中的最小值
情形2：节点X的左子节点不存在（左子节点不存在只影响前驱）
X的前驱是其第一个左祖先节点
寻找过程：一直遍历X的父节点，直到遍历到的节点是某个节点Y的右子节点，则Y是前驱，如果找不到Y，说明X没有前驱，也即X是最小的
情形2：节点X的右子节点不存在（右子节点不存在只影响后继）
X的后继是其第一个右祖先节点
寻找过程：一直遍历X的父节点，直到遍历到的节点是某个节点Y的左子节点，则Y是后继，如果找不到Y，说明X没有后继，也即X是最大的
2.5 插入元素
public TreeNode insertIntoBST(TreeNode root, int val) {
if(root==null)
return new TreeNode(val);
if(root.val<val)
root.right=insertIntoBST(root.right, val);
else if(root.val>val)
root.left=insertIntoBST(root.left, val);
return root;
}
//先找到一个适合插入的位置 注意要用一个pre保存待插入位置的父节点
//之后设置父节点的左子节点或右子节点为新节点即可
public TreeNode insertIntoBST(TreeNode root, int val) {
if(root==null)
return new TreeNode(val);
TreeNode pre=null;
TreeNode newNode=new TreeNode(val);
TreeNode tmp=root;
while(tmp!=null) {
pre=tmp;
if(tmp.val<newNode.val)
tmp=tmp.right;
else if(tmp.val>newNode.val)
tmp=tmp.left;
}
if(pre.left==null&&pre.val>newNode.val)
pre.left=newNode;
else if(pre.right==null&&pre.val<newNode.val)
pre.right=newNode;
return root;
}
2.6 删除元素
情形1：被删除节点是叶子节点，直接删除，令待删除节点父节点的指针为null
情形二：被删除节点有一个子节点，将待删除节点的子节点返回给父节点
情形三：被删除节点有两个子节点，删除该节点，并用待删除节点左子树中的最大节点来代替被删除节点（也可以用待删除节点右子树中的最小节点来代替）
//存在左右子节点时 用左子树中的最大节点来替代待删除节点
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if(root==null)
return null;
if(root.val<key)
root.right=deleteNode(root.right, key);//去root的右子树中删除
else if(root.val>key)
root.left=deleteNode(root.left, key);//去root的左子树中删除
else if(root.val==key) {
if(root.left==null&&root.right==null)
return null;
else if(root.left==null)
return root.right;
else if(root.right==null)
return root.left;
else {//左子节点和右子节点都存在
TreeNode tmp=root;//保存指向target节点的引用
root=getMax(tmp.left);//root指向待删除节点左子树中的最大节点X
root.left=deleteMax(tmp.left);//X的左子树为去掉自己后的新子树
root.right=tmp.right;//将原来target节点的右子树连接到X上
}
}
return root;
}
/*
* 寻找以node为根节点的的树中的最大节点
*/
public TreeNode getMax(TreeNode node) {
if(node==null)
return null;
while(node.right!=null)
node=node.right;
return node;
}
/*
* 删除以node为根节点的的树中的最大节点
*/
public TreeNode deleteMax(TreeNode node) {
if(node.right==null)//没有右子节点 则node本身就是最小的
return node.left;
node.right=deleteMax(node.right);//递归删除
return node;
}
}
//存在左右子节点时 用右子树中的最小节点替代待删除节点
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if(root==null)
return null;
if(root.val<key)
root.right=deleteNode(root.right, key);//去root的右子树中删除
else if(root.val>key)
root.left=deleteNode(root.left, key);//去root的左子树中删除
else if(root.val==key) {
if(root.left==null&&root.right==null)
return null;
else if(root.left==null)
return root.right;
else if(root.right==null)
return root.left;
else {//左子节点和右子节点都存在
TreeNode tmp=root;//保存指向target节点的引用
root=getMin(tmp.right);//root指向待删除节点右子树中的最小节点X
root.right=deleteMin(tmp.right);//X的右子树为去掉自己后的新子树
root.left=tmp.left;//将原来target节点的左子树连接到X上
}
}
return root;
}
/*
* 寻找以node为根节点的的树中的最小节点
*/
public TreeNode getMin(TreeNode node) {
if(node==null)
return null;
while(node.left!=null)
node=node.left;
return node;
}
/*
* 删除以node为根节点的的树中的最小节点
*/
public TreeNode deleteMin(TreeNode node) {
if(node.left==null)//没有左子节点 则node本身就是最小的
return node.right;
node.left=deleteMin(node.left);//递归删除
return node;
}
}
2.7 验证二叉搜索树
class Solution {
int pre;
boolean flag=false;
public boolean isValidBST(TreeNode root) {
if(root==null)
return true;
if(!isValidBST(root.left))
return false;
if(flag&&root.val<=pre)//flag为true表示pre已经赋值过了
return false;
pre=root.val;
flag=true;
if(!isValidBST(root.right))
return false;
return true;
}
}
//O(n)
//O(1)
2.8 二叉搜索树转化为循环双向链表
从图中可以看出，next指针的指向的节点形成的序列是升序的，因此可以采用中序遍历来处理:
class Solution {
Node pre,head;
public Node treeToDoublyList(Node root) {
if(root==null)
return null;
dfs(root);
head.left=pre;//pre最后指向最后一个节点
pre.right=head;
return head;
}
public void dfs(Node cur){
if(cur==null)
return;
dfs(cur.left);
if(pre!=null)//cur==null的话说明当前cur是第一个节点 第一个节点没有pre
pre.right=cur;
else
head=cur;
cur.left=pre;
pre=cur;
dfs(cur.right);
}
}
2.9 有序数组转化为高度平衡的二叉搜索树
高度平衡：左右子树高度差小于1
public TreeNode sortedArrayToBST(int[] nums) {
return build(nums,0,nums.length-1);
}
public TreeNode build(int[] nums,int left,int right){
if(left>right){
return null;
}
int mid=left+(right-left)/2;//选择中间位置（靠左）
//left+(right-left+1)/2; 选择中间位置（靠右）
TreeNode root=new TreeNode(nums[mid]);
root.left=build(nums,left,mid-1);
root.right=build(nums,mid+1,right);
return root;
}
2.10 求二叉搜索树中第K小的节点
中序遍历+计数
class Solution {
int cnt=0;
int ans;
public int kthSmallest(TreeNode root, int k) {
dfs(root,k);
return ans;
}
public void dfs(TreeNode root,int k){
if(root==null)
return;
dfs(root.left,k);
cnt++;
if(cnt==k){
ans=root.val;
return;
}
dfs(root.right,k);
}
}
2.11 求二叉搜索树中第K大的节点
逆序中序遍历+计数
class Solution {
int cnt=0;
int ans;
public int kthLargest(TreeNode root, int k) {
dfs(root,k);
return ans;
}
public void dfs(TreeNode root,int k){
if(root==null)
return;
dfs(root.right,k);//先递归遍历右子树
cnt++;
if(cnt==k){
ans=root.val;
return;
}
dfs(root.left,k);
}
}
2.12 修剪BST，使得修剪后的树中的节点处于给定的范围
class Solution {
public TreeNode trimBST(TreeNode root, int low, int high) {
if(root==null)
return null;
if(root.val<low)//当前节点小于下界 则修剪后的树一定出现在右子树中
return trimBST(root.right,low,high);
if(root.val>high)//当前节点大于上界 则修剪后的树一定出现在左子树中
return trimBST(root.left,low,high);
//当前root节点在范围内 则修剪它的左右子树
root.left=trimBST(root.left,low,high);
root.right=trimBST(root.right,low,high);
return root;
}
}
3. AVL树概念
- 是一棵二叉搜索树
- 对任意节点X，其左子树和右子树高度差不超过1
当向AVL树中插入一个节点时，可能会导致某个节点形成的子树不平衡，假设不平衡的子树的根节点是X，则有以下几种情况：
情况1：在X的左节点的左子树中插入新节点（左左情况）
解决：需要右旋转：
节点p 右旋时，会携带自己的右子树，向右旋转到q 的右子树位置，q 的右子树被抛弃，此时p 右旋后左子树正好空闲，将q 的右子树放在p 的左子树位置，旋转后的树根为q
情况2：在X的右节点的右子树中插入新节点（右右情况）
解决：需要左旋转：节点p 左旋时，携带自己的左子树，向左旋转到q 的左子树位置，q 的左子树被抛弃，此时p 左旋后右子树正好空闲，将q 的左子树放在p 的右子树位置，旋转后的树根为q
情况3：在X的左节点的右子树中插入新节点（左右情况）
节点8是X节点，新节点是7
解决：先左旋再右旋
情况4：在X的右节点的左子树中插入新节点（右左情况）
节点4是X节点，新节点是5
解决：先右旋再左旋
情况整理：
4. AVL树代码实现
package datastructure.tree;
public class AVLTree {
private class Node{
int data;//节点值
int height;//某个节点形成子树的高度
Node left;//左孩子指针
Node right;//右孩子指针
Node(int data){
this.data=data;
this.height=1;
}
}
private Node root;//AVL树的根节点
public void insert(int data) {//插入一个节点
this.root=insert(this.root,data);
}
private Node insert(Node node,int item) {
//1 2 3处代码类似于BST的操作
if(node==null) {//找到了插入的位置 1
Node add=new Node(item);
return add;
}
if(node.data>item) {//2
node.left=insert(node.left,item);
}
if(node.data<item) {//3
node.right=insert(node.right,item);
}
//经过1 2 3 步 节点插入完成 下面需要判断是否平衡
//更新以node为节点的子树的高度
node.height=Math.max(height(node.left),height(node.right))+1;
int bf=bf(node);//以node为节点的子树的左右子树的高度差
//LL case 左左情况
//bf>1: node节点形成的子树左子树高
//item<node.left.data: 在node左子节点的左子树中添加的
if(bf>1&&item<node.left.data)
return rightRotate(node);//需要右旋
//RR case 右右情况
//bf<-1: node节点形成的子树右子树高
//item<node.left.data: 在node右子节点的右子树中添加的
if(bf<-1&&item>node.right.data)
return leftRotate(node);//需要左旋
//RL case 右左情况
//bf<-1: node节点形成的子树右子树高
//item<node.right.data: 在node右子节点的左子树中添加的
if(bf<-1&&item<node.right.data) {
node.right=rightRotate(node.right);//先右旋
return leftRotate(node);//再左旋
}
//LR case 左右情况
//bf>1: node节点形成的子树左子树高
//item>node.left.data: 在node左子节点的右子树中添加的
if(bf>1&&item>node.left.data) {
node.left=leftRotate(node.left);//先左旋
return rightRotate(node);//再右旋
}
return node;
}
//打印AVL树
public void display() {
this.display(this.root);
System.out.println(this.root.height);//输出高度
}
//打印AVL树
private void display (Node node) {
String str="";
if(node.left!=null)
str+=node.left.data+"=>";
else
str+="null=>";
str+=node.data+"";
if(node.right!=null)
str+="<="+node.right.data;
else
str+="<=null";
System.out.println(str);
if(node.left!=null)
display(node.left);
if(node.right!=null)
display(node.right);
}
private int height(Node node) {
if(node==null) {
return 0;
}
return node.height;//返回树高度
}
//获取node作为根节点的左右子树的高度差
private int bf(Node node) {
if(node==null)
return 0;
return height(node.left)-height(node.right);
}
/*
* 右旋的具体操作
* q是p的左子树
* 节点p右旋时，会携带自己的右子树，向右旋转到q的右子树位置，q 的右子树被抛弃，
* 此时p 右旋后左子树正好空闲，将q 的右子树放在p 的左子树位置，旋转后的树根为q
*/
private Node rightRotate(Node c) {
//对节点c进行右旋 c相当于上面解释的q
Node b=c.left;//b指向c的左子树 相当于上面解释的q
Node T3=b.right;//保存q的右子树
b.right=c;//p向右旋转到q的右子树位置
c.left=T3;//q的右子树连接到p的左子树上
c.height=Math.max(height(c.left),height(c.right))+1;
b.height=Math.max(height(b.left),height(b.right))+1;
return b;//b（q)成为旋转后的新根节点
}
/*
* 左旋的具体操作
* q是p的右子树
* 节点p左旋时，携带自己的左子树，向左旋转到q的左子树位置，q的左子树被抛弃，
* 此时p 左旋后右子树正好空闲，将q 的左子树放在p 的右子树位置，旋转后的树根为q
*/
private Node leftRotate(Node c) {
//对节点c进行右旋 c相当于上面解释的q
Node b=c.right;///b指向c的右子树 相当于上面解释的q
Node T3=b.left;//保存q的左子树
b.left=c;//p向右旋转到q的左子树位置
c.right=T3;//q的左子树连接到p的右子树上
c.height=Math.max(height(c.left),height(c.right))+1;//更新高度
b.height=Math.max(height(b.left),height(b.right))+1;
return b;//b（q)成为旋转后的新根节点
}
public static void main(String[] args) {
AVLTree tree=new AVLTree();
tree.insert(20);
tree.insert(25);
tree.insert(30);
tree.insert(10);
tree.insert(5);
tree.insert(15);
tree.insert(27);
tree.insert(19);
tree.insert(16);
tree.display();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
