数据结构与算法单排日记-2020/4/1-树 & 二叉树遍历

前序遍历: 先输出父节点，再遍历左子树，再遍历右子树
中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
小结: 看输出父节点的顺序，就确定是前序，中序还是后序

树节点：

public class TreeNode {
    private int num;//节点标号
    private String name;//节点信息
    private TreeNode left; //左节点
    private TreeNode right;//右节点

    //构造方法
    public TreeNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    //setter和getter
    public int getNum() {
        return num;
    }

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

    public String getName() {
        return name;
    }

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

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

    //toString
    @Override
    public String toString() {
        return "TreeNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

遍历

public class BinaryTree {
    public static void main(String[] args) {
        //创建节点
        TreeNode node1 = new TreeNode(1, "节点1");
        TreeNode node2 = new TreeNode(2, "节点2");
        TreeNode node3 = new TreeNode(3, "节点3");
        TreeNode node4 = new TreeNode(4, "节点4");
        TreeNode node5 = new TreeNode(5, "节点5");

        //创建树
        /*
         *         1
         *    2       3
         *4      5
         * */
        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);

        System.out.println("前序遍历========================");
        preOrder(node1);
        System.out.println("中序遍历========================");
        infixOrder(node1);
        System.out.println("后序遍历========================");
        postOrder(node1);
    }

    //前序遍历,递归
    public static void preOrder(TreeNode node) {
        //先输出父节点，
        System.out.println(node.toString());
        // 再遍历左子树，
        if (node.getLeft() != null) {
            preOrder(node.getLeft());
        }
        // 再遍历右子树
        if (node.getRight() != null) {
            preOrder(node.getRight());
        }
    }

    //中序遍历,递归
    public static void infixOrder(TreeNode node) {
        // 先遍历左子树，
        if (node.getLeft() != null) {
            infixOrder(node.getLeft());
        }
        //再输出父节点，
        System.out.println(node.toString());
        // 再遍历右子树
        if (node.getRight() != null) {
            infixOrder(node.getRight());
        }
    }


    //后序遍历,递归
    public static void postOrder(TreeNode node) {
        // 先遍历左子树，
        if (node.getLeft() != null) {
            postOrder(node.getLeft());
        }
        // 再遍历右子树
        if (node.getRight() != null) {
            postOrder(node.getRight());
        }
        //再输出父节点，
        System.out.println(node.toString());
    }
}