把二叉树打印成多行

题目描述：从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

 

public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

思路一：

import java.util.ArrayList;
import java.util.LinkedList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {

        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null)
            return res;

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(pRoot);

        while (!queue.isEmpty())
        {
            int start = 0;
            int end = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            while (start++ < end)
            {
                TreeNode node  = queue.poll();
                if (node != null)
                    list.add(node.val);
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
            }
            res.add(list);
        }
        return res;
    }
}

另一种写法：

import java.util.ArrayList;
import java.util.LinkedList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null)
            return res;

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(pRoot);
        ArrayList<Integer> list =new ArrayList<>();

        int start = 0;
        int end = 1;

        while (!queue.isEmpty())
        {
            TreeNode node = queue.poll();
            start++;
            if (node != null)
                list.add(node.val);
            if (node.left != null)
                queue.add(node.left);
            if (node.right != null)
                queue.add(node.right);
            if (start == end)
            {
                if (!list.isEmpty())
                    res.add(list);
                start = 0;
                end = queue.size();
                list = new ArrayList<>();
            }
        }
        return res;
    }
}

思路二：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null)
            return res;

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(null);
        queue.add(pRoot);
        ArrayList<Integer> list =new ArrayList<>();


        while (queue.size() > 1)
        {
            TreeNode node = queue.poll();
            if (node == null)
            {
                Iterator<TreeNode> iter = queue.iterator();
                while (iter.hasNext())
                    list.add(iter.next().val);
                res.add(new ArrayList<>(list));
                list.clear();
                queue.add(null);
                continue;
            }
            if (node.left != null)
                queue.add(node.left);
            if (node.right != null)
                queue.add(node.right);
        }
        return res;
    }
}

思路三：

两个队列交替打印

import java.util.ArrayList;
import java.util.LinkedList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {

        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null)
            return res;

        LinkedList<TreeNode> q1 = new LinkedList<>();
        q1.add(pRoot);
        LinkedList<TreeNode> q2 = new LinkedList<>();

        while (!q1.isEmpty() || !q2.isEmpty())
        {
            ArrayList<Integer> list = new ArrayList<>();
            while (!q1.isEmpty())
            {
                TreeNode tmp = q1.poll();
                if (tmp != null)
                    list.add(tmp.val);
                if (tmp.left != null)
                    q2.add(tmp.left);
                if (tmp.right != null)
                    q2.add(tmp.right);
            }
            if (!list.isEmpty())
            {
                res.add(list);
                list = new ArrayList<>();
            }
            while (!q2.isEmpty())
            {
                TreeNode tmp2 = q2.poll();
                if (tmp2 != null)
                    list.add(tmp2.val);
                if (tmp2.left != null)
                    q1.add(tmp2.left);
                if (tmp2.right != null)
                    q1.add(tmp2.right);
            }
            if (!list.isEmpty())
            {
                res.add(list);
                list = new ArrayList<>();
            }
        }
        return res;
    }
}

思路四：递归

import java.util.ArrayList;

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {

        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (pRoot == null)
            return res;
        depth(pRoot, 1, res);
        return res;
    }
    private void depth(TreeNode root, int depth, ArrayList<ArrayList<Integer>> lists)
    {
        if (root == null)
            return;
        if (depth > lists.size())
            lists.add(new ArrayList<>());
        lists.get(depth - 1).add(root.val);
        depth(root.left, depth + 1, lists);
        depth(root.right, depth + 1, lists);
    }
}