103. 二叉樹的鋸齒形層次遍歷 Binary Tree Zigzag Level Order Traversal

題目 https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/

#define max(a,b) ((a)>(b)?(a):(b))
#define bool int
#define true 1
#define false 0 

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
};

int maxDeep(struct TreeNode* root){
	if(root == NULL){
		return 0;
	}
	return 1 + max(maxDeep(root->left),maxDeep(root->right));
}


struct StackNode{
    struct TreeNode *node;
    struct StackNode *next;
};

struct Stack{
	struct StackNode *button,*top;
};

struct Stack *StackCreate(){
    struct Stack *obj = malloc(sizeof(struct Stack));
    obj->button = NULL;
    obj->top = NULL;
    return obj;
}

void StackPush(struct Stack * obj,struct TreeNode *node){
    struct StackNode* stack_node = malloc(sizeof(struct StackNode));
    stack_node->node = node;
    stack_node->next = NULL;
    if(obj->top == NULL){
		obj->top = stack_node;
		obj->button = stack_node;
	}else{
		stack_node->next = obj->top;
		obj->top = stack_node;
	}
}

void StackPop(struct Stack * obj){
    if(obj->top == NULL)
		return;

	struct StackNode* stack_node;
	if(obj->top == obj->button){
		stack_node = obj->top;
		obj->top = obj->button = NULL;
	}else{
		stack_node = obj->top;
		obj->top = stack_node->next;
	}
	free(stack_node);
}

struct TreeNode * StackTop(struct Stack *obj){
    if(obj->top == NULL)
        return NULL;
    return obj->top->node;
}

bool StackEmpty(struct Stack *obj){
    if(obj->top == NULL)
        return true;
    return false;
}

void StackFree(struct Stack* obj) {
    while(!StackEmpty(obj)){
        StackPop(obj);
    }
}


int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
	int deep = maxDeep(root);
	if(deep == 0){
		*returnSize = 0;
		(*returnColumnSizes) = NULL;
		return NULL;
	}

	*returnSize = deep;
	int **returnColumn = malloc(sizeof(int*)*deep);
	*returnColumnSizes = malloc(sizeof(int)*deep);
	
	int *n = malloc(sizeof(int) * ((2<<deep)-1));
	int *n2;
	
	int len=0,count=0,flag = 1;
	struct TreeNode *node=NULL,*left=NULL,*right=NULL;
	struct Stack *stack1=NULL,*stack2=NULL,*stack3=NULL;
	stack1 = StackCreate();
	stack2 = StackCreate();
	
	StackPush(stack1,root);
	count = 0;
	while(StackEmpty(stack1) != true){
		len = 0;
		while(StackEmpty(stack1) != true){
			node = StackTop(stack1);
			//if(node == NULL)
			//	break;
			
			left = node->left;
			right = node->right;
			n[len++] = node->val;
			
			if(flag == 1){
				if(left != NULL)
					StackPush(stack2,left);	
				if(right != NULL)
					StackPush(stack2,right);
			}else{
				if(right != NULL)
					StackPush(stack2,right);
				if(left != NULL)
					StackPush(stack2,left);	
			}
			StackPop(stack1);
		}
		if(flag == 1)	flag = 0;
		else flag = 1;
		n2 = malloc(sizeof(int)*len);
		memcpy(n2,n,sizeof(int)*len);
		returnColumn[count] = n2;
		(*returnColumnSizes)[count] = len;
		count++;
		
		stack3 = stack1;
		stack1 = stack2;
		stack2 = stack3;
	}
	free(n);
	free(stack1);
	free(stack2);
	return returnColumn;
}

//測試用例
int main(){
	struct TreeNode *root = malloc(sizeof(struct TreeNode));
	root->val = 1;

	struct TreeNode *node;
	node = malloc(sizeof(struct TreeNode));
	node->val = 2;
	node->left = NULL;
	node->right = NULL;
	root->left = node;
	//root->left = NULL;

	node = malloc(sizeof(struct TreeNode));
	node->val = 3;
	node->left = NULL;
	node->right = NULL;
	root->right = node;

	node = malloc(sizeof(struct TreeNode));
	node->val = 4;
	node->left = NULL;
	node->right = NULL;
	root->left->left = node;

	node = malloc(sizeof(struct TreeNode));
	node->val = 5;
	node->left = NULL;
	node->right = NULL;
	root->left->right = node;


	int returnSize = 0;
	int *returnColumnSizes = NULL;
	int **returnColumn = zigzagLevelOrder(root,&returnSize,&returnColumnSizes);
	int i,j;
	for(i=0;i<returnSize;i++){
		for(j=0;j<returnColumnSizes[i];j++){
			printf("%d, ",returnColumn[i][j]);
		}
		printf("\n");
	}
}

速度這麼慢。。。