leetcode: up exercise merge two sort linkedlist

Author: sangtrandev00

src/leetcode/linked_list/merge-two-lists.test.ts

@@ -0,0 +1,42 @@
+// ... existing code ...
+import { describe, it, expect } from "bun:test";
+import { mergeTwoLists, ListNode } from "./merge-two-lists";
+
+// Unit tests for mergeTwoLists function
+describe('mergeTwoLists', () => {
+ it('should return null when both lists are empty', () => {
+ expect(mergeTwoLists(null, null)).toBeNull();
+ });
+
+ it('should return the non-empty list when one list is empty', () => {
+ const list1 = new ListNode(1, new ListNode(2));
+ expect(mergeTwoLists(list1, null)).toEqual(list1);
+ expect(mergeTwoLists(null, list1)).toEqual(list1);
+ });
+
+ it('should merge two sorted lists', () => {
+ const list1 = new ListNode(1, new ListNode(2, new ListNode(4)));
+ const list2 = new ListNode(1, new ListNode(3, new ListNode(4)));
+ const mergedList = mergeTwoLists(list1, list2);
+
+ expect(mergedList).toEqual(new ListNode(1, new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(4)))))));
+ });
+
+ it('should handle lists with duplicate values', () => {
+ const list1 = new ListNode(1, new ListNode(1));
+ const list2 = new ListNode(1, new ListNode(1));
+ const mergedList = mergeTwoLists(list1, list2);
+
+ expect(mergedList).toEqual(new ListNode(1, new ListNode(1, new ListNode(1, new ListNode(1)))));
+ });
+
+ it('should handle lists with different lengths', () => {
+ const list1 = new ListNode(1, new ListNode(3));
+ const list2 = new ListNode(2);
+ const mergedList = mergeTwoLists(list1, list2);
+
+ expect(mergedList).toEqual(new ListNode(1, new ListNode(2, new ListNode(3))));
+ });
+});
+
+// ... existing code ...

src/leetcode/linked_list/merge-two-lists.ts

@@ -10,7 +10,7 @@
  * }
  */
 
-class ListNode {
+export class ListNode {
  val: number
  next: ListNode | null
  constructor(val?: number, next?: ListNode | null) {
@@ -19,37 +19,38 @@ class ListNode {
  }
 }
 
-function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+// Time complexity O(n + m), n: list1, m: list2
+export function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+ if (list1 == null) return list2
+ if (list2 == null) return list1
 
- let firstItemList1 = list1
- let firstItemList2 = list2
 
  let node: ListNode | null = {
  val: 0,
  next: null
  }
+ // Gán giá trị đầu tiên
+ if (list1.val > list2.val) {
+ node = new ListNode(list2.val)
+ list2 = list2.next
+ } else {
+ node = new ListNode(list1.val)
+ list1 = list1.next
+ }
+ let pointer = node
 
- let temp: any = null
- let holder: any = node
- while ((firstItemList1 as any).next && (firstItemList2 as any).next) {
- if (firstItemList1 != undefined && firstItemList1.val < (firstItemList2 as any).val) {
- holder.val = firstItemList1.val
- firstItemList1 = firstItemList1.next
- if (temp) {
- holder.next = temp
- }
- temp = holder
+ // So sánh với các giá trị tiếp theo. Liên quan đến bộ nhớ của LinkedList nữa!
+ while (list1 || list2) {
+ if ((list1 != null && list2 != null && (list1.val < list2.val)) || list2 == null) {
+ const newNode = new ListNode(list1?.val)
+ pointer.next = newNode
+ pointer = newNode
+ list1 = list1?.next ?? null
  } else {
- holder.val = firstItemList2?.val ?? 0
- firstItemList2 = firstItemList2?.next ?? null
- if (temp) {
- holder.next = temp
- }
- temp = holder
- }
- holder.next = {
- val: 0,
- next: null
+ const newNode = new ListNode(list2?.val)
+ pointer.next = newNode
+ pointer = newNode
+ list2 = list2?.next ?? null
  }
  }
  return node
@@ -58,4 +59,4 @@ function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode
 
 const list1 = new ListNode(1, new ListNode(2, new ListNode(4, null)))
 const list2 = new ListNode(1, new ListNode(3, new ListNode(4, null)))
-mergeTwoLists(list1, list2)
+console.log("mergeTwoLists(list1, list2)", mergeTwoLists(list1, list2));