数据结构与算法（二）单链表（Singly linked list）

链表（Linked list）
Python完整功能实现
LeetCode思想实践：

链这个东西大家一定都不陌生, 脖子上有项链, 自行车上有车链, 手表上有表链…

今天我们要研究的单链表的逻辑结构就和他们如出一辙

链表（Linked list）

是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。

链表按照其结构可以分为

单向链表
双向链表
循环链表
块状列表
拓展

链表中最简单的一种是单向链表，它包含两个域，一个信息域(data field)和一个指针域(‘next’ field)。指针域指向链表中的下一个节点。最后一个节点则指向一个空值(None)。可以在单链表上执行的操作包括插入，删除和遍历。

从引用单向链表的首节点的变量可以找到这个表的首节点(图中的data field == 12)，从表中任一结点可以找到保存着该表下一个元素的结点（表中下一结点）。这样，从首节点出发就能找到这个表里的任一个结点。结点之间通过结点链接建立起单向的顺序联系。

我们把保存着首节点链接(引用或标识)的变量成为表头指针或表头变量。

如果一个表头指针的值是空链接，就说明‘它所引用的链接已经结束’，这是没有元素就已结束，说明该表为空表。

我们照例还是用代码实现一遍方便理解

链是由结点构成的, 为了方便操作, 我们先定义一个简单的表结点类:

class LNode(object):                 # 定义一个节点类def __init__(self, value, next_n=None):self.value = valueself.next = next_n

前面已经讲过了, 一个结点包含两个域, data和next.

下面考虑单链表的操作，这里主要关注加入元素和删除元素：

加入元素

有顺序的东西, 当你想插入的时候, 自然要考虑插入的位置, 可以是首端插入、尾端插入或者定位插入。注意, 在插入时, 我们并不需要移动已有的数据, 只需要给新元素一个结点, 改变next的值, 连在正确的位置即可。

首端插入

第一步, 创建我们要插入的结点, 并输入数据;
第二步, 将新结点的next域更新为原来旧表头的链接, 这一操作将原表的一串结点链接在刚创建的新结点之后;
第三部, 将新结点更新为表头指针。

new_node = LNode(new_value)
new_node.next = head
head = new_node

一般位置插入

一般位置插入就要更新位置前后两个结点的next值, 前值指向新结点, 新结点指向后值

new_node = LNode(new_value)
new_node.next = pre.next #前结点原本保存的是后结点的链接,所以直接赋给新结点
pre.next = new_node      #新结点的链接赋值给前结点的next

如果是尾部就不需要更新新结点的next, 默认为None即可

删除元素

插入的逻辑明白之后, 删除自然也就明白了, 就是换next呗

删除首元素

直接将表头后一个元素的链接更新为表头即可, Python解释器会自动回收丢弃的结点

head = head.next

删除其他位置

将要删除的结点的前一个结点的next域修改为要删除的结点的后一个结点的链接即可

pre.next  = pre.next.next
#如果pre是0号结点,那么pre.next对应的是1号结点,pre.next.next就是2号

Python解释器同样会自动回收丢弃的结点

总结一下链表操作的复杂度：

1）创建空表：O(1)
2）删除表：在python中是O(1)。当然，Python解释器做存储管理也需要时间
3）判断空表：O(1)
4）加入元素：
首端加入元素：O(1)
尾端加入元素：O(n)，因为需要找到表的最后结点
定位加入元素：O(n)，平均情况和最坏情况

5）删除元素：
首端删除元素：O(1)
尾端删除元素：O(n)
定位删除元素：O(n)，平均情况和最坏情况\

6）扫描、定位和遍历操作都需要检查一批表结点，其复杂度受到表结点数的约束，都是O(n)操作。

Python完整功能实现

转载一个单链表的实现程序, 将上边的思路完整的捋顺一下

作者：Vico_Men 来源：CSDN
原文：https://blog.csdn.net/qq_28031525/article/details/53583857

