探索Go语言链表奥秘——每日一练系列(五)超越O(n^2)的合并策略

前端

2023-11-15 09:26:43

链表合并：从O(n²)到O(nlogn)的进阶之旅

堆：高效合并的利器

链表，作为数据结构家族中的常青树，以其灵活性与高效性著称。然而，当我们面临链表合并这一任务时，却不得不面对O(n²)的时间复杂度这一拦路虎。

传统的方法是遍历所有链表并逐个合并，但这种朴素的策略却难以逃脱算法效率的桎梏。就像一群登山者，他们每个人都一步一步地攀登，看似简单粗暴，却无法摆脱缓慢的步伐。

于是，我们另辟蹊径，将目光投向了堆这一高效的数据结构。堆，凭借其独特的特性，能够帮助我们以O(nlogn)的时间复杂度完成链表合并，犹如一群登山者巧妙地利用缆车，轻松登顶。

我们首先对各链表的头节点构建一个小顶堆，该堆将按照节点值的大小进行排列，就像是一座由数字组成的金字塔，最小值稳坐塔尖。

接下来，我们不断地从堆中弹出最小的节点，就像从金字塔顶端逐层剥离，并将该节点添加到结果链表中，犹如一条蜿蜒的小溪汇聚成奔腾的河流。

通过这种巧妙的策略，我们巧妙地将链表合并问题转化为了堆排序问题，从而实现了更为高效的合并策略，就像将登山过程变为缆车畅游。

堆泛型：Go语言中的锦上添花

Go语言作为一门现代化的编程语言，内置了泛型这一强大特性，犹如为堆数据结构锦上添花。泛型就像是一种神奇的配方，它允许我们定义通用的堆类型，而不必针对每个具体的链表节点类型编写独立的堆实现。

举个例子，在使用堆泛型之前，我们需要为每个具体的链表节点类型编写独立的堆实现，就像为每种口味的冰淇淋制作不同的蛋筒。然而，有了堆泛型，我们只需编写一次通用堆实现，即可适用于任何链表节点类型，就像一个万能蛋筒，可以盛放各种口味的冰淇淋。

此外，堆泛型还提高了代码的可读性和可维护性。通过使用堆泛型，我们能够更加清晰地表达代码的意图，就像使用明了的语言登山路线，同时减少代码的冗余和重复，犹如精简登山装备，减轻负重。

代码实现：从理论到实践

type Node[T any] struct {
	Val  T
	Next *Node[T]
}

type Heap[T any] struct {
	arr []T
	less func(i, j T) bool
}

func (h *Heap[T]) Push(val T) {
	h.arr = append(h.arr, val)
	h.up(len(h.arr) - 1)
}

func (h *Heap[T]) Pop() T {
	if len(h.arr) == 0 {
		panic("heap is empty")
	}
	top := h.arr[0]
	h.arr[0] = h.arr[len(h.arr)-1]
	h.arr = h.arr[:len(h.arr)-1]
	h.down(0)
	return top
}

func (h *Heap[T]) up(i int) {
	for i > 0 {
		p := (i - 1) / 2
		if h.less(h.arr[p], h.arr[i]) {
			break
		}
		h.arr[p], h.arr[i] = h.arr[i], h.arr[p]
		i = p
	}
}

func (h *Heap[T]) down(i int) {
	for {
		l := 2*i + 1
		r := 2*i + 2
		smallest := i
		if l < len(h.arr) && h.less(h.arr[l], h.arr[smallest]) {
			smallest = l
		}
		if r < len(h.arr) && h.less(h.arr[r], h.arr[smallest]) {
			smallest = r
		}
		if smallest == i {
			break
		}
		h.arr[i], h.arr[smallest] = h.arr[smallest], h.arr[i]
		i = smallest
	}
}

func mergeKLists(lists []*Node[int]) *Node[int] {
	h := &Heap[int]{
		arr:  make([]int, 0),
		less: func(i, j int) bool { return i < j },
	}
	for _, head := range lists {
		for head != nil {
			h.Push(head.Val)
			head = head.Next
		}
	}
	dummy := &Node[int]{}
	curr := dummy
	for len(h.arr) > 0 {
		curr.Next = &Node[int]{Val: h.Pop()}
		curr = curr.Next
	}
	return dummy.Next
}