LeetCode107 Binary Tree Level Order Traversal II

详细见：leetcode.com/problems/binary-tree-level-order-traversal-ii

Java Solution: github

package leetcode;import java.util.Iterator;/* * Given a binary tree, return the bottom-up level order *  traversal of its nodes' values. (ie, from left to right, *   level by level from leaf to root).For example:Given binary tree [3,9,20,null,null,15,7],    3   / \  9  20    /  \   15   7return its bottom-up level order traversal as:[  [15,7],  [9,20],  [3]] */import java.util.LinkedList;import java.util.List;import java.util.Queue;import tools.TreeNode辅助.TreeNode;public class P107_BinaryTreeLevelOrderTraversalII {static int N = Integer.MIN_VALUE;public static void main(String[] args) {TreeNode root = null;List<List<Integer>> ans = null;root = tools.TreeNode辅助.A_生成满二叉树(new int[] {1,2, 3,4, 5, 6, 7});root = tools.TreeNode辅助.A_生成满二叉树(new int[] {3,9, 20,N, N, 15, 7});root = tools.TreeNode辅助.A_生成满二叉树(new int[] {3});ans = new Solution().levelOrderBottom(root);System.out.println(ans.size());Iterator<List<Integer>> it = ans.iterator();while (it.hasNext()) {tools.Utils.B_打印List_Integer_OneLine(it.next());}}/* * AC * 3 ms */static class Solution {List<List<Integer>> ans = new LinkedList<>();    public List<List<Integer>> levelOrderBottom(TreeNode root) {        if (root == null) {        return ans;        }    Queue<TreeNode> q1 = new LinkedList<TreeNode>();    Queue<Integer> q2 = new LinkedList<Integer>();    q1.add(root);    q2.add(1);    int pre_int = -1;    List<Integer> list_root = null;        while (! q1.isEmpty()) {        TreeNode root_now = q1.poll();        int root_int = q2.poll();        if (root_int != pre_int) {        if (pre_int != - 1) {        ans.add(0, list_root);        }        pre_int = root_int;        list_root = new LinkedList<>();        }        list_root.add(root_now.val);        if (root_now.left != null) {        q1.add(root_now.left);        q2.add(root_int + 1);        }        if (root_now.right != null) {        q1.add(root_now.right);        q2.add(root_int + 1);        }        }        if (pre_int != -1 && list_root != null) {        ans.add(0, list_root);        }    return ans;    }}}

C Solution: github

/*    url: leetcode.com/problems/binary-tree-level-order-traversal-ii    AC 3ms 28.85%*/#include <stdio.h>#include <stdlib.h>struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;};typedef struct TreeNode * ptn;typedef struct TreeNode stn;typedef int* T;typedef struct al sal;typedef struct al * pal;struct al {    int capacity;    int size;    T* arr;};pal al_init(int capacity) {    pal l = (pal) malloc(sizeof(sal));    if (capacity < 1) return NULL;    l->arr = (T*) malloc(sizeof(T) * capacity);    l->capacity = capacity;    l->size = 0;    return l;}void al_expand_capacity(pal l) {    T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));    int i = 0;    for (i = 0; i < l->capacity; i ++)        new_arr[i] = l->arr[i];    free(l->arr);    l->arr = new_arr;    l->capacity = l->capacity * 2 + 1;}void al_add_last(pal l, T v) {    if (l->capacity == l->size) al_expand_capacity(l);    l->arr[l->size] = v;    l->size ++;}void al_free_all(pal l) {    int i = 0;    for (i = 0; i < l->size; i ++)        free(l->arr[i]);    free(l->arr);    free(l);}T* al_convert_to_array_free_l(pal l) {    T* arr = l->arr;    free(l);    return arr;}typedef ptn V;typedef struct sl ssl;typedef struct sl * psl;struct sl {    int capacity;    int size;    V* arr;};psl sl_init(int capacity) {    psl l = (psl) malloc(sizeof(ssl));    if (capacity < 1) return NULL;    l->arr = (V*) malloc(sizeof(V) * capacity);    l->capacity = capacity;    l->size = 0;    return l;}void sl_expand_capacity(psl l) {    V* new_arr = (V*) malloc(sizeof(V) * (l->capacity * 2 + 1));    int i = 0;    for (i = 0; i < l->capacity; i ++)        new_arr[i] = l->arr[i];    free(l->arr);    l->arr = new_arr;    l->capacity = l->capacity * 2 + 1;}void sl_add_last(psl l, V v) {    if (l->capacity == l->size) sl_expand_capacity(l);    l->arr[l->size] = v;    l->size ++;}void sl_free_all(psl l) {    free(l->arr);    free(l);}void swap_psl(psl* l1, psl* l2) {    psl l = *l1;    *l1 = *l2;    *l2 = l;}void swap_int_star(int** a, int** b) {    int* c = *a;    *a = *b;    *b = c;}void reverse(pal l) {    int i = 0, j = l->size - 1;    while (i < j) {        swap_int_star(&(l->arr[i]), &(l->arr[j]));        i ++;        j --;    }}int** levelOrderBottom(ptn n, int** cn, int* rn) {    psl l1 , l2 ;    int i = 0, i2 = 0, *t = NULL;     pal l = NULL, ln = NULL;    if (n == NULL) return NULL;    l1 = sl_init(16);    l2 = sl_init(16);    l = al_init(16);    ln = al_init(16);    sl_add_last(l1, n);    while (l1->size != 0) {        t = (int*) malloc(sizeof(int) * l1->size);        for (i = 0; i < l1->size; i ++)            t[i] = l1->arr[i]->val;        al_add_last(l, t);        t = (int*) malloc(sizeof(int) * 1);        t[0] = l1->size;        al_add_last(ln, t);        l2->size = 0;        for (i = 0; i < l1->size; i ++) {            if (l1->arr[i]->left != NULL)                sl_add_last(l2, l1->arr[i]->left);            if (l1->arr[i]->right != NULL)                sl_add_last(l2, l1->arr[i]->right);        }        swap_psl(&l1, &l2);    }    sl_free_all(l1);    sl_free_all(l2);    *cn = (int*) malloc(sizeof(int) * ln->size);    for (i = 0; i < ln->size; i ++)        (*cn)[ln->size - 1- i] = ln->arr[i][0];    al_free_all(ln);    *rn = l->size;    reverse(l);    return al_convert_to_array_free_l(l);}

Python Solution: github

#coding=utf-8'''    url: leetcode.com/problems/binary-tree-level-order-traversal-ii    @author:     zxwtry    @email:      [e-mail]    @date:       2017年4月28日    @details:    Solution: 56ms 59.43%'''class TreeNode(object):    def __init__(self, x):        self.val = x        self.left = None        self.right = Noneclass Solution(object):    def levelOrderBottom(self, n):        """        :type n: TreeNode        :rtype: List[List[int]]        """        if n == None: return []        ans, l = [], [n]        while len(l) != 0:            ans.append([nn.val for nn in l])            ll = []            for nn in l:                if nn.left != None: ll.append(nn.left)                if nn.right != None: ll.append(nn.right)            l = ll        ans.reverse()        return ans