力扣117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树：

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

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

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

示例 1：

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

示例 2：

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

提示：

• 树中的节点数在范围 [0, 6000] 内
• -100 <= Node.val <= 100

进阶：

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

解法一：直接用next解 

class Solution {
public:
    // 这个辅助函数用于连接同一层的节点
    void handle(Node* &last, Node* &p, Node* &nextStart) {
        // 如果last节点存在，那么将last节点的next指针指向p节点
        if (last) {
            last->next = p;
        } 
        // 如果nextStart还未初始化，那么将它指向p节点
        if (!nextStart) {
            nextStart = p;
        }
        // 将last更新为p，以便在下一个迭代中将next指针连接到p
        last = p;
    }

    // 主函数，用于处理二叉树并连接同一层的节点
    Node* connect(Node* root) {
        // 如果根节点为空，直接返回nullptr
        if (!root) {
            return nullptr;
        }
        // start用于标记当前层的第一个节点
        Node *start = root;
        // 当前层还有节点未处理时，循环继续
        while (start) {
            Node *last = nullptr, *nextStart = nullptr;
            // 遍历当前层的所有节点，p指向当前层的节点
            for (Node *p = start; p != nullptr; p = p->next) {
                // 如果p节点有左子节点，调用handle函数处理左子节点
                if (p->left) {
                    handle(last, p->left, nextStart);
                }
                // 如果p节点有右子节点，调用handle函数处理右子节点
                if (p->right) {
                    handle(last, p->right, nextStart);
                }
            }
            // 将start更新为下一层的第一个节点
            start = nextStart;
        }
        // 最后返回根节点，此时树中所有同一层的节点已经被连接
        return root;
    }
};

解法二：用队列方法 

 

/*
// Node类的定义
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    // 连接完美二叉树中同一层的节点
    Node* connect(Node* root) {
        // 如果根节点为空，直接返回NULL
        if (!root) {
            return NULL;
        }

        // 创建一个队列用于层序遍历
        queue<Node*> q;

        // 将根节点入队
        q.push(root);

        // 只要队列不为空，就继续进行层序遍历
        while (!q.empty()) {
            // 用于记录当前层最后一个处理的节点
            Node* last = NULL;

            // 获取当前队列的大小，即当前层的节点数
            int n = q.size();
            // 遍历当前层的所有节点
            for (int i = 1; i <= n; i++) {
                // 取出队列中的第一个节点
                Node* f = q.front();
                q.pop(); // 出队

                // 如果当前节点有左子节点，将其入队
                if (f->left)
                    q.push(f->left);
                // 如果当前节点有右子节点，将其入队
                if (f->right)
                    q.push(f->right);

                // 除第一个节点外，将last节点的next指针指向当前节点f，实现同一层节点的连接
                if (i != 1)
                    last->next = f;
                // 更新last为当前节点f，用于下一次迭代
                last = f;
            }
        }
        // 返回根节点，此时树中所有同一层的节点已经被连接
        return root;
    }
};