数据结构-二叉搜索树

数据结构-二叉搜索树

1.查找

给定一个值key，在二叉搜索树中查找

class SearchTreeDemo{
    static class  TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val){
            this.val=val;
        }

    }
    //创建根节点
       public TreeNode root ;

    //    给定一个值key，在二叉搜索树中查找
    public TreeNode findKey(int key){
        TreeNode cur =root;
       while (cur!=null){
           if (cur == null){
               return null;
           }
           if (key>cur.val){
               cur = cur.left;
           }
           if (key<cur.val){
               cur = cur.right;
           }
       }
        return cur;
    }
}

2.插入

在二叉树中插入一个值

class SearchTreeDemo{
	public void insertKey(int key){
//给这个需要插入的值创建一个结点
        TreeNode treeNode = new TreeNode(key);
// 当插入之前，二叉树为空时，插入的这个结点就是root根节点
        if (root == null){
            root = treeNode;
            return;
        }
//定义一个parent结点，当cur==null时,就可插入到parent.left/parent.right
        TreeNode parent = null;
        TreeNode cur = root;
        while (cur!=null){
            if (key>cur.val){
                parent =cur;
                cur = cur.right;
            }else if (key == cur.val){
                return;
            }else {
                parent =cur;
                cur =cur.left;
            }
        }
        if (key>parent.val){
            parent.right = treeNode;
        }else {
            parent.left = treeNode;
        }
    }
}

3.删除

class SearchTreeDemo{
 //    删除一个节点之前要先找到这个结点
    public void remove(int key){
        TreeNode parent = root;
        TreeNode cur = root;
        while (cur!=null){
            if (key>cur.val){
                parent =cur;
                cur = cur.right;
            }else if (key == cur.val){
//           这里是找到了要删除的结点
            deletKey(parent,cur);
            return;
            }else {
                parent =cur;
                cur =cur.left;
            }
        }
    }
/*    二叉树的删除：写一个方法deletKey用于删除操作
      parent:要删除的结点的父节点
      cur:要删除的结点
      大类分三种情况：cur.left==null/cur.right==null/cur.right!=null&&cur.left!=null
 */
    public void deletKey(TreeNode parent, TreeNode cur){
        if (cur.left==null){
//            分三种情况：cur==root   /   cur==parent.left   /  cur==parent.right
            if (cur==root ){
                root = cur.right;
            }
            if (cur==parent.left){
                parent.left=cur.right ;
            }
            if (cur==parent.right){
                parent.right=cur.right ;
            }
        }else if (cur.right==null){
//            分三种情况：cur==root   /   cur==parent.left   /  cur==parent.right
            if (cur == root ){
                root = cur.left;
            }
            if (cur==parent.left){
                parent.left=cur.left ;
            }
            if (cur==parent.right){
                parent.right=cur.left ;
            }
        }else {
/*      cur两边都不为空，此时有两种方法：
        ① 去cur当前结点的左树的右树当中找最大值，用这个最大值替换掉cur
        ② 去cur当前结点的右树的左树当中找最小值，用这个最小值替换掉cur
 */
//     此处使用第二种方法：当tar走到一个左孩子为空的结点，那这个结点就是最小值
            TreeNode tp =cur;
            TreeNode tar = cur.right;
            while (tar.left!=null){
                tp = tar;
                tar = tar.left;
            }
//           当tar.left==null时，说明找到了最小值结点
            cur.val = tar.val;//用最小值覆盖掉要删除的值
            if (tar==tp.left){
                tp.left = tar.right;
            }
            if (tar==tp.right){
                tp.right = tar.right;
            }
        }
    }

}

二叉搜索树习题

第一题 找第k小元素

• 题目链接
  二叉搜索树中找第k小的数

• 题目描述：

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）

• 输入输出

输入：root = [3,1,4,null,2], k = 1
输出：1

• 题目分析

1. BST本身就是有序的，中序遍历即是升序
2. 求第k小元素，即中序中找第K个元素
3. 不用递归，采用循环中序遍历的方式

• 运行代码

class Solution {
    public int kthSmallest(TreeNode root, int k) {
        if(root==null || k<=0){
            return -1;
        }
        Stack<TreeNode> st = new Stack<>();
       while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            --k;
            if (k == 0) {
                break;
            }
            root = root.right;
        }
        return root.val;
    }
}