二叉树的前序遍历、中序遍历、后序遍历及应用

二叉树的前序遍历、中序遍历、后序遍历及应用

概念

遍历严格来说有四类
DLR、DRL、LDR、RDL、LRD、RLD
D：根节点
L：左子节点
R：右子节点
但我们一般只讨论DLR LDR LRD三种，其他三种实现方法类似

import javax.swing.tree.TreeNode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 遍历严格来说有四类
 * DLR、DRL、LDR、RDL、LRD、RLD
 * 但我们一般只讨论DLR LDR LRD三种，其他三种实现方法类似
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class PreMidPostOrder {
     

    //递归先序遍历 根、左、右
    public static void preOrder(TreeNode root){
     
        if(root == null) return;
        list.add(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }
    //递归中序遍历 左、根、右
    public static void midOrder(TreeNode root){
     
        if(root == null) return;
        list.add(root.val);
        midOrder(root.left);
        midOrder(root.right);
    }
    //递归后续遍历 左、右、根
    public static void postOrder(TreeNode root){
     
        if(root == null) return;
        list.add(root.val);
        postOrder(root.left);
        postOrder(root.right);
    }



    public static LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
    public static List<Integer> list = new ArrayList();

    //中序迭代
    public static List<Integer> midOrderD(TreeNode root){
     
        while(true){
     
            while(root != null){
     
                stack.push(root.val);
                root = root.left;
            }
            if(stack.isEmpty()){
     
                return list;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
    }

}

应用

LeetCode：二叉树的中序遍历（中等难度）
本文提供了两种方式，一种的递归实现，一种是运用迭代的方式
分析：递归方法简介明了，但树太深是容易导致栈溢出，数据量较大的情况下推荐使用迭代方法
通过代码如下，运行时间0ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
     

    private List<Integer> list;
    private LinkedList<TreeNode> stack;

    public List<Integer> inorderTraversal(TreeNode root) {
     
        list = new ArrayList();
        stack = new LinkedList();
        // midOrder(root);
        midOrderD(root);
        return list;
    }

    //中序遍历递归算法
    // public void midOrder(TreeNode root){
     
    //     if(root == null){
     
    //         return;
    //     }
    //     midOrder(root.left);
    //     list.add(root.val);
    //     midOrder(root.right);
    // }

    //中序遍历迭代算法
    public void midOrderD(TreeNode root){
     
        while(true){
     
            while(root != null){
     
                stack.push(root);
                root = root.left;
            }
            if(stack.isEmpty()){
     
                return;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
    }
}