力扣第102题(二叉树的层序遍历＜C语言＞)

 题目：

 

层序遍历其实不难，这题难的地方就是:

        1、要自己开二维数组空间，malloc了int**的变量作为返回数组以后还要malloc   int* (每一行的一维数组也要malloc).

        2、要理解returnSize和returnColumnSizes的意思，因为后台不知道我们给的二维数组的行数和列数，所以就要我们给这个行数和列数。returnSize就是行数，returnColumnSizes就是每一行的列数所构成的数列，因为需要我们在函数里面改变returnSize这个数字，所以传了int*, 因为需要我们在函数里面改变returnColumnSizes这个数组，所以传了int**

下面就给出代码： 

/**
 * 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().
 */

 int max(int x, int y)
 {
	 return x>y?x:y;
 }

typedef struct TreeNode* Queuedatatype;
typedef struct QueueNode {
	Queuedatatype data;
	struct QueueNode* next;
}QNode;
 
typedef struct Queue {
	QNode* head;
	QNode* tail;
}Queue;
 
QNode* BuyNewnode(Queuedatatype x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		printf("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
 
void QueuePush(Queue* pq, Queuedatatype x)//尾入
{
	assert(pq);
	QNode* newnode = BuyNewnode(x);
	if (pq->head == NULL) {
 
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
 
void QueuePop(Queue* pq)//头删
{
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL) { pq->tail = NULL; }//防止tail野指针或者在（2）处
	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	//if (pq->head == NULL) { pq->tail = NULL; }（2）
}
 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
 
	return pq->head == NULL;
}
 
Queuedatatype QueueFront(Queue* pq)//头出
{
	assert(pq);
	assert(!QueueEmpty(pq));
 
	return pq->head->data;
}
 
Queuedatatype QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
 
	return pq->tail->data;
}
 
int QueueSize(Queue* pq)
{
	int n = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		n++;
	}
	return n;
}
 
void QueueInit(Queue* pq)//初始化
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
 
void QueueDestroy(Queue* pq)//销毁
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

int treeKLevel(struct TreeNode* root, int k)//第K层的结点个数
{
	assert(k >= 1);
	if (root == NULL)
		return 0;
	/*if (root != NULL && k == 1)
		return 1;*/
	if (k == 1)//root一定不为空
		return 1;
	return treeKLevel(root->left, k - 1) + treeKLevel(root->right, k - 1);
}

int treeDepth(struct TreeNode* root)//层数
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	else
	{
		return max(treeDepth(root->left), treeDepth(root->right)) + 1;
	}
}

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
		//这里的returnSize是要返回的数组的行数
		//returnColumnSizes是要返回数组的列数所组成的一个数组
    *returnSize = 0;//如果树为空，要返回*returnSize为0
    if(root == NULL)
        return root;
    int* num1 = (int*)malloc(sizeof(int) * 2000);//存储树的所有数据
    int level = treeDepth(root);//二叉树层数
    *returnSize = level;//二叉树的层数就是要返回的二维数组的行数
	*returnColumnSizes = (int*)malloc(sizeof(int) * (*returnSize));//malloc一个数组存放每行的列数
		int** num2 = (int**)malloc(sizeof(int*) * (*returnSize));//准备返回的二维数组
    for(int i = 0; i < level; i++)
    {
        (*returnColumnSizes)[i] = treeKLevel(root, i+1);//二叉树每层的数目就是二维数组每行的列数，存放在returnColumnSizes中
    }
    Queue q;//基本思想：借助队列实现层序遍历
    QueueInit(&q);
    QueuePush(&q, root);
    int j = 0;
    while(!QueueEmpty(&q))
    {
        struct TreeNode* cur = QueueFront(&q);
        num1[j++] = cur->val;//将二叉树的元素按照层序遍历存在num1中
        QueuePop(&q);
        if(cur->left)
        {
            QueuePush(&q, cur->left);
        }
        if(cur->right)
        {
            QueuePush(&q, cur->right);
        }
    }
    int k = 0;
    for(int i = 0; i < level; i++)
    {
			num2[i] = (int*)malloc(sizeof(int) * (*returnColumnSizes)[i]);
			//num2只开了(int**)的，要形成二维数组还要开(int*)的
      for(int j = 0; j<(*returnColumnSizes)[i];j++)
      {
			num2[i][j] = num1[k++];//每层存入数据
      }
    }
	free(num1);//free掉num1
    return num2;
}