链式存储二叉树

1 创建二叉树

节点

public class TreeNode {
    //节点的权
    int value;

    TreeNode leftNode;
    TreeNode rightNode;

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

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }
}

二叉树

public class BinaryTree {
    TreeNode root;

    public TreeNode getRoot() {
        return root;
    }

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

测试

public static void main(String[] args){
        //创建一棵树
        BinaryTree bt = new BinaryTree();
        //创建根节点
        TreeNode root = new TreeNode(1);
        bt.setRoot(root);
        TreeNode rootLeft = new TreeNode(2);
        root.setLeftNode(rootLeft);
        TreeNode rootRight = new TreeNode(3);
        root.setRightNode(rootRight);
    }

2 二叉树遍历

2.1 前序遍历

前中后是相对于根节点而言的。根节点–左节点–右节点，就是前序遍历。
关键代码就是TreeNode#frontShow()。

节点

public class TreeNode {
    //节点的权
    int value;

    TreeNode leftNode;
    TreeNode rightNode;

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

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    //前序遍历  递归思想
    // 1.先遍历当前节点；
    // 2.遍历左节点；
    // 3.遍历右节点
    public void frontShow() {
        System.out.println(value);
        if (leftNode != null) {
            leftNode.frontShow();
        }
        if (rightNode != null) {
            rightNode.frontShow();
        }
    }

    //中序遍历
    // 1.遍历左节点；
    // 2.遍历当前节点；
    // 3.遍历右节点
    public void midShow() {

        if (leftNode != null) {
            leftNode.frontShow();
        }
        System.out.println(value);

        if (rightNode != null) {
            rightNode.frontShow();
        }
    }
    //后序遍历
    // 1.遍历左节点；
    // 2.遍历右节点 ；
    // 3.遍历当前节点

    public void afterShow() {
        if (leftNode != null) {
            leftNode.frontShow();
        }

        if (rightNode != null) {
            rightNode.frontShow();
        }
        System.out.println(value);
    }
}

二叉树

public class BinaryTree {
    TreeNode root;

    public TreeNode getRoot() {
        return root;
    }

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

    public void frontShow() {
        root.frontShow();
    }

    public void midShow() {
        root.midShow();
    }

    public void afterShow() {
        root.afterShow();
    }
}

测试

public class TestBinary {
    public static void main(String[] args){
        //创建一棵树
        BinaryTree bt = new BinaryTree();
        //创建根节点
        TreeNode root = new TreeNode(1);
        bt.setRoot(root);
        TreeNode rootLeft = new TreeNode(2);
        root.setLeftNode(rootLeft);
        TreeNode rootRight = new TreeNode(3);
        root.setRightNode(rootRight);

        //第二层左节点设置子节点
        rootLeft.setLeftNode(new TreeNode(4));
        rootLeft.setRightNode(new TreeNode(5));

        //第二层右节点设置子节点
        rootRight.setLeftNode(new TreeNode(6));
        rootRight.setRightNode(new TreeNode(7));

        //前序遍历
        bt.frontShow();
        System.out.println("==============");
        //中序遍历
        bt.midShow();
        System.out.println("==============");
        bt.afterShow();
    }
}

##2.2 中序遍历
左节点–根节点—右节点，就是中序遍历。
代码在其前序遍历，
关键代码就是TreeNode#midShow()。

2.3 后序遍历

左节点—右节点–根节点，就是后序遍历。
代码在其前序遍历，
关键代码就是TreeNode#afterShow()。

2.4 二叉树中节点查找

节点查找可分为前序查找、中序查找、后续查找。根据前面的遍历，可以根据一个写出另外两个，所有只写一个谦虚查找：
关键代码

public TreeNode frontSearch(int i) {
        TreeNode target = null;
        if (this.value == i) {
            return this;
        } else {
            if (leftNode != null) {
                target = leftNode.frontSearch(i);
            }
            if (target != null) {
                if (rightNode != null) {
                    target = rightNode.frontSearch(i);
                }
            }
        }
        return target;
    }

2.5 二叉树中节点的删除

一般的二叉树，删除一个节点之后，其子节点（如果存在）也就一块删除了
关键代码

public class BinaryTree {
    TreeNode root;
//省略一部分代码
    public void delete(int i) {
        if (root.value == i){
            root = null;
        }else {
            root.delete(i);
        }
    }
}

public class TreeNode {
    //节点的权
    int value;

    TreeNode leftNode;
    TreeNode rightNode;
//省略一部分代码
    //删除一个子树
    public void delete(int i) {
        TreeNode parent = this;

        if (parent.leftNode != null && parent.leftNode.value == i) {
            parent.leftNode = null;
            return;
        }
        if (parent.rightNode != null && parent.rightNode.value == i) {
            parent.rightNode = null;
            return;
        }
        //递归检查并删除
        parent = leftNode;
        if (parent != null) {
            parent.delete(i);
        }
        parent = rightNode;
        if (parent != null) {
            parent.delete(i);
        }
    }
}

//测试
//删除一个子树
        bt.delete(5);