前文介绍了一些链表的基础知识,不熟悉的同学可以去看看,有了知识后,没有操作怎么行,所以今天给大家分析几个链表的经典问题,面试也是经常出现,废话不多说,我们一个个讲,重点补充一下,以下例子都是有链表头的,并都是用Golang。
一、链表倒置
这里介绍两种方法,头插入法和递归发。
1、head插入发
基本思想就是从头到尾遍历列表,每遍历一个节点,都插入到head后,直到链尾。看图:
代码:
type ListNode struct {
value interface{}
next *ListNode
}
type SingleLinkList struct {
head *ListNode
len uint
}
// 含链表头
func (s *SingleLinkList) Reverse() bool {
if s.head.next == nil {
return true
}
cur := s.head.next
p := cur.next
cur.next = nil
s.head.next = cur
for nil != p {
tmp := p.next
tmp1 := s.head.next
s.head.next = p
p.next = tmp1
p = tmp
}
return true
}
2、递归法
既然可以使用递归法,那我们根据递归法的条件来分析这个题目。
1、是否存在终止条件
如果链表无节点或者只有一个节点,则无需反转,直接返回当前节点
if head == nil || head.next == nil {
return head
}
2、是否能分为多个规模更小的子问题,并且子问题的解法一致
有一个链表: A->B->C, 将B->C看成一个已经反转后的整体K, 即A->K,那么问题就变为 A 和 K之间的反转,代码如下:
A = head.next
A.next = K
head.next = nil
所以问题就转化成B->C之间的反转,这也是两个节点的反转,与A->K的解法是相同的,而且从三个节点的问题 转化为两个节点问题,规模更小了。所以我们可以总结出递归公式如下:
head.next.next = head
head.next = nil
通过以上分析,代码如下:
func Reverse2(head *ListNode) *ListNode {
if head == nil || head.next == nil {
return head
}
newHead := Reverse2(head.next)
head.next.next = head
head.next = nil
return newHead
}
二、链表中环的检测
环的检测很简单,我们设计两个指针,一个快指针,一个慢指针,如果链表中有环,那么快慢指针肯定会相遇,反之则无环。另外注意链尾的判断,如果有遇到,则表示没有环。
代码:
type ListNode struct {
value interface{}
next *ListNode
}
type SingleLinkList struct {
head *ListNode
len uint
}
func (s *SingleLinkList) HasLoop() bool {
if s.head == nil || s.head.next == nil {
return false
}
pFast := s.head.next
pSlow := s.head.next
for pFast.next != nil {
pFast = pFast.next.next
if pFast == nil {
break
}
pSlow = pSlow.next
if pSlow == nil {
break
}
if pSlow == pFast {
return true
}
}
return false
}
三、两个有序的链表合并
1. 非递归法
从图可得,合并的基本思想是,遍历链表,并一一比较节点值,哪个小,指针就指向哪个,直到某个链表达到链尾。
代码:
type ListNode struct {
value interface{}
next *ListNode
}
type SingleLinkList struct {
head *ListNode
len uint
}
func MergeTwoLinkList(l1 *SingleLinkList, l2 *SingleLinkList) *SingleLinkList {
if l1.head == nil || l1.head.next == nil {
return l2
}
if l2.head == nil || l2.head.next == nil {
return l1
}
cur1 := l1.head.next
cur2 := l2.head.next
result := NewSingleLink()
n := result.head
for cur1 != nil && cur2 != nil {
if cur1.value.(int) <= cur2.value.(int) {
n.next = cur1
cur1 = cur1.next
} else {
n.next = cur2
cur2 = cur2.next
}
result.len++
n = n.next
}
if cur1 == nil {
n.next = cur2
}
if cur2 == nil {
n.next = cur1
}
return result
}
2、递归法
我们还是按照递归的条件来对问题进行分析:
1、是否有终止条件
如果两个合并链表都无节点,则不需要合并,任意返回一个即可。如果一个链表是空节点,则直接返回另外一个,终止条件如下:
if n1 == nil {
return n2
}
if n2 == nil {
return n1
}
2、是否能分为多个规模更小的子问题,并且子问题的解法一致
我们假设两个链表只有一个节点,那么问题就简化为,比较两个节点的大小,小的先连,大得后连,那么扩展到N个节点,我们是否也可以将问题简化到只比较两个节点问题呢? 当然可以,我们可以假设除了两个节点之外,其他节点已经合并,这样就问题的解法是一致。问题化解过程,请具体看图:
从图中可以看到,问题最后就是值为4的两个节点在比较。由此可以得出递推公式:
if n1.value.(int) <= n2.value.(int) {
return n1
} else {
return n2
}
所以根据终止条件和递推公式,代码如下:
func MergeTwoLinkList2(n1 *ListNode, n2 *ListNode) *ListNode {
if n1 == nil {
return n2
}
if n2 == nil {
return n1
}
if n1.value.(int) <= n2.value.(int) {
n1.next = MergeTwoLinkList2(n1.next, n2)
return n1
} else {
n2.next = MergeTwoLinkList2(n1, n2.next)
return n2
}
}
四、总结
最后还是强调,写链表还是得多写,写多了自然而然就熟悉了。以上三个例子,抛砖引玉,进一步提升大家可以去leetcode上练习。另外此文也讲了一些递归算法的分析方法,具有一定的普世性,大家可以参考分析,以免落入脑容量不够的境地。最后留个作业:如果去掉链表头,如何写上面上个例子。
五、参考文献
1. Finding the Start of a Loop in a Circular Linked List
2. https://en.wikipedia.org/wiki/Linked_list
欢迎关注公众号: