leetcode——Binary Tree Level Order Traversal

树的遍历主要是四种：前序、中序遍历、后序、分层遍历。前三种一般用递归的方法，而递归方法都会用到堆栈；分层遍历需要用到队列，队列的实现也是不唯一的，根据需要建立自己的结构。这道题具体的方法是，先将根入栈，记录size=1（我的size在队列中），出栈生成需要的数组，size = 0；再将他的左右儿子入栈，size...一直循环到size=0，也就是不再有入栈且完全出栈的时候（描述不好。。）。

这道题对题目的理解很重要：leetcode中 形参为（整形）指针，一般是要传回的整形；形参为二维指针，要传回数组，而前一个整形正是这个数组的大小。

/**
* Return an array of arrays of size *returnSize. 返回二维数组的大小
* The sizes of the arrays are returned as *columnSizes array.   *columnSizes是一个数组，注意，不是<span style="font-family: Arial, Helvetica, sans-serif;">columnSizes</span>
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/

这道题参考了别人的答案，但能做出来很开心啊，加油！

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

#include<stdlib.h>
#include<stdio.h>
#define ElementType struct TreeNode
typedef struct QueueRecord *Queue;
typedef struct TreeNode *Tree;
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
};
//创建一个队列--链表实现
struct QueueRecord
{
	int size;
	ElementType *element;
	Queue next;
};
//省略空间检测
Queue Initialize()
{
	Queue H = (Queue)malloc(sizeof(struct QueueRecord));
	H->size = 0;
	H->element = NULL;
	H->next = NULL;
	return H;
}
void Enqueue(ElementType *node, Queue Q)
{
	Queue temp;
	temp = (Queue)malloc(sizeof(struct QueueRecord));
	Q->size++;
	temp->element = node;
	temp->next = Q->next;
	Q->next = temp;
}
Queue Dequeue(Queue Q)
{
	Queue temp = Q;
	Queue tem;
	if (temp->next)
	{
		while (temp->next->next != NULL)
		{
			temp = temp->next;
		}
	}
	tem = temp->next;
	temp->next = NULL;
	Q->size--;
	return tem;
}

//*returnSize 返回数组大小，*columnSizes 是返回数组内部数组的大小的数组
int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {
	if (root == NULL)
		return NULL;
	Queue Q = Initialize();
	Enqueue(root, Q);
	int lever = 4;
	int **Ret = (int**)malloc(lever * sizeof(int*));
	int size;
	int *column;
	int *colsize = (int*)malloc(lever*sizeof(int));
	Queue out;
	int j = 0;
	while (Q->size != 0)
	{
		size = Q->size;

		int i = 0;
		column = (int*)malloc(size*sizeof(int));
		
		colsize[j] = size;
		do
		{
			out = Dequeue(Q);
			column[i++] = out->element->val;
			if (out->element->left)
			{
				Enqueue(out->element->left,Q);
			}
			if (out->element->right)
			{
				Enqueue(out->element->right, Q);
			}
		} while (--size);
		if (j >= lever-1)
		{
			lever = lever << 1;
			Ret = (int**)realloc(Ret, lever*sizeof(int*));//重新分配地址空间
			colsize = (int*)realloc(colsize, lever*sizeof(int*));
		}
		Ret[j++] = column;	
		
	}
	*columnSizes = colsize;
	*returnSize = j;
	return Ret;
}
void main()
{
	Tree T = (Tree)malloc(1 * sizeof(struct TreeNode));
	T->val = 1;
	T->left = NULL;
	T->right = NULL;
	int **c = (int**)malloc(1 * sizeof(int*));;
	int *r = (int *)malloc(sizeof(int));
	int ** ret = levelOrder(T, c, r);
	getchar();
}