算法 - 01二叉树三种遍历算法

二叉数遍历的三种方法

• 前序遍历，对树中的任意结点来说，先打印这个结点，然后前序遍历它的左子树，最后前序遍历它的右子树。
• 中序遍历，对树中的任意结点来说，先中序遍历它的左子树，然后打印这个结点，最后中序遍历它的右子树。
• 后序遍历，对树中的任意结点来说，先后序遍历它的左子树，然后后序遍历它的右子树，最后打印它本身。

package algorithm.tree;

import lombok.Data;

/**
 * @author Demon-HY
 * @description 树节点
 * @date 2020/7/12 17:23
 */
@Data
public class BinaryTreeNode<T> {

    /**
     * 保存数据
     */
    private T value;

    /**
     * 左子节点
     */
    private BinaryTreeNode<T> leftChildNode;

    /**
     * 右子节点
     */
    private BinaryTreeNode<T> rightChildNode;

    public BinaryTreeNode(T value) {
        this.value = value;
    }
}

package algorithm.tree;

/**
 * @author Demon-HY
 * @description 测试二叉树三种遍历方法
 * @date 2020/7/12 17:26
 */
public class BinaryTreeNodeErgodicTest {

    public static void main(String[] args) {
        BinaryTreeNode<String> rootNode = buildTree();

        //先序遍历
        System.out.println("--------------------- 先序 ---------------------");
        preOrderTraverse(rootNode); // A B D E C F G
        System.out.println();
        System.out.println("--------------------- 先序 ---------------------");

        // 中序遍历
        System.out.println("--------------------- 中序 ---------------------");
        inOrderTraverse(rootNode); // D B E A F C G
        System.out.println();
        System.out.println("--------------------- 中序 ---------------------");

        // 后序遍历
        System.out.println("--------------------- 后序 ---------------------");
        postOrderTraverse(rootNode); // D E B F G C A
        System.out.println();
        System.out.println("--------------------- 后序 ---------------------");
    }

    // 先序遍历
    public static void preOrderTraverse(BinaryTreeNode<String> node) {
        if (node == null) {
            return;
        }
        System.out.print(node.getValue() + " ");
        preOrderTraverse(node.getLeftChildNode());
        preOrderTraverse(node.getRightChildNode());
    }

    // 中序遍历
    public static void inOrderTraverse(BinaryTreeNode<String> node) {
        if (node == null) {
            return;
        }
        inOrderTraverse(node.getLeftChildNode());
        System.out.print(node.getValue() + " ");
        inOrderTraverse(node.getRightChildNode());
    }

    // 后序遍历
    public static void postOrderTraverse(BinaryTreeNode<String> node) {
        if (node == null) {
            return;
        }
        postOrderTraverse(node.getLeftChildNode());
        postOrderTraverse(node.getRightChildNode());
        System.out.print(node.getValue() + " ");
    }

    // 构建一个树
    private static BinaryTreeNode<String> buildTree() {
        BinaryTreeNode<String> nodeA = new BinaryTreeNode<String>("A");
        BinaryTreeNode<String> nodeB = new BinaryTreeNode<String>("B");
        BinaryTreeNode<String> nodeC = new BinaryTreeNode<String>("C");
        BinaryTreeNode<String> nodeD = new BinaryTreeNode<String>("D");
        BinaryTreeNode<String> nodeE = new BinaryTreeNode<String>("E");
        BinaryTreeNode<String> nodeF = new BinaryTreeNode<String>("F");
        BinaryTreeNode<String> nodeG = new BinaryTreeNode<String>("G");

        nodeA.setLeftChildNode(nodeB);
        nodeA.setRightChildNode(nodeC);

        nodeB.setLeftChildNode(nodeD);
        nodeB.setRightChildNode(nodeE);

        nodeC.setLeftChildNode(nodeF);
        nodeC.setRightChildNode(nodeG);

        return nodeA;
    }
}