二叉树遍历

二叉树节点

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

/**
 * @program: sorttest
 * @description: 二叉树节点
 * @author: zhaozhenwei
 * @create: 2021-03-27 18:39
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;
}

工程使用lombok插件

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
 </dependencies>

二叉树遍历代码

package com.zzw.tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @program: sorttest
 * @description: 二叉树遍历
 * @author: zhaozhenwei
 * @create: 2021-03-27 18:37
 **/
public class Ergodic {

    public static void main(String[] args) {
        Ergodic ergodic = new Ergodic();
        TreeNode rootNode = ergodic.createTree();
        System.out.println("----------------------先序遍历----------------------");
        ergodic.preorderErgodic(rootNode);
        System.out.println("----------------------中序遍历----------------------");
        ergodic.middleOrderErgodic(rootNode);
        System.out.println("----------------------后序遍历----------------------");
        ergodic.afterOrderErgodic(rootNode);
    }

    /**
     * 后序遍历
     *      左节点 -> 右节点 -> 跟节点
     * 目前了解的处理：递归、栈
     * @param rootTreeNode
     */
    public void afterOrderErgodic(TreeNode rootTreeNode) {
        List<TreeNode> treeNodesByRecursion = new ArrayList<>();
        List<TreeNode> treeNodesByStack = new ArrayList<>();

        afterOrderErgodicByRecursion(rootTreeNode, treeNodesByRecursion);
        System.out.print("递 归：");
        treeNodesByRecursion.forEach(x -> System.out.print(x.getValue() + " "));

        System.out.println();

        afterOrderErgodicByRecursion(rootTreeNode, treeNodesByStack);
        System.out.print("非递归：");
        treeNodesByStack.forEach(x -> System.out.print(x.getValue() + " "));
        System.out.println();
    }

    /**
     *
     * 使用递归遍历二叉树
     * @param rootTreeNode  当前遍历二叉树的根节点
     * @param treeNodes     用来存放已经遍历的节点
     */
    private void afterOrderErgodicByRecursion(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        // 遍历左节点
        afterOrderErgodicByRecursion(rootTreeNode.getLeft(), treeNodes);
        // 遍历右节点
        afterOrderErgodicByRecursion(rootTreeNode.getRight(), treeNodes);
        // 根节点不为空的时候，将根节点放入到对应序列中
        treeNodes.add(rootTreeNode);
    }

    /**
     * 非递归参考：https://blog.csdn.net/aijxb/article/details/105799283
     * @param rootTreeNode
     * @param treeNodes
     */
    private void afterOrderErgodicByStack(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        // 当前访问节点
        TreeNode currentNode = rootTreeNode;
        // 使用该节点表示上次访问的节点
        TreeNode prev = null;
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        stack.push(currentNode);
        while (!stack.isEmpty()) {
            while (null != currentNode.getLeft()) {
                currentNode = currentNode.getLeft();
                stack.push(currentNode);
            }

            // 当前节点的右节点为空，或者右节点刚访问过，则说明当前节点的子结点已经访问完
            if (null == currentNode.getRight() || currentNode.getRight().equals(prev)) {
                treeNodes.add(currentNode);
                prev = currentNode;
                stack.removeFirst();
            } else {
                // 如果当前节点的右节点不为空，并且没有访问过，则访问右节点
                currentNode = currentNode.getRight();
            }
        }
    }


    /**
     * 中序遍历
     *      左节点 -> 跟节点 -> 右节点
     * 目前了解的处理：递归、栈
     * @param rootTreeNode
     */
    public void middleOrderErgodic(TreeNode rootTreeNode) {
        List<TreeNode> treeNodesByRecursion = new ArrayList<>();
        List<TreeNode> treeNodesByStack = new ArrayList<>();

        middleOrderErgodicByRecursion(rootTreeNode, treeNodesByRecursion);
        System.out.print("递 归：");
        treeNodesByRecursion.forEach(x -> System.out.print(x.getValue() + " "));

        System.out.println();

        middleOrderErgodicByStack(rootTreeNode, treeNodesByStack);
        System.out.print("非递归：");
        treeNodesByStack.forEach(x -> System.out.print(x.getValue() + " "));
        System.out.println();
    }

