LeetCode //C - 103. Binary Tree Zigzag Level Order Traversal

103. Binary Tree Zigzag Level Order Traversal

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

Example 1:

Input: root = 3,9,20,null,null,15,7
Output: \[3,20,9,15,7]

Example 2:

Input: root = 1
Output: \[1]

Example 3:

Input: root = \[\]
Output: \[\]

Constraints:
  • The number of nodes in the tree is in the range 0, 2000.
  • -100 <= Node.val <= 100

From: LeetCode

Link: 103. Binary Tree Zigzag Level Order Traversal


Solution:

Ideas:
  1. Use a double-ended queue (deque) to keep track of the current level of nodes.
  2. Use a variable isLeftToRight to determine the direction of traversal. We start from left-to-right for the first level.
  3. For each level:
    • If isLeftToRight is true, pop nodes from the front of the deque and push their left child followed by their right child to the back.
    • Otherwise, pop nodes from the back of the deque and push their right child followed by their left child to the front.
  4. Keep track of the number of nodes at the current level to determine when to switch to the next level and reverse the traversal direction.
Code:
c 复制代码
typedef struct {
    struct TreeNode **data;
    int front;
    int rear;
    int size;
    int capacity;
} Deque;

Deque* createDeque(int capacity) {
    Deque *deque = (Deque *)malloc(sizeof(Deque));
    deque->data = (struct TreeNode **)malloc(capacity * sizeof(struct TreeNode *));
    deque->front = 0;
    deque->rear = -1;
    deque->size = 0;
    deque->capacity = capacity;
    return deque;
}

void pushFront(Deque *deque, struct TreeNode *node) {
    deque->front = (deque->front - 1 + deque->capacity) % deque->capacity;
    deque->data[deque->front] = node;
    deque->size++;
}

void pushRear(Deque *deque, struct TreeNode *node) {
    deque->rear = (deque->rear + 1) % deque->capacity;
    deque->data[deque->rear] = node;
    deque->size++;
}

struct TreeNode* popFront(Deque *deque) {
    struct TreeNode *node = deque->data[deque->front];
    deque->front = (deque->front + 1) % deque->capacity;
    deque->size--;
    return node;
}

struct TreeNode* popRear(Deque *deque) {
    struct TreeNode *node = deque->data[deque->rear];
    deque->rear = (deque->rear - 1 + deque->capacity) % deque->capacity;
    deque->size--;
    return node;
}

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

    int **result = (int **)malloc(2000 * sizeof(int *));
    *returnColumnSizes = (int *)malloc(2000 * sizeof(int));
    *returnSize = 0;

    Deque *deque = createDeque(2000);
    pushRear(deque, root);
    int isLeftToRight = 1;

    while (deque->size > 0) {
        int levelSize = deque->size;
        (*returnColumnSizes)[*returnSize] = levelSize;
        result[*returnSize] = (int *)malloc(levelSize * sizeof(int));

        for (int i = 0; i < levelSize; i++) {
            struct TreeNode *current;
            if (isLeftToRight) {
                current = popFront(deque);
                result[*returnSize][i] = current->val;
                if (current->left) pushRear(deque, current->left);
                if (current->right) pushRear(deque, current->right);
            } else {
                current = popRear(deque);
                result[*returnSize][i] = current->val;
                if (current->right) pushFront(deque, current->right);
                if (current->left) pushFront(deque, current->left);
            }
        }

        isLeftToRight = !isLeftToRight;
        (*returnSize)++;
    }

    free(deque->data);
    free(deque);
    return result;
}
相关推荐
老师我太想进步了202610 小时前
【数据结构-8】栈的实现
c语言·数据结构·算法
kyle~11 小时前
因子图优化(Factor Graph Optimization)
c++·算法·机器人·传感器
LCG元11 小时前
串口乱码,先算波特率误差再动代码
c语言·嵌入式
Pniubi12 小时前
贪心算法入门
算法·贪心算法
MobotStone12 小时前
AI 能不能越用越会用?从“改答案”到“改进自己”,读懂 RSI
人工智能·算法
复杂网络与机器学习12 小时前
Meta 重写 K-Means:25 轮压成 2 轮,GPU 快 45 倍
人工智能·算法·数据挖掘
lunar_coder13 小时前
【算法】前缀和:把 O(n) 的重复劳动变成 O(1) 的一次查询
c++·算法
Pniubi13 小时前
力扣19 . 删除表的倒数第N个节点(栈)
算法·leetcode·职场和发展
青少儿编程课堂13 小时前
第十八届蓝桥杯青少组图形化 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园三消乐大挑战解析
c++·python·算法·bfs·信息学竞赛
青少儿编程课堂13 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:网格连通块与岛屿数量(DFS+BFS双解)
c++·python·算法·bfs·信息学竞赛