关于链表的常见面试题一 （python详解）_寻找链表循环的起点什么意思 python

关于链表的常见面试题一 （python详解）

1.链表与数组的区别？

• 存储：数组是一种顺序存储的线性表，所有元素的内存地址是连续的；链表是一种链式存储的线性表，所有元素的内存地址不一定连续；
• 访问：数组通过下标可“随机访问”，时间复杂度为O(1),链表需要从第一个元素“顺序访问”,时间复杂度为O(n),
• 当插入或删除元素时数组需要移动大量元素，链表只需修改元素的指针

2.翻转链表（递归、迭代方法）

根据数组创建一个链表，将链表输出

#定义单链表节点
class ListNode:
	def __init__(self,x):
		self.val=x
		self.next=None
#根据数组创建一个单链表
def creat_ListNode(nums):
	head=pre=ListNode(nums[0])
	for num in nums[1:]:
		pre.next=ListNode(num)
		pre=pre.next
	return head
#将链表输出为数组
def print_ListNode(head):
	list_node=[]
	while head:
		list_node.append(head.val)
		head=head.next
	return list_node
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'
运行
运行

   # 反转一个单链表
   # 输入: 1->2->3->4->5->NULL
   # 输出: 5->4->3->2->1->NULL
   #定义单链表节点
   class ListNode:
   	def  __init__(self,x):
   		self.val=x
   		self.next=None
   #反转链表:双指针迭代
   def reverse_ListNode(head):
   	if not head:
   		return 
   	pre,cur=None,head
   	while cur:
   		tmp=cur.next
   		cur.next=pre
   		pre=pre.next
   		cur=tmp
   	return pre
   #递归
  def recursion_reverse(head):
    	#递归终止条件
       if not head or not head.next:
           return head
       #此时的cur为最后一个节点
       cur=self.recursion_reverse(head.next)
       #翻转当前节点
       head.next.next=head
       # 防止链表循环，将head.next设为空
       head.next=None
       #每次递归返回最后一个节点
       return cur
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.链表中是否有环？环的起点？

创建一个带环的链表

#创建一个带环的链表
class ListNode:
	def __init__(self,x):
		self.val=x
		self.next=None
head = ListNode(0)
p1 = ListNode(1)
p2 = ListNode(2)
p3 = ListNode(3)
p4 = ListNode(4)
p5 = ListNode(5)
head.next = p1
p1.next = p2
p2.next = p3
p3.next = p4
p4.next = p5
p5.next = p2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'
运行
运行

快慢指针法：快指针每走两步，慢指针走一步，若相遇则存在环

def exit_loop(head):	
	#定义两个指针
	fast=slow=head
	while fast.next.next and slow,next:
		fast=fast.next.next
		slow=slow.next
		if fast==slow:
			return True
	return False
1
2
3
4
5
6
7
8
9

寻找环的起点：两指针一个从起点出发，一个指针从第一次相遇点出发，两指针再次相遇点即为环的起点

def start_loop(head):
	fast=slow=head
	while fast.next.next and slow.next:
		fast=fast.next.next
		slow=slow.next
	#找到第一次相遇点
		if fast==slow:
			break
 #一个指针从起点出发，另一个从相遇点出发
 	fast=head
 	while fast.next and slow.next:
 		fast,slow=fast.next,slow.next
 		if fast==slow:
 			return slow.val
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.移除链表中的节点

1）移除链表中的指定节点

def remove_node(head,val):
	if not head:
		return head
	if head.val==val:
		return head.next
	pre,cur=head,head.next
	#找到删除节点的位置（cur指针所指的位置）
	while cur and cur.val!=val:
		pre,cur=pre.next,cur.next
	#在遍历链表结束前，找到删除位置
	if cur:
		pre.next=cur.next
	return head
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

2）移除顺序链表中的重复节点

def remove_repeat(head):
	if not head:
		return head
	pre,post=head,head.next
	while post:
	#若两指针节点值相等，删除
		if pre.val==post.val:
			pre.next=post.next
			post=post.next
		#不相等，两指针分别后移
		else:
			pre,post=pre.next,post.next
	return head
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行