chore: Merge pull request #4 from saulmaldonado/feat/merge-two-sorted-lists

merge two sorted lists

Author: saulmaldonado

linked-lists/merge-two-sorted-lists/README.md

@@ -0,0 +1,49 @@
+# Merge Two Sorted Lists
+
+![difficulty](https://img.shields.io/badge/easy-5cb85c?style=for-the-badge&logoColor=white)
+
+## Problem:
+
+Merge two sorted linked lists and return it as a sorted list. The list should be made by splicing together the nodes of the first two lists.
+
+### Example 1:
+
+```
+Input: l1 = [1,2,4], l2 = [1,3,4]
+Output: [1,1,2,3,4,4]
+```
+
+### Example 2:
+
+```
+Input: l1 = [], l2 = []
+Output: []
+```
+
+### Example 3:
+
+```
+Input: l1 = [], l2 = [0]
+Output: [0]
+```
+
+### Constraints
+
+`The number of nodes in both lists is in the range [0, 50].`
+
+`-100 <= Node.val <= 100`
+
+`Both l1 and l2 are sorted in non-decreasing order.`
+
+<details>
+  <summary>Solutions (Click to expand)</summary>
+
+### Explanation
+
+Create a `sentinel` or `dummy` node to that will point to the beginning of our new linked list. Iterate through both linked lists at the same time using two different pointers comparing the value of the currently referenced nodes. Taking the smallest of the two nodes, link the node to the current node pointer of the new linked list. Continue this until one pointer reaches the end of the their list. Link the remaining part of the longer list to the end of the new list as it is already sorted. Return the new list by referencing the next node of the dummy node
+
+- [JavaScript](./merge-two-sorted-lists.js)
+- [TypeScript](./merge-two-sorted-lists.ts)
+- [Java](./merge-two-sorted-lists.java)
+- [Go](./merge-two-sorted-lists.go)
+</details>

linked-lists/merge-two-sorted-lists/merge-two-sorted-lists.go

@@ -0,0 +1,45 @@
+package mergetwosortedlists
+
+// ListNode is a node for a Linked List
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+	i := l1
+	j := l2
+
+	dummyNode := &ListNode{}
+	currentNode := dummyNode
+
+	for i != nil && j != nil {
+		iVal := i.Val
+		jVal := j.Val
+
+		if iVal <= jVal {
+			currentNode.Next = i
+			currentNode = currentNode.Next
+			i = i.Next
+		} else {
+			currentNode.Next = j
+			currentNode = currentNode.Next
+			j = j.Next
+		}
+	}
+
+	if i != nil {
+		currentNode.Next = i
+	} else {
+		currentNode.Next = j
+	}
+
+	return dummyNode.Next
+}

linked-lists/merge-two-sorted-lists/merge-two-sorted-lists.java

@@ -0,0 +1,48 @@
+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;
+  }
+}
+
+class Solution {
+  public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+    ListNode i = l1;
+    ListNode j = l2;
+    ListNode dummy = new ListNode(0, l1);
+    ListNode currentNode = dummy;
+
+    while (i != null && j != null) {
+      int iValue = i.val;
+      int jValue = j.val;
+
+      if (iValue <= jValue) {
+        currentNode.next = i;
+        currentNode = currentNode.next;
+        i = i.next;
+      } else {
+        currentNode.next = j;
+        currentNode = currentNode.next;
+        j = j.next;
+      }
+    }
+
+    if (i != null) {
+      currentNode.next = i;
+    } else {
+      currentNode.next = j;
+    }
+
+    return dummy.next;
+  }
+}

linked-lists/merge-two-sorted-lists/merge-two-sorted-lists.js

@@ -0,0 +1,52 @@
+class ListNode {
+  val;
+  next;
+
+  constructor(val, next) {
+    this.val = val;
+    this.next = next;
+  }
+}
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+function mergeTwoLists(l1, l2) {
+  let i = l1;
+  let j = l2;
+
+  const dummyNode = new ListNode();
+  let currentNode = dummyNode;
+
+  while (i !== null && j !== null) {
+    const iVal = i.val;
+    const jVal = j.val;
+
+    if (iVal <= jVal) {
+      currentNode.next = i;
+      currentNode = currentNode.next;
+      i = i.next;
+    } else {
+      currentNode.next = j;
+      currentNode = currentNode.next;
+      j = j.next;
+    }
+  }
+
+  if (i !== null) {
+    currentNode.next = i;
+  } else {
+    currentNode.next = j;
+  }
+
+  return dummyNode.next;
+}

linked-lists/merge-two-sorted-lists/merge-two-sorted-lists.ts

@@ -0,0 +1,40 @@
+class ListNode {
+  val: number;
+  next: ListNode | null;
+
+  constructor(val?: number, next?: ListNode | null) {
+    this.val = val ?? 0;
+    this.next = next ?? null;
+  }
+}
+
+function mergeTwoLists(l1: ListNode | null, l2: ListNode | null) {
+  let i: ListNode | null = l1;
+  let j: ListNode | null = l2;
+
+  const dummyNode = new ListNode();
+  let currentNode: ListNode | null = dummyNode;
+
+  while (i !== null && j !== null) {
+    const iVal: number = i.val;
+    const jVal: number = j.val;
+
+    if (iVal <= jVal) {
+      currentNode.next = i;
+      currentNode = currentNode.next;
+      i = i.next;
+    } else {
+      currentNode.next = j;
+      currentNode = currentNode.next;
+      j = j.next;
+    }
+  }
+
+  if (i !== null) {
+    currentNode.next = i;
+  } else {
+    currentNode.next = j;
+  }
+
+  return dummyNode.next;
+}