代码随想录 第14天 | ● 理论基础 ● 递归遍历 ● 迭代遍历 ● 统一迭代

二叉树的定义：

public  class TreeNode{
        int val;
        TreeNode Left;
        TreeNode Right;
        TreeNode(){}
            TreeNode( int val){
            this.val = val;
            }

            public TreeNode(int val, TreeNode left, TreeNode right) {
                this.val = val;
                Left = left;
                Right = right;
            }
        }

递归遍历：

递归三部曲：1.确定递归函数的参数和返回值

　　　　　　2.确定终止条件

　　　　　　3，确定单层递归的逻辑

前中后序遍历：只是换的代码顺序。前中后说的是中心根目录的存在顺序。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root,res);
        return res;
        }
        void traversal(TreeNode root,List res){
            if( root  == null){
                return ;
            }else {//前序
                res.add(root.val);//中
                traversal(root.left,res);//左
                traversal(root.right,res);//右
            }
        }

    }

em，代码确实不难理解。怎么这么简单？

非递归遍历：

是空就取栈顶，不是空就添加

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

 

由于是栈模拟的递归，所以后序遍历并不像递归那样直接换顺序就行，还要将数组倒换。因为是栈，数组倒换也就是将数据放入另一个栈中出来的顺序才是对的。

顺序就死记硬背吧。