/**
* 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().
*/
#define MAXSIZE 10000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
if(root==NULL){
*returnSize=0;
return NULL;
}
struct TreeNode*queue[MAXSIZE]={0};
int head=0,tail=0;
int **res=(int**)malloc(sizeof(int*)*MAXSIZE);
*returnColumnSizes=(int*)malloc(sizeof(int*)*MAXSIZE);
queue[tail++]=root;//push
*returnSize=0;
while(head<tail){
int size=(tail-head+MAXSIZE)%MAXSIZE;
(*returnColumnSizes)[*returnSize]=size;
res[*returnSize]=(int*)malloc(sizeof(int)*size);
for(int i=0;i<size;i++){
struct TreeNode*temp=queue[head++];//pop
res[*returnSize][i]=temp->val;
if(temp->left){
queue[tail++]=temp->left;
}
if(temp->right){
queue[tail++]=temp->right;
}
}
(*returnSize)++;
}
return res;
}
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
题目可以理解，但是二级指针用的不理解，比如说*returnColumnSizes 是一级指针地址，但一直理解为解引用
该回答通过自己思路及引用到GPTᴼᴾᴱᴺᴬᴵ搜索,得到内容具体如下：
在C语言中，使用指针可以实现对内存的动态操作，可以避免在函数调用时进行大量的内存拷贝。在函数中，如果需要改变函数外部的变量，需要使用指针或者二级指针。
对于这道题目中的函数levelOrder，它的返回值类型是int**，表示返回一个二维数组，其中每一行是一个数组，数组中存储这一层的节点值。为了正确返回这个二维数组，需要使用二级指针。
在函数中，returnColumnSizes是一个指向一级指针的指针，其作用是存储每一层的节点数。因为在函数中需要动态分配数组空间来存储每一层的节点值，所以需要在函数外部先分配好一级指针的内存空间，然后在函数中对这个指针进行操作，存储每一层的节点数。
在函数中，使用*returnColumnSizes来访问一级指针的指向，使用(*returnColumnSizes)[i]来访问一级指针中的元素。这个语法可能比较复杂，但是理解了指针的概念之后，就可以更好地理解这种语法。
总之，在C语言中，指针和二级指针是非常常用的语法，需要仔细理解。在这道题目中，二级指针的使用是为了能够正确返回一个动态分配的二维数组，并且存储每一层的节点数。
如果以上回答对您有所帮助，点击一下采纳该答案～谢谢
我可以解决该问题。
实现从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，并且每一层打印到一行中的方案如下：
typedef struct TreeNode { int val; struct TreeNode left; struct TreeNode right; } TreeNode;
我们需要辅助队列来按层遍历二叉树，这里可以直接使用标准库中的队列，也可以自己手写队列。
typedef struct Queue { int front; int rear; int *data; } Queue;
Queue createQueue(int n) { Queue q = (Queue)malloc(sizeof(Queue)); q->front = q->rear = 0; q->data = (int)malloc(sizeof(int)*n); return q; }
void enqueue(Queue *q, int val) { q->data[q->rear++] = val; }
int dequeue(Queue *q) { return q->data[q->front++]; }
void printLevel(TreeNode root, int level, int curLevel, int count, int result) { if (!root || curLevel > level) { return; } if (curLevel == level) { (count)++; result[level] = (int)realloc(result[level], sizeof(int)(count)); result[level][(*count)-1] = root->val; return; } printLevel(root->left, level, curLevel+1, count, result); printLevel(root->right, level, curLevel+1, count, result); }
int printTree(TreeNode root, int returnSize, int returnColumnSizes){ Queue q = createQueue(1000); // 声明一个队列 int result = (int)malloc(sizeof(int)1000); // 定义返回数组 returnColumnSizes = (int)malloc(sizeof(int)1000); int level = 0; // 二叉树的深度 int count; // 每一层的节点数目 count = 0; if (!root) { returnSize = 0; return NULL; } enqueue(q, (int)root); while (q->front != q->rear) { (count) = 0; int size = q->rear - q->front; result[level] = (int)malloc(sizeof(int)size); for (int i = 0; i < size; i++) { TreeNode node = (TreeNode)dequeue(q); result[level][(count)++] = node->val; if (node->left) { enqueue(q, (int)node->left); } if (node->right) { enqueue(q, (int)node->right); } } (returnColumnSizes)[level] = (count); level++; } returnSize = level; return result; }
int main() { TreeNode root; // 二叉树的构建 int returnSize; int returnColumnSizes; int **result = printTree(root, &returnSize, &returnColumnSizes); // 打印result for (int i = 0; i < returnSize; i++) { for (int j = 0; j < returnColumnSizes[i]; j++) { printf("%d ", result[i][j]); } printf("\n"); } return 0; }
以上就是实现从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，并且每一层打印到一行中的具体方案。这个方案不是使用二级指针实现的，而是使用辅助队列来实现按层遍历二叉树，逐层打印节点。