LintCode:二叉树的层次遍历

LintCode:二叉树的层次遍历

方法一：二叉树的层序遍历，需要借助两个队列空间。

Python

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""


"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""


class Solution:
    """
    @param root: The root of binary tree.
    @return: Level order in a list of lists of integers
    """
    def levelOrder(self, root):
        # write your code here
        if root == None:
            return []

        L1 = []
        L2 = []
        L1.append([root.val])
        if root.left != None:
            L2.append(root.left)
        if root.right != None:
            L2.append(root.right)
        m = 1

        while(len(L2) != 0):
            n = len(L2)
            L1.append([])
            for i in range(n):
                if L2[0].left != None:
                    L2.append(L2[0].left)
                if L2[0].right != None:
                    L2.append(L2[0].right)
                L1[m].append(L2[0].val)
                L2.remove(L2[0])
            m += 1

        return L1

方法二：

题目要求只用一个队列实现，可以考虑把L2放在L1的某个位置，最后再删除就可以了。

Python

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""


class Solution:
    """
    @param root: The root of binary tree.
    @return: Level order in a list of lists of integers
    """
    def levelOrder(self, root):
        # write your code here
        if root == None:
            return []

        L1 = []
        L1.append([root.val])
        L1.append([])
        if root.left != None:
            L1[1].append(root.left)
        if root.right != None:
            L1[1].append(root.right)
        m = 2

        while(len(L1[1]) != 0):
            n = len(L1[1])
            L1.append([])
            for i in range(n):
                if L1[1][0].left != None:
                    L1[1].append(L1[1][0].left)
                if L1[1][0].right != None:
                    L1[1].append(L1[1][0].right)
                L1[m].append(L1[1][0].val)
                L1[1].remove(L1[1][0])
            m += 1
        L1.remove(L1[1])
        return L1

Java

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */


public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Level order a list of lists of integer
     */
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write your code here
        if(root == null){
            return new ArrayList<ArrayList<Integer>>();
        }

        LinkedList<LinkedList<TreeNode>> L = new LinkedList<LinkedList<TreeNode>>();
        L.add(new LinkedList());
        L.get(0).add(root);
        L.add(new LinkedList());

        if(root.left != null){
            L.get(1).add(root.left);
        }

        if(root.right != null){
            L.get(1).add(root.right);
        }
        int m = 2;

        while(L.get(1).size() != 0){
            int n = L.get(1).size();
            L.add(new LinkedList());
            for(int i=0; i<n; i++){
                if(L.get(1).get(0).left != null){
                    L.get(1).add(L.get(1).get(0).left);
                }
                if(L.get(1).get(0).right != null){
                    L.get(1).add(L.get(1).get(0).right);
                }
            L.get(m).add(L.get(1).get(0));
            L.get(1).remove(L.get(1).get(0));
            }
            m += 1;
        }
        ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();

        for(int i=0; i<L.size(); i++){
            ans.add(new ArrayList<Integer>());
            for(int j=0; j<L.get(i).size(); j++){
                ans.get(i).add(L.get(i).get(j).val);
            }
        }
        ans.remove(1);
        return ans;
    }
}