Connect All Siblings of a Binary Tree

struct Node {
    int val;
    Node *left, *right, *next;
    Node(int v) : val(v), left(nullptr), right(nullptr), next(nullptr) {}
};

class Solution {
public:
    Node* connectAll(Node* root) {
        if (!root) return nullptr;
        queue<Node*> q;
        q.push(root);
        Node* prev = nullptr;
        while (!q.empty()) {
            Node* cur = q.front(); q.pop();
            if (prev) prev->next = cur;
            prev = cur;
            if (cur->left)  q.push(cur->left);
            if (cur->right) q.push(cur->right);
        }
        return root;
    }
};

type Node struct {
    Val         int
    Left, Right *Node
    Next        *Node
}

func connectAll(root *Node) *Node {
    if root == nil {
        return nil
    }
    queue := []*Node{root}
    var prev *Node
    for len(queue) > 0 {
        cur := queue[0]
        queue = queue[1:]
        if prev != nil {
            prev.Next = cur
        }
        prev = cur
        if cur.Left != nil {
            queue = append(queue, cur.Left)
        }
        if cur.Right != nil {
            queue = append(queue, cur.Right)
        }
    }
    return root
}

from typing import Optional
from collections import deque

# class Node:
#     def __init__(self, val: int = 0, left=None, right=None, next=None):
#         self.val = val
#         self.left = left
#         self.right = right
#         self.next = next

class Solution:
    def connectAll(self, root: Optional['Node']) -> Optional['Node']:
        if not root:
            return None
        queue = deque([root])
        prev: Optional['Node'] = None
        while queue:
            cur = queue.popleft()
            if prev:
                prev.next = cur
            prev = cur
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return root

// class Node {
//     constructor(val = 0, left = null, right = null, next = null) {
//         this.val = val;
//         this.left = left;
//         this.right = right;
//         this.next = next;
//     }
// }

function connectAll(root) {
    if (!root) return null;
    const queue = [root];
    let prev = null;
    while (queue.length) {
        const cur = queue.shift();
        if (prev) prev.next = cur;
        prev = cur;
        if (cur.left) queue.push(cur.left);
        if (cur.right) queue.push(cur.right);
    }
    return root;
}

class Solution {
    public Node connectAll(Node root) {
        if (root == null) return null;
        Deque<Node> queue = new ArrayDeque<>();
        queue.offer(root);
        Node prev = null;
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            if (prev != null) prev.next = cur;
            prev = cur;
            if (cur.left != null) queue.offer(cur.left);
            if (cur.right != null) queue.offer(cur.right);
        }
        return root;
    }
}

function connectAll(root: Node | null): Node | null {
    if (!root) return null;
    const queue: Node[] = [root];
    let prev: Node | null = null;
    while (queue.length) {
        const cur = queue.shift()!;
        if (prev) prev.next = cur;
        prev = cur;
        if (cur.left) queue.push(cur.left);
        if (cur.right) queue.push(cur.right);
    }
    return root;
}