144. 二叉树的先序遍历

1. 题目描述

题目链接

给定一个二叉树，返回它的 前序 遍历。

示例:

输入: [1,null,2,3]

1

\

2

/

3

输出: [1,2,3]

2. 题目分析

先序遍历二叉树顺序是，先遍历根节点，然后遍历左孩子，最后遍历右孩子，遍历有两种实现方式，一种是递归实现，一种是非递归实现。

• 递归实现：简单、易理解，但吃内存，了解jvm的内存分配模型的同学一定知道，递归方法，每一次递归，都需要在虚拟机栈中保存当前方法的出口、入口、局部变量等，这些会占用大量的内存，然后就容易出现oom问题（内存泄漏），所以一般开发环境会禁止使用比较深的递归。从而采用动态规划那种备忘录形式的非递归实现。
• 非递归实现：非递归实现，需要解决备忘录的数据结构，根据遍历节点时的先进后出的顺序特点，所以采用栈结构暂时存储已经得到的节点。

3. 解决思路

• 递归实现：递归很好理解的原因是，递归只需要关注两个点，一是递归结束标志，而是当前节点的遍历方式；把每一个当前节点都看作是根节点，那么获取到当前节点的值，然后遍历遍历左孩子，最后遍历右孩子，这样就实现了整颗二叉树的遍历。
• 非递归实现：使用栈存储已经得到的节点。

4. 代码实现（java）

• 递归实现

/**
     * 先序遍历:递归实现
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal_1(TreeNode root) {
        List<Integer> result= new ArrayList<>();
        if (root == null){
            return result;
        }
        return preorderTraversalWithRecursion(root,result);
    }

    /**
     * 先序遍历的递归实现方法
     * @param root
     * @param result
     * @return
     */
    public List<Integer> preorderTraversalWithRecursion(TreeNode root,List<Integer> result) {
        if (root == null){
            return result;
        }
        result.add(root.val);
        preorderTraversalWithRecursion(root.left,result);
        preorderTraversalWithRecursion(root.right,result);
        return result;
    }
           

• 非递归实现

package com.algorithm.leetcode.binarytree;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

/**
 * Created by 凌 on 2018/12/9.
 */
public class BTree {
    //表示空节点
    public static final int FLAG = -1;

    public static void main(String[] args) {
        BTree bTree = new BTree();
        TreeNode root = null;
        System.out.println("按先序遍历，输入所有节点值：");
        root = bTree.buildBTree(root);
//        List<Integer> result = bTree.inorderTraversal(root);
//        List<Integer> result = bTree.preorderTraversal(root);
        List<Integer> result = bTree.postorderTraversal(root);
        for(Integer val: result){
            System.out.printf(val + "\t");
        }
        System.out.println("");
    }
    /**
     * 先序遍历构建二叉树:1 2 -1 4 -1 -1 3 5 -1 -1 -1
     *       1
     *      / \
     *     2   3
     *     \   /
     *     4  5
     * @param treeNode
     * @return
     */
    public TreeNode buildBTree(TreeNode treeNode){
        //递归建树二叉树
        Scanner input = new Scanner(System.in);
        int val = input.nextInt();
        //用FLAG区分没有子结点的情况
        if (val != FLAG) {
            treeNode=new TreeNode(val);
            treeNode.left=buildBTree(treeNode.left);
            treeNode.right=buildBTree(treeNode.right);
        }
        return treeNode;
    }

    /**
     * 先序遍历
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result= new ArrayList<>();
        if (root == null){
            return result;
        }
        TreeNode node = root;
        Stack<TreeNode> stack =new Stack<>();

        while (node != null || !stack.isEmpty()){
            //找到最左叶子节点
            if (node != null){
                result.add(node.val);
                stack.push(node);
                node = node.left;
            }else{
                node = stack.pop();
                node = node.right;
            }
        }
        return result;
    }
}

class TreeNode {
    int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
}