二叉排序树的查找、插入、删除，最大值、最小值

查找递归实现

查找非递归实现

查找最小值的递归实现

查找最大值的非递归实现

向二叉排序树中插入结点

删除节点

下面代码，拿去即可运行：

package leetcode;
 
public class TreeNode {
 
    private Integer value;
    private TreeNode left;
    private TreeNode right;
 
 
    public TreeNode() {
    }
 
    public TreeNode(Integer value) {
        this.value=value;
    }
 
    public TreeNode(Integer value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }
 
    public Integer getValue() {
        return value;
    }
 
    public void setValue(Integer value) {
        this.value = value;
    }
 
    public TreeNode getLeft() {
        return left;
    }
 
    public void setLeft(TreeNode left) {
        this.left = left;
    }
 
    public TreeNode getRight() {
        return right;
    }
 
    public void setRight(TreeNode right) {
        this.right = right;
    }
}

package tree;

import leetcode.TreeNode;

import java.util.Objects;


public class SortTree {
    public static void main(String[] args) {
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        //TreeNode treeNode6 = new TreeNode(6);
        treeNode4.setRight(treeNode5);
        treeNode2.setLeft(treeNode1);
        treeNode3.setLeft(treeNode2);
        treeNode3.setRight(treeNode4);

        InOrderTraversal(treeNode3);
        insertTreeNode( 6,treeNode3);
        System.out.println("====================");
        InOrderTraversal(treeNode3);

    }

    // 查找递归实现
    public static Boolean Find(Integer X, TreeNode treeNode) {

        if (treeNode == null) { // 如果根结点为空，返回 null
            return false;
        }

        if (X < treeNode.getValue()) {// 比根结点小，去左子树查找
            return Find(X, treeNode.getLeft());
        } else if (X > treeNode.getValue()) {// 比根结点大，去右子树查找
            return Find(X, treeNode.getRight());
        } else if (treeNode.getValue().equals(X)) { // 找到了
            return true;
        }
        return null;
    }


    // 查找非递归实现
    static TreeNode IterFind(Integer X, TreeNode treeNode) {
        while (treeNode != null) {
            if (X < treeNode.getValue())
                treeNode = treeNode.getLeft();
            else if (treeNode.getValue() < X)  // 比根结点大，去右子树查找
                treeNode = treeNode.getRight();
            else if (treeNode.getValue() == X) // 找到了
                return treeNode;
        }
        return null;
    }

    // 查找最小值的递归实现
    static TreeNode FindMin(TreeNode treeNode) {
        if (treeNode == null) {// 如果为空了，返回 null
            return null;
        } else if (treeNode.getLeft() != null)   // 还存在左子树，沿左分支继续查找
            return FindMin(treeNode.getLeft());
        else  // 找到了 
            return treeNode;
    }

    // 查找最大值的非递归实现
    static TreeNode FindMax(TreeNode treeNode) {
        if (treeNode != null)  // 如果不空
            while (treeNode.getRight() != null)   // 只要右子树还存在
                treeNode = treeNode.getRight();
        return treeNode;
    }

    /***向二叉排序树中插入结点*********/

    public static void insertTreeNode( Integer key,TreeNode root) {
        TreeNode insertNode = new TreeNode(key);
        while (root != null) {
            if (key < root.getValue()) {
                if (root.getValue() != null) {
                    root = root.getLeft();
                } else {
                    root.setLeft(insertNode);
                    return;
                }
            } else if (key > root.getValue()) {
                if (root.getRight() != null) {
                    root = root.getRight();
                } else {
                    root.setRight(insertNode);
                    return;
                }
            } else {
                throw new RuntimeException("插入节点值已经存在");
            }
        }
    }
    /***********删除*************/
    TreeNode Delete(Integer X, TreeNode treeNode) {
        TreeNode tmp;
        if (treeNode == null) {
            System.out.println("要删除的元素未找到");
        } else if (X < treeNode.getValue())   // X 比当前结点值小，在左子树继续查找删除
            treeNode.setLeft(Delete(X, treeNode.getLeft()));
        else if (treeNode.getValue() < X)   // X 比当前结点值大，在右子树继续查找删除
            treeNode.setRight(Delete(X, treeNode.getRight()));
        else {  //  找到被删除结点
            if (treeNode.getLeft() != null && treeNode.getRight() != null) {  // 被删除结点有俩孩子结点
                tmp = FindMin(treeNode.getRight());   // 找到右子树中值最小的
                treeNode.setValue(tmp.getValue());     // 用找到的值覆盖当前结点
                treeNode.setRight(Delete(tmp.getValue(), treeNode.getRight()));    // 把前面找到的右子树最小值结点删除
            } else {  // 被删除结点只有一个孩子结点或没有孩子结点
                tmp = treeNode;
                if (Objects.isNull(treeNode.getLeft()) && Objects.isNull(treeNode.getRight()))  // 没有孩子结点
                    treeNode = null;
                else if (treeNode.getLeft() != null && Objects.isNull(treeNode.getRight()))  // 只有左孩子结点
                    treeNode = treeNode.getLeft();
                else if (Objects.isNull(treeNode.getLeft()) && treeNode.getRight() != null)  // 只有右孩子结点
                    treeNode = treeNode.getRight();
            }
        }
        return treeNode;
    }
    /*********中序遍历*************/
    static void InOrderTraversal(TreeNode treeNode) {
        if (treeNode != null) {
            InOrderTraversal(treeNode.getLeft());  // 进入左子树 
            System.out.println(treeNode.getValue());// 打印根
            InOrderTraversal(treeNode.getRight());  // 进入右子树 
        }
    }

}

做此记录，方便日后复习看，同时也希望对你有些帮助