数据结构和算法-链表
链表分类
- 单向链表
- 双向链表
优点:- 删除某个节点更加高效, 能够快速找到前驱节点
- 能够方便的在某个节点前插入元素
循环链表
当要处理的数据具备环形结构的时候, 适合循环链表. 如约瑟夫环问题node双向循环链表python
数组的缺点是大小固定, 一旦声明长度就要占用连续的内存空间, 当空间不够用时更换更大的空间, 此时就须要将原数组的全部数据迁移过去, 比较费时. 链表则能够动态扩容.算法
数组在查询上能够更快, 链表在插入和删除上更快, 为告终合数组和链表的优势, 有同时使用的状况, 好比一个网站的用户注册, 能够以A-Z为数组, 在每一个字母后面加入链表, 这样能够在添加新用户的时候能快速找到要添加的链表并进行插入, 同时在查询用户的时候也能缩短查询时间数组
常见边界条件
- 链表为空
- 只有一个节点
- 只有两个节点
- 指针在头结点和尾节点的处理
常见问题
- 单链表反转
- 检测链表中是否有环
- 两个有序链表合并
- 删除链表倒数第n个节点
- 求链表的中间节点
单向链表
"""
单链表
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
class SingleLinkedList(object):
def __init__(self):
self.head = None
def is_empty(self):
return self.head == None
def size(self):
current = self.head
num = 0
while current != None:
current = current.next_
num += 1
return num
def prepend(self, value):
"""
在头部添加节点
:param value:
:return:
"""
self.head = Node(value, self.head)
def append(self, value):
"""
在尾部追加节点
:param value:
:return:
"""
node = Node(value)
if self.is_empty():
self.head = node
else:
current = self.head
while current.next_ != None:
current = current.next_
current.next_ = node
def insert(self, position, value):
"""
指定位置插入节点, 从1开始计数
:param position:
:param value:
:return:
"""
if position <= 1:
self.prepend(value)
elif position > self.size():
self.append(value)
else:
node = Node(value)
tmp_pos = 1
pre_node = None
current = self.head
while tmp_pos < position:
pre_node = current
current = current.next_
tmp_pos += 1
node.next_ = current
pre_node.next_ = node
def delete(self, value):
if self.is_empty():
raise Exception("empty")
pre_node = None
current = self.head
while current != None:
if current.data == value:
# 判断删除的元素是否是第一个
if not pre_node:
self.head = current.next_
else:
pre_node.next_ = current.next_
break
else:
pre_node = current
current = current.next_
def pop_first(self):
if self.is_empty():
raise Exception("empty")
data = self.head.data
self.head = self.head.next_
return data
def pop_last(self):
if self.is_empty():
raise Exception("empty")
pre_node = None
current = self.head
while current.next_ != None:
pre_node = current
current = current.next_
data = current.data
if pre_node == None:
self.head = None
else:
pre_node.next = None
return data
def find(self, value):
status = False
current = self.head
while current != None and not status:
if current.data == value:
status = True
else:
current = current.next_
return status
单链表反转
# coding:utf-8
"""
单链表反转
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
def reverse(linked_list):
head = linked_list
pre = None
while head != None:
current = head
head = current.next_
current.next_ = pre
pre = current
return pre
def output(linked_list):
current = linked_list
res = []
while current != None:
res.append(current.data)
current = current.next_
print(res)
if __name__ == '__main__':
link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))
output(link)
root = reverse(link)
output(root)
"""
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
"""
链表成对调换
# coding:utf-8
"""
链表成对调换
1 -> 2 -> 3 -> 4
调换后为
2 -> 1 -> 4 -> 3
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
def swap(head):
if head != None and head.next_ != None:
after = head.next_
head.next_ = swap(after.next_)
after.next_ = head
return after
return head
def output(linked_list):
current = linked_list
res = []
while current != None:
res.append(current.data)
current = current.next_
print(res)
if __name__ == '__main__':
link = Node(1, Node(2, Node(3, Node(4))))
output(link)
print('----')
link1 = swap(link)
output(link1)
"""
[1, 2, 3, 4]
----
[2, 1, 4, 3]
"""
判断是否交叉链表
- 头指针法
- 求出两个链表的长度之差
sub_size - 让较长链表快速走
sub_size步 - 最后依次比较两条链表对应的值是否相等, 相等处则是交点
- 求出两个链表的长度之差
- 分别遍历两个链表, 判断最后一个节点的值是否同样
时间复杂度O(m+n)
判断链表是否有环
定义两个游标first和later, first步长是1, later步长是2. 同时向前走, 若是有环必定会遇到. 复杂度O(n)数据结构
# -*- coding:utf-8 -*-
"""
判断链表是否有环
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
def check(head):
current1 = current2 = head
while True:
current1 = current1.next_ # 指向第一个节点
current2 = current2.next_.next_ # 指向第二个节点
if (not current1) or (not current2):
break
if current1.data == current2.data:
return True
return False
if __name__ == '__main__':
node1 = Node(6)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
node5 = Node(5)
node6 = Node(6)
node1.next_ = node2
node2.next_ = node3
node3.next_ = node4
node4.next_ = node5
node5.next_ = node6
node6.next_ = node3 # 环交点
assert check(node1) == True
查找单链表倒数第k个元素
定义两个指针first, later都初始化指向头节点, 而后first先走k步, 再同时走, 当first到尾节点的时候, 读出later节点的值. 复杂度是O(n)app
# -*- coding:utf-8 -*-
"""
找到链表的倒数第K个元素
定义两个游标, 第二个游标先走k-1步, 以后再同时走, 此时第一个游标停留位置就是倒数第K个元素
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
def find_reverse_k(head, k):
c1 = head
current = head
for _ in range(k - 1):
current = current.next_
c2 = current
while c2.next_ != None:
c2 = c2.next_
c1 = c1.next_
return c1.data
if __name__ == '__main__':
link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))
assert find_reverse_k(link, 3) == 7
assert find_reverse_k(link, 1) == 9
assert find_reverse_k(link, 2) == 8
合并两个有序链表
# coding:utf-8
"""
合并两个有序单链表
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
"""
class Node(object):
def __init__(self, data, next_=None):
self.data = data
self.next_ = next_
def merge2linkedlist(l1, l2):
"""
合并两个有序链表
:param l1:
:param l2:
:return:
"""
if l1 == None and l2 == None:
raise Exception("None!!!")
if l1 == None:
return l2
if l2 == None:
return l1
# 使用head为辅助节点
head = Node(0)
current = head
while l1 and l2:
if l1.data <= l2.data:
current.next_ = l1
l1 = l1.next_
elif l1.data > l2.data:
current.next_ = l2
l2 = l2.next_
current = current.next_
if l1:
current.next_ = l1
if l2:
current.next_ = l2
return head.next_
if __name__ == "__main__":
l1 = Node(1, Node(2, Node(4)))
l2 = Node(1, Node(3, Node(4)))
tmp = merge2linkedlist(l1, l2)
res = []
while tmp:
res.append(tmp.data)
tmp = tmp.next_
print(res)
"""
[1, 1, 2, 3, 4, 4]
"""
合并K个有序单链表
- 方法一
把K个链表2个为一组进行合并, 不断分组, 最后合并为一个有序链表 - 方法二
遍历全部链表将全部元素放在一个数组中, 而后对数组进行排序, 最后生成一个有序链表.
时间复杂度:
若是全部链表共有n个元素, 遍历须要O(n), 对数组排序须要O(nlogn), 最后链接O(n). 因此总的复杂度是O(n + nlogn + n), 也就是O(nlogn)
注意
咱们说空间复杂度的时候, 是指除了本来的数据存储空间外, 算法还须要的额外的存储空间, 即无论原来所占空间是多少网站
资料
- < <漫画算法> >
- < <大话数据结构> >
- < <数据结构与算法> >
相关文章
- 1. Java数据结构和算法——链表
- 2. 数据结构和算法5——链表
- 3. 数据结构和算法：链表（下）
- 4. 数据结构和算法：链表（上）
- 5. Java数据结构和算法 - 链表
- 6. Java数据结构和算法：数组、单链表、双链表
- 7. 【数据结构与算法】--JavaScript 链表
- 8. 数据结构与算法 — 链表
- 9. Java数据结构与算法——链表
- 10. 数据结构与算法 — 单链表
- 更多相关文章...
- • Redis链表（linked-list）数据结构和常用命令 - Redis教程
- • Rust 结构体 - RUST 教程
- • 算法总结-回溯法
- • TiDB 在摩拜单车在线数据业务的应用和实践
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里云，牛客助您找到心仪好工作
- 2. 解决jdbc(jdbctemplate)在测试类时不报错在TomCatb部署后报错
- 3. 解决PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE无法输入中文
- 4. vue+ant design中关于图片请求不显示的问题。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解决IDEA用Maven创建的Web工程不能创建Java Class文件的问题
- 7. [已解决] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea让java文件夹正常使用
- 9. Eclipse启动提示“subversive connector discovery”
- 10. 帅某-技巧-快速转帖博主文章（article_content）
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Java数据结构和算法——链表
- 2. 数据结构和算法5——链表
- 3. 数据结构和算法：链表（下）
- 4. 数据结构和算法：链表（上）
- 5. Java数据结构和算法 - 链表
- 6. Java数据结构和算法：数组、单链表、双链表
- 7. 【数据结构与算法】--JavaScript 链表
- 8. 数据结构与算法 — 链表
- 9. Java数据结构与算法——链表
- 10. 数据结构与算法 — 单链表