Leetcode 116. Populating Next Right Pointers in Each Node

最新推荐文章于 2023-11-09 13:02:00 发布

原创最新推荐文章于 2023-11-09 13:02:00 发布 · 140 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#tree #dfs #bfs #recursion

Leetcode 专栏收录该内容

278 篇文章

订阅专栏

本文介绍四种高效算法解决N叉树中相邻节点的连接问题，包括迭代双队列BFS、递归DFS、非递归BFS等方法，并详细解释了每种方法的时间与空间复杂度。

在这里插入图片描述
**方法1:**topDown- bfs-iteration-two queues。时间复杂n，空间复杂n。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

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

class Solution {
    public Node connect(Node root) {
        if(root == null) return root;
        Queue<Node> currLevel = new LinkedList<>();
        Queue<Node> nextLevel = new LinkedList<>();
        nextLevel.offer(root);
        while(!nextLevel.isEmpty()){
            currLevel = new LinkedList<>(nextLevel);
            nextLevel.clear();
            while(!currLevel.isEmpty()){
                Node node = currLevel.poll();
                node.next = currLevel.peek(); 
                if(node.left != null) nextLevel.offer(node.left);
                if(node.right != null) nextLevel.offer(node.right);
            }
        }
        return root;
    }
}

方法2: bottomUp-dfs-postorder-recursion。时间复杂n，空间复杂h。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

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

class Solution {
    public Node connect(Node root) {
        if(root == null) return root;
        if(root.left == null && root.right == null) return root;
        Node left = connect(root.left);
        Node right = connect(root.right);
        connecter(left, right);
        return root;
    }
    
    public void connecter(Node left, Node right){
        while(left != null && right != null){
            left.next = right;
            left = left.right;
            right = right.left;
        }
    }
}

方法3: bottomUp-dfs-preorder-recursion。时间复杂n，空间复杂h。

public void connect(TreeLinkNode root) {
    if(root == null)
        return;
        
    if(root.left != null){
        root.left.next = root.right;
        if(root.next != null)
            root.right.next = root.next.left;
    }
    
    connect(root.left);
    connect(root.right);
}

方法4: topDown-bfs-norecursion。时间复杂n，空间复杂1。这个方法是由方法3演变过来的，很好理解。

class Solution {
    public Node connect(Node root) {
        
        if (root == null) {
            return root;
        }
        
        // Start with the root node. There are no next pointers
        // that need to be set up on the first level
        Node leftmost = root;
        
        // Once we reach the final level, we are done
        while (leftmost.left != null) {
            
            // Iterate the "linked list" starting from the head
            // node and using the next pointers, establish the 
            // corresponding links for the next level
            Node head = leftmost;
            
            while (head != null) {
                
                // CONNECTION 1
                head.left.next = head.right;
                
                // CONNECTION 2
                if (head.next != null) {
                    head.right.next = head.next.left;
                }
                
                // Progress along the list (nodes on the current level)
                head = head.next;
            }
            
            // Move onto the next level
            leftmost = leftmost.left;
        }
        
        return root;
    }
}

总结：