LeetCode_144：二叉树的前序遍历

1、题目描述：

2、思路：

前序遍历：先遍历跟节点，然后前序遍历左子树，前序遍历右子树
由于遍历后的数据需要存放在集合中，因此每次递归传入一个list集合，重载方法。

3、递归方法实现：

（1）节点类Node：

public class Node {
    int val;
    Node left;
    Node right;
    Node(int val){
        this.val = val;
    }
}

（2）二叉树类 Solution ：

class Solution {

    public Node root;

    public void setRoot(Node root) {
        this.root = root;
    }

    public List<Integer> preorderTraversal(Node root) {
        List<Integer> list = new ArrayList<>();
        if(root==null){
            return list;
        }
        //利用preorderTraversal，每次递归传入相同的list
        preorderTraversal(root, list);
        return list;
    }

    // 利用preorderTraversal，加 list 条件
    private void preorderTraversal(Node root, List<Integer> list) {
        list.add(root.val);
        if (root.left != null) {
            preorderTraversal(root.left, list);
        }
        if (root.right != null) {
            preorderTraversal(root.right, list);
        }
    }
}

（3）Main测试类：

public class Main {
    public static void main(String[] args) {
        Node node = new Node(3);
        Node node1 = new Node(9);
        Node node2 = new Node(20);
        Node node3 = new Node(15);
        Node node4 = new Node(7);

        Solution binaryTree = new Solution();

        binaryTree.setRoot(node);
        node.left = node1;
        node.right = node2;
        node2.left = node3;
        node2.right = node4;

        List<Integer> integers = binaryTree.preorderTraversal(node);
        System.out.println(integers);
    }
}

[3, 9, 20, 15, 7]

4、LeetCode解答：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if(root == null) return list;
        //借助preorderTraversal每次递归传入一个相同的list
        preorderTraversal(root, list);
        return list;
    }
    
    public List<Integer> preorderTraversal(TreeNode root, List<Integer> list) {
        
        list.add(root.val);
        if(root.left != null)
            preorderTraversal(root.left, list);
        if(root.right != null)
            preorderTraversal(root.right, list);
        
        return list;
    }
}