链式存储之遍历二叉树

二叉树遍历

前序遍历：首先遍历根节点，接着遍历左子树，最后遍历右子树。

中序遍历：首先遍历左子树，接着遍历根节点，最后遍历右子树。

后序遍历：首先遍历左子树，接着遍历右子树，最后遍历根节点。

遍历思想：依据前序、中序、后序遍历的特点，使用递归，依次对二叉树的根节点、左子树和右子

树进行遍历。

如上图所示：

前序遍历：1 2 4 5 3 6 7

中序遍历：4 2 5 1 6 3 7

后序遍历：4 5 2 6 7 3 1

代码展示

package demo5;

public class BinaryTree {

    TreeNode root;

    //设置根节点
    public void setRoot(TreeNode root){
        this.root = root;
    }

    //获取根节点
    public TreeNode getRoot(){
        return root;
    }

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

    public void midShow() {
        if(root!=null){
             root.midShow();
        }
    }

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

package demo5;

public class TreeNode {
    //节点的权
    int value;
    //左儿子
    TreeNode leftNode;
    //右儿子
    TreeNode rightNode;

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

    //设置左儿子
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    //设置右儿子
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    //前序遍历
    public void frontShow() {
        //先遍历当前节点的内容
        System.out.print(value+" ");
        //左节点
        if(leftNode!=null){
            leftNode.frontShow();
        }
        //右节点
        if(rightNode!=null){
            rightNode.frontShow();
        }
    }

    //中序遍历
    public void midShow() {
        //左节点
        if(leftNode!=null){
            leftNode.midShow();
        }
        //当前节点
        System.out.print(value+" ");
        //右节点
        if(rightNode!=null){
            rightNode.midShow();
        }
    }

    //后序遍历
    public void afterShow() {
        //左节点
        if(leftNode!=null){
            leftNode.afterShow();
        }
        //右节点
        if(rightNode!=null){
            rightNode.afterShow();
        }
        //当前节点
        System.out.print(value+" ");
    }
}

package demo5;

public class TestBinaryTree {

    public static void main(String[] args) {
        //创建一棵树
        BinaryTree binaryTree = new BinaryTree();
        //创建一个根节点
        TreeNode root = new TreeNode(1);
        //把根节点赋给树
        binaryTree.setRoot(root);
        //创建一个左节点
        TreeNode rootL = new TreeNode(2);
        //把新创建的节点设置为根节点的子节点
        root.setLeftNode(rootL);
        //创建一个右节点
        TreeNode rootR = new TreeNode(3);
        //把新创建的节点设置为根节点的子节点
        root.setRightNode(rootR);
        //为第二层的左节点创建两个子节点
        rootL.setLeftNode(new TreeNode(4));
        rootL.setRightNode(new TreeNode(5));
        //为第二层的右节点创建两个子节点
        rootR.setLeftNode(new TreeNode(6));
        rootR.setRightNode(new TreeNode(7));
        //前序遍历树
        System.out.print("前序遍历：");
        binaryTree.frontShow();
        System.out.println();
        //中序遍历树
        System.out.print("中序遍历：");
        binaryTree.midShow();
        System.out.println();
        //后序遍历树
        System.out.print("后序遍历：");
        binaryTree.afterShow();
        System.out.println();
    }
}