g2101_2200.s2181_merge_nodes_in_between_zeros.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g2101_2200.s2181_merge_nodes_in_between_zeros;

// #Medium #Simulation #Linked_List #2022_06_02_Time_6_ms_(96.26%)_Space_71.2_MB_(97.95%)

import com_github_leetcode.ListNode;

/*
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * 2181 - Merge Nodes in Between Zeros\.
 *
 * Medium
 *
 * You are given the `head` of a linked list, which contains a series of integers **separated** by `0`'s. The **beginning** and **end** of the linked list will have `Node.val == 0`.
 *
 * For **every** two consecutive `0`'s, **merge** all the nodes lying in between them into a single node whose value is the **sum** of all the merged nodes. The modified list should not contain any `0`'s.
 *
 * Return _the_ `head` _of the modified linked list_.
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2022/02/02/ex1-1.png)
 *
 * **Input:** head = [0,3,1,0,4,5,2,0]
 *
 * **Output:** [4,11]
 *
 * **Explanation:**
 *
 * The above figure represents the given linked list. The modified list contains
 *
 * - The sum of the nodes marked in green: 3 + 1 = 4.
 *
 * - The sum of the nodes marked in red: 4 + 5 + 2 = 11. 
 *
 * **Example 2:**
 *
 * ![](https://assets.leetcode.com/uploads/2022/02/02/ex2-1.png)
 *
 * **Input:** head = [0,1,0,3,0,2,2,0]
 *
 * **Output:** [1,3,4]
 *
 * **Explanation:**
 *
 * The above figure represents the given linked list. The modified list contains
 *
 * - The sum of the nodes marked in green: 1 = 1.
 *
 * - The sum of the nodes marked in red: 3 = 3.
 *
 * - The sum of the nodes marked in yellow: 2 + 2 = 4. 
 *
 * **Constraints:**
 *
 * *   The number of nodes in the list is in the range [3, 2 * 10⁵].
 * *   `0 <= Node.val <= 1000`
 * *   There are **no** two consecutive nodes with `Node.val == 0`.
 * *   The **beginning** and **end** of the linked list have `Node.val == 0`.
**/
public class Solution {
    public ListNode mergeNodes(ListNode head) {
        ListNode temp = head.next;
        ListNode slow = head;
        int sum = 0;
        ListNode fast = temp;
        while (temp != null) {
            if (temp.val == 0) {
                temp.val = sum;
                sum = 0;
                slow.next = fast.next;
                slow = temp;
                fast = fast.next;
            } else {
                sum += temp.val;
                fast = temp;
            }
            temp = temp.next;
        }
        return head.next;
    }
}