4月19号算法题解

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示：

• 二叉树的节点个数的范围是 [0,104]
• -231 <= Node.val <= 231 - 1

要找到每一行中的最大值，依然是要遍历树的每一层，然后及时更新最大值，最后将最大值记录在答案数组里面；

这里的关键点是要处理好最后一层，和第一层最大值的返回

int* largestValues(struct TreeNode* root, int* returnSize) {
    int* ans = (int*)malloc(sizeof(int) * 10000);	//首先为答案数组分配内存
    *returnSize = 0;
    if(root == NULL) {	//数组若是为空直接返回
        return NULL;
    }
    int col[10000];
    struct TreeNode* queue[10000];
    int rear = 0, front = 0;
    int max = root->val;	//先将最大值初始化为根节点的值
    queue[rear++] = root;	//将根节点入队
    while(rear != front) {
        ans[(*returnSize)++] = max;	//这里相当于是将上一层记录的最大值加入答案数组，第一层比较特殊，最后还要另外处理
        int head = front;
        front = rear;
        max = queue[head]->val;	//遍历每一层，先将最大值更新为每层的第一个节点
        for(int i = head; i < front; i++) {
            if(queue[i]->val > max) {	//遇到更大的就即使更新节点最大值
                max = queue[i]->val;
            }
            if(queue[i]->left) {	//将新节点的左右节点入队
                queue[rear++] = queue[i]->left;
            }
            if(queue[i]->right) {
                queue[rear++] = queue[i]->right;
            }
        }
    }
    ans[(*returnSize)++] = max;	//遍历到最后一层就已经退出了，所以这里另外将最后一层的结果加入答案
    for(int i = 0; i < *returnSize - 1; i++) {	//由于第一层的答案加入了两次，这里将数组向前移动一位
        ans[i] = ans[i + 1];
    }
    (*returnSize)--;
    return ans;
}

116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

提示：

• 树中节点的数量在 [0, 212 - 1] 范围内
• -1000 <= node.val <= 1000

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

这里的每一个节点有第三个子节点，题目要求我们为这些节点赋值，由于每个节点的指向和同一层的节点有关系，所以这里还是层序遍历，然后要处理好最后一个节点要指向空节点

struct Node* connect(struct Node* root) {
    if(root == NULL) {	//如果树为空就直接返回
        return NULL;
    }
    struct Node* queue[100000];	//树队列
    int rear = 0;
    int front = 0;
    queue[rear++] = root;	//先将根节点入队
    while(rear != front) {
        int head = front;
        front = rear;
        for(int i = head; i < front; i++) {	//这里是遍历每一层的节点
            if(i == front - 1) {	//当遍历到每一层的最后一个结点的时候，要将其第三节点指向空
                queue[i]->next = NULL;
            }else {	//其他的就要指向同层的下一个节点
                queue[i]->next = queue[i + 1];
            }
            if(queue[i]->left) {	//将左右节点加入队列
                queue[rear++] = queue[i]->left;
            }
            if(queue[i]->right) {
                queue[rear++] = queue[i]->right;
            }
        }
    }
    return root;
}

       }
            if(queue[i]->right) {
                queue[rear++] = queue[i]->right;
            }
        }
    }
    return root;
}