二叉树的层序遍历-102

 

方法一：本文采用BFS进行层序遍历，具体分析参见https://www.cnblogs.com/sbb-first-blog/p/13259728.html

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
#define MAX_RETURN_NUM 1000

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int **ret=(int**)calloc(MAX_RETURN_NUM,sizeof(int *));    //分配一个二维数组
    *returnColumnSizes=(int*)calloc(MAX_RETURN_NUM,sizeof(int));  //分配空间
    *returnSize=0;
    struct TreeNode *queue[10000];
    int outIndex=0;
    int inIndex=0;

    //判断异常输入，进入while循环之前初始化
    if(root==NULL) return NULL;
    queue[inIndex++]=root;
    int levelcount=inIndex-outIndex;              //记录每层的个数
    int count=0,i;

    //bfs
    while(levelcount>0)
    {
        count++;
        ret[*returnSize]=(int *)calloc(levelcount,sizeof(int));
        (*returnColumnSizes)[*returnSize]=levelcount;
        //对每一层进行处理
        for(i=0;i<levelcount;i++)
        {
            if(queue[outIndex]->left!=NULL)
            {
                queue[inIndex++]=queue[outIndex]->left;
            }
            if(queue[outIndex]->right!=NULL)
            {
                queue[inIndex++]=queue[outIndex]->right;
            }
            ret[*returnSize][i]=queue[outIndex]->val;
            outIndex++;
        }
        //进入下一层的操作
        (*returnSize)++;              //在returnSize所指向的数据上加1，
        levelcount=inIndex-outIndex;
    }
return ret;

}

 方法二：链表加BFS

/**
 * 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 *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
 typedef struct queue{
     int front;
     int rear;
     struct TreeNode *data[1009];
 }QUEUE;
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    *returnSize=0;
    if(root==NULL)
    {
        return NULL;
    }
    QUEUE q;
    q.front=0;
    q.rear=1;
    q.data[0]=root;
    int levelcount=q.rear-q.front;
    int **res=(int **)malloc(sizeof(int *)*1009);     //给二维数组分配空间
    int n=-1;
    while(q.front!=q.rear)
    {
        res[*returnSize]=(int *)malloc(1009*sizeof(int));
        (*returnColumnSizes)[*returnSize]=levelcount;
        for(int i=0;i<levelcount;i++)
        {
            if(q.data[(q.front)]->left)
            {
                q.data[(q.rear)++]=q.data[q.front]->left;
            }
            if(q.data[(q.front)]->right)
            {
                q.data[(q.rear)++]=q.data[q.front]->right;
            }
            res[*returnSize][i]=q.data[q.front]->val;
            q.front++;
        }
        levelcount=q.rear-q.front;
        (*returnSize)++;
    }
//    *returnSize=n;
    return res;
}