class LNode(object):                 # 定义一个节点类def __init__(self, elem, next_=None):self.elem = elemself.next = next_class LinkListUnderflow(ValueError):       # 自定义一个异常passclass Llist(object):                   # 定义一个链表def __init__(self):self._head = Nonedef is_empty(self):                # 判断链表是否为空，通过self._head来判断return self._head is Nonedef prepend(self, elem):           # 在链表的头部加上元素self._head = LNode(elem, self._head)def pop(self):                     # 删除表头节点并返回其中的值if self._head is None:         # 无结点raise LinkListUnderflow('in pop')e = self._head.elemself._head = self._head.nextprint edef append(self, elem):if self._head is None:              # 在链表的结尾处添加元素self._head = LNode(elem)returnp = self._headwhile p.next is not None:p = p.nextp.next = LNode(elem)def pop_last(self):                      # 删除链表最后的一个元素if self._head is None:raise LinkListUnderflow('in pop_last')p = self._headif p.next is None:e = p.elemself._head = Nonereturn ewhile p.next.next is not None:           # 找到链表的倒数第二个节点p = p.nexte = p.next.elemp.next = Nonereturn edef printall(self):              # 自定义打印出来的结果p = self._headwhile p is not None:print p.elemp = p.nextdef rev(self):                   # 列表翻转的操作p = Nonewhile self._head is not None:q = self._headself._head = q.next                 # 摘下原来的首节点q.next = p                          # 将摘下来的节点放到p引用的节点序列中p = qself._head = p                          # 反转的结点序列做好后，重置表头链接def sort1(self):                           # 通过移动表中的元素进行排序if self._head is None:returncart = self._head.next                  # 从首节点之后的结点开始处理while cart is not None:p = self._headx = cart.elemwhile p is not cart and p.elem <= x:    # 跳过小的元素p = p.nextwhile p is not cart:                    # 置换大的元素和现在的值y = p.elemp.elem = xx = yp = p.nextcart.elem = x                           # 回填最后的一个元素cart = cart.next

LeetCode思想实践：

#142 Linked List Cycle II

https://leetcode.com/problems/linked-list-cycle-ii/

给定一个链表找循环起点的游戏

拿到题以后, 就没明白传入的变量是什么, 让人一头雾水

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution(object):def detectCycle(self, head):""":type head: ListNode:rtype: ListNode"""

看到example里的input, 本以为iuput是一个列表!?? 但是!!! 函数传入的类型是ListNode!!! 我一下就没明白这是怎样的一个对应关系, 本以为需要自己拿列表数据做链, 直到我验证了head的内容。

     print(head.val) #得到的结果竟然是3***再测试一下next***print(head.next.val) #得到的结果是2

这也就是说明, 提供给我们的是串好的链!!! 直接干就完了

昨天我们做了#202 Happy Number, 这和今天这题不就是一回事儿吗

昨天我们把平方和后得到的结果放在字典里, 如果 in dict 为 True 就return False

我们把结点放在字典里, 如果 in dict 为 True, 那这个交叉点不就找到了么, 是不是一回事儿

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution(object):def detectCycle(self, head):""":type head: ListNode:rtype: ListNode"""dict = {}while head and head.next:if head in dict:return headelse:dict[head] = 0head = head.nextreturn None

判断单链表中是否有环，找到环的入口节点, 我们可以使用双指针追逐法: 快指针每次移动2, 慢指针每次移动1

如图所示，链表头是X，环的第一个节点是Y，slow和fast第一次的交点是Z。各段的长度分别是a,b,c，如图所示。环的长度是L。

fast先走, 与slow在Z会和是已经走了 a+b+nL (#可能已经循环了n圈)
slow走了 a + b, 因为fast的速度是slow的二倍所以 fast走了 2a+2b

我们可以得到等式 a+b+nL = 2a+2b

所以a = nL -b = c

所以, 当快慢指针相遇时, 再有一指针从表头走, 因为路径长度相同, 所以再次会和时, 所在结点就是交点

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution(object):def detectCycle(self, head):""":type head: ListNode:rtype: ListNode"""slow = fast = headwhile fast and fast.next:slow = slow.nextfast = fast.next.nextif slow == fast:slow = headwhile fast != slow:fast = fast.nextslow = slow.nextreturn fastreturn None

#206 Reverse Linked List

https://leetcode.com/problems/reverse-linked-list/

反转一个单链表, 迭代法和递归法都行

递归我们会在后面讨论

迭代解一下:

class Solution:def reverseList(self, head):""":type head: ListNode:rtype: ListNode"""if head is None:return Nonethis = Nonepre = Nonewhile head:this = head.nexthead.next = prepre = headhead = thisreturn pre

今天的学习到这里就要结束了

感谢那些为我们提供资料的大佬们:

数据结构与算法（单链表） https://blog.csdn.net/qq_28031525/article/details/53583857
python编程（指针） https://blog.csdn.net/feixiaoxing/article/details/79504712
[Leetcode-142] Linked List Cycle II（链表有环详细分析）https://blog.csdn.net/xy010902100449/article/details/48995255
维基百科链表 https://zh.wikipedia.org/wiki/链表

下次见