leetcode 103.Binary Tree Zigzag Level Order Traversal（C语言实现）

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its zigzag level order traversal as:
[
  [3],
  [20,9],
  [15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal

二维数组（i,j）时，第二个下标的参数切勿传错 (习惯性写成i)

反转数组指针只到达中点或中点前一个

不能在递归中先右后左，否则下一次不能回退到最左边（只能到右子树的最左边） 

类似层次遍历，偶数层数编号（i层对应i-1号层）先左后右，奇数层编号先右后左 

short depthOfTree(struct TreeNode *root)
{
        if(!root)
                return 0;
        short left = depthOfTree(root->left);
        short right = depthOfTree(root->right);
        return 1 + (left > right ? left : right);
}

void levelNums(struct TreeNode *root , short k , int *size)
{
        if(!root)
                return;
        ++size[k];
        levelNums(root->left, k + 1, size);
        levelNums(root->right, k + 1, size);
}

/*本层是偶数编号下一层先右后左，否则先左后右 */
void pushArrayTwist(struct TreeNode *root,short k,int *index, int **ans)
{
        if(!root)
                return ;

        ans[k][index[k]] = root->val;
        ++index[k];

        /*
        if(k%2==0)//偶数编号层下一层从右到左
        {
                pushArrayTwist(root->right, k + 1, index, ans);
                pushArrayTwist(root->left, k + 1, index, ans);
        }
        else
        {
                pushArrayTwist(root->left, k + 1, index, ans);
                pushArrayTwist(root->right, k + 1, index, ans);
        }
        */
        pushArrayTwist(root->left, k + 1, index, ans);
        pushArrayTwist(root->right, k + 1, index, ans);
}
int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
        *returnSize = depthOfTree(root);//层数
        int *sizeOfLevel = (int *)calloc(*returnSize, sizeof(int));//层结点数量的数组，初始化
        levelNums(root, 0, sizeOfLevel);

        int **ans = (int **)calloc(*returnSize, sizeof(int *));//二维输出数组，元素是int一维数组
        for (short i = 0; i < *returnSize; ++i )
        {
                ans[i] = (int *)calloc(sizeOfLevel[i], sizeof(int));
                sizeOfLevel[i] = 0;//分配完该层的空间后把该层的结点数重置为0，以便作为该层元素的下标
        }

        pushArrayTwist(root, 0, sizeOfLevel, ans);//写入数组结束时，sizeofLevel[i]指向末位的下一个==层结点数
        *returnColumnSizes = sizeOfLevel;//指向sizeoflevel的起点
        //奇数编号层反转
        for (short i = 1; i < *returnSize; i+=2 )
        {
                short len = sizeOfLevel[i];
                //for (short j = 0; j < len; ++j)指针最多走到中点
                for (short j = 0; j < len / 2; ++j)
                        if (ans[i][j]!=ans[i][len-1-j])
                        {
                                ans[i][j] ^= ans[i][len - 1 - j];
                                ans[i][len - 1 - j] ^= ans[i][j];
                                ans[i][j] ^= ans[i][len - 1 - j];//第二个下标是-j,不是-i
                        }
        }
        return ans;
}