leetcode-102-二叉树的层序遍历

#define MAXQSIZE 10000
 typedef struct
{
	struct TreeNode *base;
	int front;
	int rear;
}SqQueue;



SqQueue *InitQueue()
{
	SqQueue *queue = (SqQueue *)malloc(sizeof(SqQueue));
	queue->base = (struct TreeNode *)malloc(sizeof(struct TreeNode) * MAXQSIZE);
	queue->front = queue->rear = 0;
	return queue;
}

int QueueLenth(SqQueue *obj)
{
	return (obj->rear - obj->front + MAXQSIZE) % MAXQSIZE;
}

void EnQueue(SqQueue *obj, struct TreeNode x)
{
	if ((obj->rear + 1) % MAXQSIZE == obj->front)
	{
		//printf("obj->rear = %d,obj->front = %d, Queue is full!\n", obj->rear, obj->front);
		return;
	}
	obj->base[obj->rear] = x;
	obj->rear = (obj->rear + 1) % MAXQSIZE;
}

void DeQueue(SqQueue *obj)
{
	if (obj->rear == obj->front)
		return;

	obj->front = (obj->front + 1) % MAXQSIZE;
}

struct TreeNode QueueFront(SqQueue *obj)
{
	return obj->base[obj->front];
}

//获取二叉树深度
void preOrderGetDepth(struct TreeNode *node, int depth, int *maxDepth)
{
	if (node == NULL)
	{
		*maxDepth = depth > *maxDepth ? depth : *maxDepth;
		return;
	}
	preOrderGetDepth(node->left, depth + 1, maxDepth);
	preOrderGetDepth(node->right, depth + 1, maxDepth);
}

int getBiTreeDepth(struct TreeNode *root)
{
	int *maxDepth = (int *)malloc(sizeof(int));
	int depth;
	struct TreeNode *t;

	*maxDepth = INT_MIN;
	depth = 0;

	t = root;
	preOrderGetDepth(t, depth, maxDepth);
	//printf("maxdepth=%d\n", *maxDepth);
	
	int res = *maxDepth;
	free(maxDepth);
	return res;
}

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    struct TreeNode *t;
	int i;
	int depth, level, arrIndex;
	int **res = NULL;

	if (root == NULL)
	{
		*returnSize = 0;
		return res;
	}
	int *arr = (int *)malloc(sizeof(int) * 1000);

	//先求二叉树层数
	t = root;
	depth = getBiTreeDepth(t);
	//printf("tree depth = %d\n", depth);

        *returnSize = depth;
	*returnColumnSizes = (int *)malloc(sizeof(int) * depth);
	res = (int **)malloc(sizeof(int *) * depth);

	SqQueue *queue = InitQueue();
	struct TreeNode *tmpNode = (struct TreeNode *)malloc(sizeof(struct TreeNode));
	tmpNode->val = INT_MIN;
	tmpNode->left = NULL;
	tmpNode->right = NULL;

	EnQueue(queue, *root);
	EnQueue(queue, *tmpNode);

	level = 0;
	arrIndex = 0;
	while (QueueLenth(queue) != 0)
	{
		struct TreeNode node = QueueFront(queue);
		DeQueue(queue);
		if (node.val == INT_MIN)
		{
			(*returnColumnSizes)[level] = arrIndex;
			res[level] = (int *)malloc(sizeof(int) * arrIndex);
			memcpy(res[level], arr, sizeof(int) * arrIndex);
			level++;
			arrIndex = 0;

                        if (QueueLenth(queue) == 0)
			    break;

			EnQueue(queue, *tmpNode);
			continue;
		}
		else
		{
			arr[arrIndex] = node.val;
			arrIndex++;
		}

		if ((&node)->left)
			EnQueue(queue, *((&node)->left));
		if ((&node)->right)
			EnQueue(queue, *((&node)->right));
	}
	free(arr);

	return res;

}