利用二叉树实现节点的遍历、查找、删除等操作

1.说明

	这里删除某个节点时，不考虑规则，删除以这个节点为跟的整个子树

2.代码实现

1.节点

public class BinaryTreeNodes {
    private int id; // 节点id
    private String name; // 节点名字
    private BinaryTreeNodes left; // 节点的左指针
    private BinaryTreeNodes right; // 节点的右指针

    public BinaryTreeNodes() {
    }

    public BinaryTreeNodes(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BinaryTreeNodes getLeft() {
        return left;
    }

    public void setLeft(BinaryTreeNodes left) {
        this.left = left;
    }

    public BinaryTreeNodes getRight() {
        return right;
    }

    public void setRight(BinaryTreeNodes right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "BinaryTreeNodes{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    // 前序遍历
    public void PreOrder() {
        // 先遍历当前节点
        System.out.println(this);
        // 递归遍历左子树
        if (this.left != null) {
            this.left.PreOrder();
        }
        // 递归遍历右子树
        if (this.right != null) {
            this.right.PreOrder();
        }
    }
    // 中序遍历
    public void MidOrder() {
        // 先遍历当前节点的左子树
        if (this.left != null) {
            this.left.MidOrder();
        }
        // 遍历当前节点
        System.out.println(this);
        // 遍历右子树
        if (this.right != null) {
            this.right.MidOrder();
        }

    }
    // 后序遍历
    public void PostOrder() {
        // 先遍历当前节点的左子树
        if (this.left != null) {
            this.left.PostOrder();
        }
        // 再遍历当前节点的右子树
        if (this.right != null) {
            this.right.PostOrder();
        }
        // 遍历当前节点
        System.out.println(this);
    }
    // 删除指定节点
    public void DelNodes(int id){
        // 左子树删除
        if(this.left != null && this.left.id == id){
            this.left = null;
        }
        // 右子树删除
        if(this.right != null && this.right.id == id){
            this.right = null;
        }
        // 左子树递归删除
        if(this.left != null){
            this.left.DelNodes(id);
        }
        // 右子树递归删除
        if(this.right != null){
            this.right.DelNodes(id);
        }
    }

    /**
     * 先序遍历查找
     * 根据节点id查找某个节点
     *
     * @param id 传入的节点id
     * @return 如果找到，返回这个节点，否则返回null
     */
    public BinaryTreeNodes PreOrderSearch(int id) {
        // 如果找到，则返回当前节点
        if (this.id == id) {
            return this;
        }
        BinaryTreeNodes resNodes = null; // 标记位
        // 左子树递归
        if (this.left != null) {
            resNodes = this.left.PreOrderSearch(id);
        }
        if (resNodes != null) {
            return resNodes;
        }   // 左子树找到
        // 右子树递归
        if (this.right != null) {
            resNodes = this.right.PreOrderSearch(id);
        }
        return resNodes;
    }

    /**
     * 中序遍历查找
     * 根据节点id查找某个节点
     *
     * @param id 传入的节点id
     * @return 如果找到，返回这个节点，否则返回null
     */
    public BinaryTreeNodes MidOrderSearch(int id) {
        BinaryTreeNodes resNodes = null;
        // 先遍历查找当前节点的左子树
        if (this.left != null) {
            resNodes = this.left.MidOrderSearch(id);
        }
        if (resNodes != null) {
            return resNodes;
        }       // 左子树的中序遍历完成
        // 和当前节点比较
        if (this.id == id) {
            return this;
        }
        // 最后中序遍历右子树
        if (this.right != null) {
            resNodes = this.right.MidOrderSearch(id);
        }
        return resNodes;
    }
    /**
     * 后序遍历查找
     * 根据节点id查找某个节点
     *
     * @param id 传入的节点id
     * @return 如果找到，返回这个节点，否则返回null
     */
    public BinaryTreeNodes PostOrderSearch(int id) {
        BinaryTreeNodes resNodes = null;
        // 先后序遍历左子树
        if (this.left != null) {
            resNodes = this.left.PostOrderSearch(id);
        }
        if (resNodes != null) {
            return resNodes;
        }    // 左子树后序遍历完成
        if (this.right != null) {
            resNodes = this.right.PostOrderSearch(id);
        }
        if (resNodes != null) {
            return resNodes;
        }  // 右子树后序遍历完成
        // 和当前节点比较
        if (this.id == id) {
            return this;
        }
        return resNodes;
    }
}

2.二叉树

public class BinaryTree {
    public BinaryTreeNodes root; // 二叉树的根节点

    public BinaryTree() {
    }

    public BinaryTree(BinaryTreeNodes root) {
        this.root = root;
    }

    public void setRoot(BinaryTreeNodes root) {
        this.root = root;
    }

    // 先序遍历
    public void PreOrderTraverse() {
        if (this.root != null) {
            this.root.PreOrder();
        } else {
            System.out.println("二叉树为空,无法先序遍历");
        }
    }

    // 中序遍历
    public void MidOrderTraverse() {
        if (this.root != null) {
            this.root.MidOrder();
        } else {
            System.out.println("二叉树为空，无法中序遍历");
        }
    }
    // 后序遍历
    public void PostOrderTraverse() {
        if (this.root != null) {
            this.root.PostOrder();
        } else {
            System.out.println("二叉树为空，无法后序遍历");
        }
    }
    // 删除指定节点
    public void DelNode(int id) {
        if (root != null) {
            if (root.getId() == id) {
                root = null;
            }else {
                root.DelNodes(id);
            }
        } else {
            System.out.println("树为空，无法删除");
        }
    }
    // 先序遍历查找
    public BinaryTreeNodes PreOrderSearch(int id) {
        if (root != null) {
            return root.PreOrderSearch(id);
        } else {
            return null;
        }
    }
    // 中序遍历查找
    public BinaryTreeNodes MidOrderSearch(int id) {
        if (root != null) {
            return root.MidOrderSearch(id);
        } else {
            return null;
        }
    }
    // 后序遍历查找
    public BinaryTreeNodes PostOrderSearch(int id) {
        if (root != null) {
            return root.PostOrderSearch(id);
        } else {
            return null;
        }
    }
}

3.入口

package binaryTreeTraverse;

/**
 * @program: 8.二叉树的相关操作
 * @description: 入口函数
 * @author: Zhou Jian
 * @create: 2020-07-18 15:00
 */
public class input {
    public static void main(String[] args) {
        // 创建一个二叉树
        BinaryTree Tree = new BinaryTree();
        // 手动创建二叉树的节点
        BinaryTreeNodes root = new BinaryTreeNodes(1, "宋江");
        BinaryTreeNodes N1 = new BinaryTreeNodes(2, "林冲");
        BinaryTreeNodes N2 = new BinaryTreeNodes(3, "鲁智深");
        BinaryTreeNodes N3 = new BinaryTreeNodes(4, "武松");
        BinaryTreeNodes N4 = new BinaryTreeNodes(5, "李逵");
        // 将创建的节点添加到二叉树中
        Tree.setRoot(root);
        // 构造二叉树
        root.setLeft(N1);
        root.setRight(N2);
        N1.setLeft(N3);
        N1.setRight(N4);

        //先序遍历
        System.out.println("先序遍历的结果:");
        Tree.PreOrderTraverse();
//        // 中序遍历
//        System.out.println("中序遍历的结果:");
//        Tree.MidOrderTraverse();
//        // 后序遍历
//        System.out.println("后序遍历的结果:");
//        Tree.PostOrderTraverse();

        // 先序遍历查找
//        System.out.println("先序遍历查找:");
//        BinaryTreeNodes resNodes = Tree.PreOrderSearch(4);
//        if (resNodes != null) {
//            System.out.printf("您找到的节点信息为:id=%d,name=%s", resNodes.getId(), resNodes.getName());
//        } else {
//            System.out.printf("没有找到id=%d的节点", 4);
//        }
        // 删除指定节点
        Tree.DelNode(3);
        System.out.println("删除后:");
        Tree.PreOrderTraverse();
    }
}