树的遍历基础

树的遍历基础

这里强推一篇博客：https://blog.youkuaiyun.com/chinesekobe/article/details/110874773

• 树的深度遍历
  • 先序：逆时针跑
  • 中序：垂直剪影
  • 后序：逆时针跑并剪葡萄
• 树的广度遍历
  • 层次遍历

直接上代码吧

package com.ws.leetcode.august;

import java.util.Stack;

/**
 * @author 王顺
 * @description
 * @date 2022/8/18
 */
public class TreeTest {
    public static void main(String[] args) {
        //[4,2,7,1,3,6,9]
        TreeNode treeNode = new TreeNode(4, new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(7, new TreeNode(6), new TreeNode(9)));
        TreeTest treeTest = new TreeTest();

        //先序递归  4213769
        treeTest.PreOrder(treeNode);
        System.out.println("\n");

        //先序-栈
        treeTest.PreOrderWithStack(treeNode);

        //中序递归
        treeTest.InnerOrder(treeNode);

        //后序递归
        System.out.println("\n");
        treeTest.AfterOrder(treeNode);
    }

    //先序遍历--递归
    public void PreOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        System.out.print(treeNode.val);
        PreOrder(treeNode.left);
        PreOrder(treeNode.right);
    }
   

    //中序遍历--递归
    public void InnerOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        InnerOrder(treeNode.left);
        System.out.print(treeNode.val);
        InnerOrder(treeNode.right);
    }

    //后续遍历--递归
    //先将根结点压入栈，然后根结点出栈并访问根结点，而后依次将根结点的右孩子、左孩子入栈，直到栈为空为止。
    public void AfterOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        AfterOrder(treeNode.left);
        AfterOrder(treeNode.right);
        System.out.print(treeNode.val);
    }

    //先序遍历--栈
    //1. 根节点放入  2.出栈，并放入出栈节点的右，左子树  3.出栈 放入当前出栈节点的右，左子树
    public void PreOrderWithStack(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(treeNode);
        while (!stack.empty()) {
            TreeNode innerNode = stack.pop();
            System.out.print(innerNode.val);
            //这里要注意是右子树先进栈，因为先序要先访问左子树，而栈是先进后出，所以右子树先进，后出
            if (innerNode.right != null) {
                stack.push(innerNode.right);
            }
            if (innerNode.left != null) {
                stack.push(innerNode.left);
            }
        }
    }

    //中序遍历--栈
    //中序遍历需要先将父节点压入栈，然后压入左节点，这是一个循环的步骤，
    //直到左子树为空才停止压栈，此时需要弹出栈进行遍历该节点(可以看成父节点，左节点为空)，遍历完后再将该节点的右节点作为右子树的父节点，
    //重复前面步骤，直到整个栈为空即可完成每个节点中序遍历。
    public void InnerOrderWithStack(TreeNode treeNode) {
        Stack<TreeNode> stack = new Stack();
        TreeNode node = treeNode;
        while (node != null || !stack.isEmpty()) {
            //这个if将所有的左子树都push进了栈，这个if结束后，只剩下右子树没有push了
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                //从栈里取出节点，作为右节点的根，然后输出
                TreeNode tem = stack.pop();
                System.out.print(tem.val + "->");
                node = tem.right;
            }
        }
    }

    //后序遍历--栈--太复杂了，这里就不cv了，cv也记不住
    public void AfterOrderWithOrder(TreeNode treeNode) {

    }
}





//树节点的定义：
package com.ws.leetcode.august;


/**
 * @Author: wangshun
 * @date: 2022/8/17 10:36
 * @Description:
 * @Version: 1.0
 */
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {
    }
    TreeNode(int val) {
        this.val = val;
    }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}