二叉搜索树

二叉搜索树：BST，又叫二叉查找树、二叉排序树

特点

1、结点的左儿子值小于结点的值，结点的右儿子值大于结点值

2、树中结点的值都不相同

3、一个结点的左子树必小于该结点右子树中的任何结点

4、不是一棵完全二叉树，常用链表来实现

操作

1、查找

从根结点开始，判断查找值与当前结点值的大小。若查找值大于当前结点值，则搜索当前结点的右儿子；若查找值小于当前结点值，则搜索当前结点的左儿子；若查找值等于当前结点值，则查找结束。

2、插入

从根结点开始，判断插入值与当前结点值的大小。若插入值大于当前结点值，判断右儿子是否存在，若右儿子为空，则在此插入，否则转向当前结点的右儿子；若插入值小于当前结点值，判断左儿子是否存在，若左儿子为空，则在此插入，否则转向当前结点的左儿子

3、删除

思想：利用特点3，将待删除结点的左子树指向待删除结点的右子树的最左结点，然后将待删除结点的父节点的儿子结点（判断是左儿子还是右儿子）指向待删除结点的右儿子

（1）待删除结点没有右儿子，则将右儿子指向左儿子进行操作

（2）待删除结点是根结点，没有父结点，直接将树的根结点指向待删除结点的右儿子，移动待删除结点的左子树

如下图所示

Java实现

package com.company;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;
class TreeNode{
    int data;
    TreeNode left;
    TreeNode right;
}
class Tree{
    TreeNode root;
    public void insert(int data){
        if(root == null){
            TreeNode node = new TreeNode();
            node.data=data;
            root = node;
            return ;
        }
        TreeNode now = root;
        while(now!=null){
            if(data == now.data){// data has existed
                System.out.println(String.valueOf(data)+" has existed");
                return ;
            }
            if (data < now.data) {
                if (now.left != null) {
                    now = now.left;
                } else {
                    TreeNode node = new TreeNode();
                    node.data=data;
                    now.left = node;
                    break;
                }
            } else {
                if (now.right != null) {
                    now = now.right;
                } else {
                    TreeNode node = new TreeNode();
                    node.data=data;
                    now.right = node;
                    break;
                }
            }
        }
    }
    public TreeNode find(int data){
        TreeNode now = root;
        while(now!=null){
            if(data > now.data)
                now = now.right;
            else if(data < now.data)
                now = now.left;
            else
                return now;
        }
        return null;
    }
    public TreeNode findParent(int data){
        TreeNode now=root;
        TreeNode parent=null;
        while(now!=null){
            if(now.data==data)
                return parent;
            if(now.data<data){
                parent=now;
                now=now.right;
            }else{
                parent=now;
                now=now.left;
            }
        }
        return null;
    }
    public void delete(int data){
        TreeNode node = find(data);
        TreeNode parent = findParent(data);
        if(node == null)// data doesn't exist
            return ;
        TreeNode index = node.right;
        if(index==null) {
            node.right=node.left;
        }else {
            while (index.left != null)
                index = index.left;
            index.left = node.left;
        }
        if(node==root){
            root=node.right;
        }else{
            if(parent.left==node)
                parent.left=node.right;
            else
                parent.right=node.right;
        }
        return ;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Tree tree = new Tree();
        int num = input.nextInt();
        for (int i = 0; i < num; i++) {
            int data = input.nextInt();
            tree.insert(data);
        }
        while(true) {
            int c = input.nextInt();
            num = input.nextInt();
            if(num == -1)
                break;
            if(c==0)
                System.out.println(tree.find(num));
            else
                tree.delete(num);
        }
    }
}