二叉树的前中后序遍历，以及节点的查找，节点的级联删除简单小实例

二叉树的前中后序遍历，以及节点的查找，节点的级联删除

注意：

public treenode getnode(treenode root, int pos) {
    treenode temp = null;
    if (root == null) {
        System.out.println("二叉树为空");
        return null;
    }else {
        if (root.getNum()==pos) {
            return root;
        }
        if (root.getLeft() != null) {
            temp = getnode(root.getLeft(), pos);
        }
        if (root.getRight() != null&&temp == null) {
            temp = getnode(root.getRight(), pos);
        }
    }
    return temp;
}

不可以在递归的时候直接return

而是定义一个中间变量进行保存

如果直接return的话可能访问不到右子树就直接返回了

package com.hebut.liyiwei.tree;

import com.sun.source.tree.BinaryTree;


/**
 * @className: BinaryTreeDemo
 * @author: Liyiwei
 * @date: 2024/10/28 下午4:12
 * @Version: 1.0
 * @description: tree
 */

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTreeNode binaryTree = new BinaryTreeNode();
        treenode root = new treenode(1, "root");
        treenode dog = new treenode(2, "dog");
        treenode cat = new treenode(3, "cat");
        treenode cow = new treenode(4, "cow");
        treenode pig = new treenode(5, "pig");
        root.setLeft(dog);
        root.setRight(cat);
        cat.setLeft(cow);
        cat.setRight(pig);
        binaryTree.setRoot(root);
        binaryTree.mypreOrder(root);
        System.out.println("=========================");
        binaryTree.mymidOrder(root);
        System.out.println("=========================");
        binaryTree.mypostOrder(root);
        System.out.println("=========================");
        binaryTree.mygetnode(3);
        System.out.println("=========================");
        binaryTree.mydeletenode(3);
        System.out.println("=========================");
        binaryTree.mypreOrder(root);
    }
}

class BinaryTreeNode {
    private treenode root;
    public BinaryTreeNode() {}
    public BinaryTreeNode(treenode root) {
        this.root = root;
    }
    public treenode getRoot() {
        return root;
    }
    public void setRoot(treenode root) {
        this.root = root;
    }

    public void mypreOrder(treenode root) {

        root.preOrder(root);
    }
    public void mymidOrder(treenode root) {

        root.midOrder(root);
    }
    public void mypostOrder(treenode root) {

        root.postOrder(root);
    }
    public void mygetnode( int index) {
        treenode getnode = root.getnode(root, index);
        if (getnode == null) {
            System.out.println("没有找到");
        }else {
            System.out.println(getnode.toString());
        }
    }
    public void mydeletenode(int index) {
        if(root!=null&&root.getNum()==index){
            root=null;
        }else {
            root.deletenode(root,index);
        }
    }
}

class treenode{
    private int num;
    private String text;
    private treenode left;
    private treenode right;

    public treenode(int num, String text) {
        this.num = num;
        this.text = text;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    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;
    }

    @Override
    public String toString() {
        return "treenode{" +
                "num=" + num +
                ", text='" + text + '\'' +
                '}';
    }

    public void preOrder(treenode root) {
        if (root != null) {
            System.out.println(root);
        }else {
            System.out.println("二叉树为空");
        }
        if (root.getLeft() != null) {
            preOrder(root.getLeft());
        }
        if (root.getRight() != null) {
            preOrder(root.getRight());
        }
    }

    public void midOrder(treenode root) {
        if (root.getLeft() != null) {
            midOrder(root.getLeft());
        }
        if (root != null) {
            System.out.println(root);
        }else {
            System.out.println("二叉树为空");
        }
        if (root.getRight() != null) {
            midOrder(root.getRight());
        }
    }
    public void postOrder(treenode root) {
        if (root.getLeft() != null) {
            postOrder(root.getLeft());
        }
        if (root.getRight() != null) {
            postOrder(root.getRight());
        }
        if (root != null) {
            System.out.println(root);
        }else {
            System.out.println("二叉树为空");
        }
    }
    public treenode getnode(treenode root, int pos) {
        treenode temp = null;
        if (root == null) {
            System.out.println("二叉树为空");
            return null;
        }else {
            if (root.getNum()==pos) {
                return root;
            }
            if (root.getLeft() != null) {
                temp = getnode(root.getLeft(), pos);
            }
            if (root.getRight() != null&&temp == null) {
                temp = getnode(root.getRight(), pos);
            }
        }
        return temp;
    }

    public void deletenode(treenode root, int pos) {
        if (root == null) {
            System.out.println("二叉树为空");
            return;
        }
        if (root.getLeft()!=null&&root.getLeft().getNum()==pos) {
            root.setLeft(null);
        }
        if (root.getRight()!=null&&root.getRight().getNum()==pos) {
            root.setRight(null);
        }
        if (root.getLeft()!=null){
            deletenode(root.getLeft(),pos);
        }
        if (root.getRight()!=null){
            deletenode(root.getRight(),pos);
        }



    }
}