LeetCode Binary Tree Level Order Traversal

大家好，我是刘天昊，这次带来的是树的题目

发现自己树的题目po上来的不多（实际上还没能融汇贯通-  。 -）

先来一个简答的树的层次遍历吧

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3   / \  9  20    /  \   15   7

return its level order traversal as:

[  [3],  [9,20],  [15,7]]

题目就是层次遍历

说下层次遍历的思路吧虽然记在我的笔记本上但是这也是一个朋友博客上的（然而我找不到了贴不了他的地址了，原谅我）

1.根结点放入队列

2.队列非空时执行3-5

3.出队列，访问节点

4.若左子树不为空访问左子树并把节点入队列

5.若右子树不为空访问右子树并把节点入队列

6.队列为空结束不为空返回2

这个逻辑很清楚了也很简洁来吧按照这个逻辑po代码用的是链队

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     struct TreeNode *left; *     struct TreeNode *right; * }; *//** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *columnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */typedef struct Array{    int data;    int level;}Array;typedef struct Node{    struct TreeNode *Tnode;    struct Node *next;    int level;}Node;typedef struct Queue{    struct Node *front;    struct Node *tail;    int Size;}Queue;Queue *InitQueue(){    Queue *queue=(Queue *)malloc(sizeof(Queue));    queue->Size=0;    queue->front=NULL;    queue->tail=NULL;    return queue;}void PushQueue(Queue *queue,struct TreeNode *Tnode,int level){    Node *node=(Node *)malloc(sizeof(Node));    node->Tnode=Tnode;    node->next=NULL;    node->level=level;        if(queue->Size==0)    {        queue->front=node;    }    else    {        queue->tail->next=node;    }    queue->tail=node;    queue->Size++;}Node* PopQueue(Queue *queue){    Node *q=queue->front;    queue->front=queue->front->next;    queue->Size--;    return q;}int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {    if(root==NULL)    {        return NULL;    }    Queue *queue=InitQueue();    int level=1;    Array array[2048];    memset(array,0,sizeof(array));    int count=0;    PushQueue(queue,root,level);    int MaxDepth=0;    while(queue->Size)    {            Node *node=PopQueue(queue);            array[count].data=node->Tnode->val;            array[count].level=node->level;            count++;            if(node->Tnode->left)            {                PushQueue(queue,node->Tnode->left,node->level+1);            }            if(node->Tnode->right)            {                PushQueue(queue,node->Tnode->right,node->level+1);            }            if(queue->Size==0)            {                MaxDepth=node->level;            }    }    int flag=1;    count=0;    int **res=(int **)calloc(MaxDepth,sizeof(int *));    int *columnSizesArray=(int *)calloc(1024,sizeof(int));    while(1)    {        int t=0;        int *r=(int *)calloc(1024,sizeof(int ));        while(flag==array[count].level)        {            *(r+t)=array[count].data;            t++;            count++;        }        *(columnSizesArray+flag-1)=t;        *(res+flag-1)=r;        if(flag==MaxDepth)        {            break;        }        flag++;    }    *columnSizes=columnSizesArray;    *returnSize=MaxDepth;        return res;}

这个解决了可以解决很多类似的题目我直接写在这里面了可以自己去试试再来看代码

Binary Tree Level Order Traversal II

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   7

return its bottom-up level order traversal as:

[  [15,7],  [9,20],  [3]]

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     struct TreeNode *left; *     struct TreeNode *right; * }; *//** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *columnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */typedef struct Array{    int data;    int level;}Array;typedef struct Node{    struct TreeNode *Tnode;    struct Node *next;    int level;}Node;typedef struct Queue{    struct Node *front;    struct Node *tail;    int Size;}Queue;Queue *InitQueue(){    Queue *queue=(Queue *)malloc(sizeof(Queue));    queue->Size=0;    queue->front=NULL;    queue->tail=NULL;    return queue;}void PushQueue(Queue *queue,struct TreeNode *Tnode,int level){    Node *node=(Node *)malloc(sizeof(Node));    node->Tnode=Tnode;    node->next=NULL;    node->level=level;        if(queue->Size==0)    {        queue->front=node;    }    else    {        queue->tail->next=node;    }    queue->tail=node;    queue->Size++;}Node* PopQueue(Queue *queue){    Node *q=queue->front;    queue->front=queue->front->next;    queue->Size--;    return q;}int** levelOrderBottom(struct TreeNode* root, int** columnSizes, int* returnSize) {    if(root==NULL)    {        return NULL;    }    Queue *queue=InitQueue();    int level=1;    Array array[2048];    memset(array,0,sizeof(array));    int count=0;    PushQueue(queue,root,level);    int MaxDepth=0;    while(queue->Size)    {            Node *node=PopQueue(queue);            array[count].data=node->Tnode->val;            array[count].level=node->level;            count++;            if(node->Tnode->left)            {                PushQueue(queue,node->Tnode->left,node->level+1);            }            if(node->Tnode->right)            {                PushQueue(queue,node->Tnode->right,node->level+1);            }            if(queue->Size==0)            {                MaxDepth=node->level;            }    }    int flag=1;    count=0;    int **res=(int **)calloc(MaxDepth,sizeof(int *));    int *columnSizesArray=(int *)calloc(1024,sizeof(int));    int i=0;    while(1)    {        int t=0;        int *r=(int *)calloc(1024,sizeof(int ));        while(flag==array[count].level)        {            *(r+t)=array[count].data;            t++;            count++;        }                *(columnSizesArray+MaxDepth-i-1)=t;        *(res+MaxDepth-i-1)=r;        i++;        if(flag==MaxDepth)        {            break;        }        flag++;    }    *columnSizes=columnSizesArray;    *returnSize=MaxDepth;    return res;}

还有这个额

Populating Next Right Pointers in Each Node

Given a binary tree

    struct TreeLinkNode {      TreeLinkNode *left;      TreeLinkNode *right;      TreeLinkNode *next;    }

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Note:

• You may only use constant extra space.
• You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).

For example,
Given the following perfect binary tree,

         1       /  \      2    3     / \  / \    4  5  6  7

After calling your function, the tree should look like:

         1 -> NULL       /  \      2 -> 3 -> NULL     / \  / \    4->5->6->7 -> NULL

/** * Definition for binary tree with next pointer. * struct TreeLinkNode { *  int val; *  struct TreeLinkNode *left, *right, *next; * }; * */typedef struct Node{    struct TreeLinkNode *Tnode;    struct Node *next;    int level;}Node;typedef struct Queue{    Node *front;    Node *tail;    int Size;}Queue;Queue *InitQueue(){    Queue *queue=(Queue *)malloc(sizeof(Queue));    queue->front=NULL;    queue->tail=NULL;    queue->Size=0;    return queue;}void PushQueue(Queue *queue,struct TreeLinkNode *Tnode,int level){    Node *node=(Node *)malloc(sizeof(Node));    node->Tnode=Tnode;    node->level=level;    if(queue->Size==0)    {        queue->front=node;    }    else    {        queue->tail->next=node;    }    queue->tail=node;    queue->Size++;}Node *PopQueue(Queue *queue){    Node *node=queue->front;    queue->front=queue->front->next;    queue->Size--;    return node;}void connect(struct TreeLinkNode *root) {    int level=1;    Queue *queue=InitQueue();    if(root)    {        PushQueue(queue,root,level);        while(queue->Size)        {            Node *node=PopQueue(queue);            if(queue->front)            {                if(node->level==queue->front->level)                {                    node->Tnode->next=queue->front->Tnode;                    }                else                {                    node->Tnode->next=NULL;                }            }            else            {                node->Tnode->next=NULL;            }            if(node->Tnode->left)            {                PushQueue(queue,node->Tnode->left,node->level+1);            }            if(node->Tnode->right)            {                PushQueue(queue,node->Tnode->right,node->level+1);            }        }    }}

还有就不说了反正还有的哦-。-自己来试试这些题目会了开始的第一个后面都很随意