    /**
     * 使用递归遍历二叉树
     * @param rootTreeNode  当前遍历二叉树的根节点
     * @param treeNodes     用来存放已经遍历的节点
     */
    private void middleOrderErgodicByRecursion(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        // 遍历左节点
        middleOrderErgodicByRecursion(rootTreeNode.getLeft(), treeNodes);
        // 根节点不为空的时候，将根节点放入到对应序列中
        treeNodes.add(rootTreeNode);
        // 遍历右节点
        middleOrderErgodicByRecursion(rootTreeNode.getRight(), treeNodes);
    }


    /**
     * 非递归参考：https://blog.csdn.net/azl397985856/article/details/105591938
     *
     * 使用栈辅助遍历二叉树
     * @param rootTreeNode  当前遍历二叉树的根节点
     * @param treeNodes     用来存放已经遍历的节点
     */
    private void middleOrderErgodicByStack(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        TreeNode currentNode = rootTreeNode;
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        while (!stack.isEmpty() || null != currentNode) {
            while (null != currentNode) {
                stack.addFirst(currentNode);
                currentNode = currentNode.getLeft();
            }
            if (!stack.isEmpty()) {
                currentNode = stack.removeFirst();
                treeNodes.add(currentNode);
                currentNode = currentNode.right;
            }
        }
    }

    /**
     * 先序遍历
     *      跟节点 -> 左节点 -> 右节点
     * 目前了解的处理：递归、栈
     * @param rootTreeNode
     */
    public void preorderErgodic(TreeNode rootTreeNode) {
        List<TreeNode> treeNodesByRecursion = new ArrayList<>();
        List<TreeNode> treeNodesByStack = new ArrayList<>();

        preorderErgodicByRecursion(rootTreeNode, treeNodesByRecursion);
        System.out.print("递 归：");
        treeNodesByRecursion.forEach(x -> System.out.print(x.getValue() + " "));

        System.out.println();

        preorderErgodicByStack(rootTreeNode, treeNodesByStack);
        System.out.print("非递归：");
        treeNodesByStack.forEach(x -> System.out.print(x.getValue() + " "));

        System.out.println();
    }

    /**
     * 使用递归遍历二叉树
     * @param rootTreeNode  当前遍历二叉树的根节点
     * @param treeNodes     用来存放已经遍历的节点
     */
    private void preorderErgodicByRecursion(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        // 根节点不为空的时候，将根节点放入到对应序列中
        treeNodes.add(rootTreeNode);
        // 遍历左节点
        preorderErgodicByRecursion(rootTreeNode.getLeft(), treeNodes);
        // 遍历右节点
        preorderErgodicByRecursion(rootTreeNode.getRight(), treeNodes);
    }

    /**
     * 使用栈辅助遍历二叉树
     * @param rootTreeNode  当前遍历二叉树的根节点
     * @param treeNodes     用来存放已经遍历的节点
     */
    private void preorderErgodicByStack(TreeNode rootTreeNode, List<TreeNode> treeNodes) {
        if (null == rootTreeNode) {
            return;
        }
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        stack.push(rootTrÅeeNode);
        while (!stack.isEmpty()) {
            TreeNode node = stack.removeFirst();
            treeNodes.add(node);
            if (null != node.getRight()) {
                stack.addFirst(node.getRight());
            }
            if (null != node.getLeft()) {
                stack.addFirst(node.getLeft());
            }

        }

    }


    public TreeNode createTree() {
        TreeNode node01 = new TreeNode(); node01.setValue(1);
        TreeNode node02 = new TreeNode(); node02.setValue(2);
        TreeNode node03 = new TreeNode(); node03.setValue(3);
        TreeNode node04 = new TreeNode(); node04.setValue(4);
        TreeNode node05 = new TreeNode(); node05.setValue(5);
        TreeNode node06 = new TreeNode(); node06.setValue(6);
        TreeNode node07 = new TreeNode(); node07.setValue(7);
        TreeNode node08 = new TreeNode(); node08.setValue(8);
        TreeNode node09 = new TreeNode(); node09.setValue(9);
        TreeNode node10 = new TreeNode(); node10.setValue(10);
        TreeNode node11 = new TreeNode(); node11.setValue(11);
        node01.setLeft(node02);
        node01.setRight(node03);

        node02.setLeft(node04);
        node02.setRight(node05);

        node03.setLeft(node06);
        node03.setRight(node07);

        node04.setLeft(node08);
        node04.setRight(node09);

        node05.setLeft(node10);
        node05.setRight(node11);

        return node01;
    }
}