Added 21. Merge Two Sorted Lists

Author: manojbaishya

src/main/java/org/dojo/leetcode/LinkedListProblems.java

@@ -1,5 +1,7 @@
 package org.dojo.leetcode;
 
+import static org.dojo.leetcode.SinglyLinkedList.SinglyLinkedListNode;
+
 public class LinkedListProblems {
     public SinglyLinkedListNode addTwoNumbers(SinglyLinkedListNode l1, SinglyLinkedListNode l2) {
         var carryover = 0;
@@ -9,21 +11,17 @@ public SinglyLinkedListNode addTwoNumbers(SinglyLinkedListNode l1, SinglyLinkedL
         SinglyLinkedListNode lm1 = l1;
         SinglyLinkedListNode lm2 = l2;
 
-        while (lm1 != null || lm2 != null)
-        {
+        while (lm1 != null || lm2 != null) {
             int sum;
 
             if (lm1 != null && lm2 != null) sum = lm1.getVal() + lm2.getVal() + carryover;
             else if (lm2 != null) sum = lm2.getVal() + carryover;
             else sum = lm1.getVal() + carryover;
 
-            if (sum > 9)
-            {
+            if (sum > 9) {
                 carryover = 1;
                 sum %= 10;
-            }
-            else
-            {
+            } else {
                 carryover = 0;
             }
 
@@ -38,11 +36,60 @@ public SinglyLinkedListNode addTwoNumbers(SinglyLinkedListNode l1, SinglyLinkedL
             lm2 = (lm2 != null) ? lm2.getNext() : null;
         }
 
-        if (carryover == 1)
-        {
+        if (carryover == 1) {
             sumNode.setNext(new SinglyLinkedListNode(carryover));
         }
 
         return head;
     }
+
+    public SinglyLinkedListNode reverseList(SinglyLinkedListNode head) {
+        SinglyLinkedListNode dummy = null;
+        SinglyLinkedListNode next;
+        while (head != null) {
+            next = head.getNext();
+            head.setNext(dummy);
+            dummy = head;
+            head = next;
+        }
+
+        return dummy;
+    }
+
+    // Slow and Fast Pointers - LinkedList
+    public SinglyLinkedListNode middleNode(SinglyLinkedListNode head) {
+        SinglyLinkedListNode slow = head, fast = head;
+
+        while (fast != null && fast.getNext() != null) {
+            slow = slow.getNext();
+            fast = fast.getNext().getNext();
+        }
+
+        return slow;
+    }
+
+    public SinglyLinkedListNode mergeTwoLists(SinglyLinkedListNode list1, SinglyLinkedListNode list2) {
+        if (list1 == null) return list2;
+        else if (list2 == null) return list1;
+
+        SinglyLinkedListNode l1 = list1, l2 = list2;
+        SinglyLinkedListNode result = list1.getVal() <= l2.getVal() ? list1 : l2;
+        SinglyLinkedListNode tmp = l1.getVal() > l2.getVal() ? l2 : l1;
+        while (l1 != null) {
+            if (l1.getVal() > l2.getVal()) {
+                tmp = l1;
+                l1 = l2;
+                l2 = tmp;
+            }
+            while (l1.getVal() <= l2.getVal()) {
+                tmp = l1;
+                l1 = l1.getNext();
+
+                if (l1 == null) break;
+            }
+            tmp.setNext(l2);
+        }
+
+        return result;
+    }
 }

src/main/java/org/dojo/leetcode/SinglyLinkedList.java

@@ -0,0 +1,47 @@
+package org.dojo.leetcode;
+
+import java.util.Objects;
+
+public class SinglyLinkedList {
+
+    private SinglyLinkedListNode head;
+    public SinglyLinkedListNode getHead() { return head; }
+    public void setHead(SinglyLinkedListNode head) { this.head = head; }
+    public SinglyLinkedList() { this.head = null; }
+
+    public void add(int data) {
+        var newNode = new SinglyLinkedListNode(data);
+
+        if (head == null) {
+            setHead(newNode);
+        } else {
+            SinglyLinkedListNode current = getHead();
+            while (current.getNext() != null) current.setNext(current.getNext());
+            current.setNext(newNode);
+        }
+    }
+    public static class SinglyLinkedListNode {
+        private int val;
+        public int getVal() { return val; }
+        public void setVal(int val) { this.val = val; }
+
+        private SinglyLinkedListNode next;
+        public SinglyLinkedListNode getNext() { return next; }
+        public void setNext(SinglyLinkedListNode next) { this.next = next; }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof SinglyLinkedListNode second)) return false;
+            return getVal() == second.getVal();
+        }
+        @Override
+        public int hashCode() { return Objects.hashCode(getVal()); }
+
+        public SinglyLinkedListNode() { this(0, null); }
+        public SinglyLinkedListNode(int val) { this(val, null); }
+        public SinglyLinkedListNode(int val, SinglyLinkedListNode next) {
+            this.val = val;
+            this.next = next;
+        }
+    }
+}

src/main/java/org/dojo/leetcode/SinglyLinkedListNode.java

@@ -1,5 +1,6 @@
 package org.dojo.leetcode;
 
+import org.dojo.leetcode.SinglyLinkedList.SinglyLinkedListNode;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -9,10 +10,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class LinkedListProblemsTests {
-
     private final LinkedListProblems sut = new LinkedListProblems();
 
-    static Stream<Arguments> inlineData() {
+    static Stream<Arguments> addTwoNumbersData() {
         return Stream.of(
                 Arguments.of(
                         new SinglyLinkedListNode(2, new SinglyLinkedListNode(4, new SinglyLinkedListNode(3))),
@@ -29,14 +29,49 @@ static Stream<Arguments> inlineData() {
     }
 
     @ParameterizedTest
-    @MethodSource("inlineData")
+    @MethodSource("addTwoNumbersData")
     void addTwoNumbers(SinglyLinkedListNode l1, SinglyLinkedListNode l2, SinglyLinkedListNode expected) {
         SinglyLinkedListNode actual = sut.addTwoNumbers(l1, l2);
 
-        while(expected.getNext() != null) {
+        while (expected.getNext() != null) {
             assertEquals(expected, actual);
             expected = expected.getNext();
             actual = actual.getNext();
         }
     }
+
+    static Stream<Arguments> mergeTwoListsData() {
+        return Stream.of(
+                Arguments.of(
+                        linkedListFromArray(new int[] {1, 2, 4}),
+                        linkedListFromArray(new int[] {1, 3, 4}),
+                        linkedListFromArray(new int[] {1, 1, 2, 3, 4, 4})
+                )
+        );
+    }
+    private static SinglyLinkedListNode linkedListFromArray(int[] arr) {
+        if (arr == null || arr.length == 0) return null;
+
+        SinglyLinkedListNode head = new SinglyLinkedListNode(arr[0]);
+        SinglyLinkedListNode current = head;
+
+        for (int i = 1; i < arr.length; i++) {
+            SinglyLinkedListNode newNode = new SinglyLinkedListNode(arr[i]);
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+    @ParameterizedTest
+    @MethodSource("mergeTwoListsData")
+    void mergeTwoLists(SinglyLinkedListNode list1, SinglyLinkedListNode list2, SinglyLinkedListNode expectedList) {
+        SinglyLinkedListNode actual = sut.mergeTwoLists(list1, list2);
+        SinglyLinkedListNode expected = expectedList;
+        while (expected != null) {
+            assertEquals(expected.getVal(), actual.getVal());
+            expected = expected.getNext();
+            actual = actual.getNext();
+        }
+    }
 }