Merge k Sorted Lists

Author: volodimyr

23.merge_k_sorted_lists/merge.go

@@ -0,0 +1,92 @@
+// 23. Merge k Sorted Lists
+// Topics: 'Linked List', 'Divide and Conquer', 'Heap (Priority Queue)', 'Merge Sort'
+// Level: 'Hard'
+
+// You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.
+
+// Merge all the linked-lists into one sorted linked-list and return it.
+
+// Example 1:
+
+// Input: lists = [[1,4,5],[1,3,4],[2,6]]
+// Output: [1,1,2,3,4,4,5,6]
+// Explanation: The linked-lists are:
+// [
+//   1->4->5,
+//   1->3->4,
+//   2->6
+// ]
+// merging them into one sorted linked list:
+// 1->1->2->3->4->4->5->6
+
+// Example 2:
+
+// Input: lists = []
+// Output: []
+
+// Example 3:
+
+// Input: lists = [[]]
+// Output: []
+
+// Constraints:
+
+//     k == lists.length
+//     0 <= k <= 104
+//     0 <= lists[i].length <= 500
+//     -104 <= lists[i][j] <= 104
+//     lists[i] is sorted in ascending order.
+//     The sum of lists[i].length will not exceed 104.
+
+package mergeksortedlists
+
+func mergeKLists(lists []*ListNode) *ListNode {
+	if len(lists) < 1 {
+		return nil
+	}
+	if len(lists) == 1 {
+		return lists[0]
+	}
+
+	return mergeRange(lists, 0, len(lists)-1)
+}
+
+func mergeRange(lists []*ListNode, L, R int) *ListNode {
+	if L == R {
+		return lists[L]
+	}
+	mid := (L + R) / 2
+	left := mergeRange(lists, L, mid)
+	right := mergeRange(lists, mid+1, R)
+	return merge(left, right)
+}
+
+func merge(list1, list2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+
+	cur := dummy
+	cur1 := list1
+	cur2 := list2
+	for cur1 != nil && cur2 != nil {
+		if cur1.Val < cur2.Val {
+			cur.Next = cur1
+			cur1 = cur1.Next
+		} else {
+			cur.Next = cur2
+			cur2 = cur2.Next
+		}
+		cur = cur.Next
+	}
+
+	if cur1 != nil {
+		cur.Next = cur1
+	} else if cur2 != nil {
+		cur.Next = cur2
+	}
+	return dummy.Next
+}
+
+type ListNode struct {
+	Next *ListNode
+	Val  int
+}

23.merge_k_sorted_lists/merge_test.go

@@ -0,0 +1,127 @@
+package mergeksortedlists
+
+import (
+	"reflect"
+	"testing"
+)
+
+func buildList(nums []int) *ListNode {
+	if len(nums) == 0 {
+		return nil
+	}
+	head := &ListNode{Val: nums[0]}
+	cur := head
+	for _, v := range nums[1:] {
+		cur.Next = &ListNode{Val: v}
+		cur = cur.Next
+	}
+	return head
+}
+
+func listToSlice(head *ListNode) []int {
+	var res []int
+	for head != nil {
+		res = append(res, head.Val)
+		head = head.Next
+	}
+	return res
+}
+
+func TestMergeKLists(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  [][]int
+		expect []int
+	}{
+		{
+			name:   "example1",
+			input:  [][]int{{1, 4, 5}, {1, 3, 4}, {2, 6}},
+			expect: []int{1, 1, 2, 3, 4, 4, 5, 6},
+		},
+		{
+			name:   "single list",
+			input:  [][]int{{1, 2, 3}},
+			expect: []int{1, 2, 3},
+		},
+		{
+			name:   "lists with duplicates",
+			input:  [][]int{{1, 1, 2}, {1, 3}, {2, 2}},
+			expect: []int{1, 1, 1, 2, 2, 2, 3},
+		},
+		{
+			name:   "different lengths",
+			input:  [][]int{{1}, {2, 3, 4}, {5, 6}},
+			expect: []int{1, 2, 3, 4, 5, 6},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var lists []*ListNode
+			for _, arr := range tt.input {
+				lists = append(lists, buildList(arr))
+			}
+
+			out := mergeKLists(lists)
+			got := listToSlice(out)
+
+			if !reflect.DeepEqual(got, tt.expect) {
+				t.Fatalf("expected %v, got %v", tt.expect, got)
+			}
+		})
+	}
+}
+
+func TestMerge(t *testing.T) {
+	tests := []struct {
+		name   string
+		list1  []int
+		list2  []int
+		expect []int
+	}{
+		{
+			name:   "both non-empty",
+			list1:  []int{1, 3, 5},
+			list2:  []int{2, 4, 6},
+			expect: []int{1, 2, 3, 4, 5, 6},
+		},
+		{
+			name:   "first list empty",
+			list1:  []int{},
+			list2:  []int{1, 2, 3},
+			expect: []int{1, 2, 3},
+		},
+		{
+			name:   "second list empty",
+			list1:  []int{1, 2, 3},
+			list2:  []int{},
+			expect: []int{1, 2, 3},
+		},
+		{
+			name:   "lists with duplicates",
+			list1:  []int{1, 2, 2},
+			list2:  []int{1, 2, 3},
+			expect: []int{1, 1, 2, 2, 2, 3},
+		},
+		{
+			name:   "different lengths",
+			list1:  []int{1, 4, 7, 10},
+			list2:  []int{2, 3},
+			expect: []int{1, 2, 3, 4, 7, 10},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l1 := buildList(tt.list1)
+			l2 := buildList(tt.list2)
+
+			out := merge(l1, l2)
+			got := listToSlice(out)
+
+			if !reflect.DeepEqual(got, tt.expect) {
+				t.Fatalf("expected: %v, got: %v", tt.expect, got)
+			}
+		})
+	}
+}