python-链表练习，还不做做吗？

一、删除链表中的节点，且只能访问该节点

只能访问该节点的话，那该节点的上一个节点我们是无法访问的。一般我们的思路是这样的，如果我们要删除节点b，那么我们需要用a节点的next指向b节点next指向的c节点，那么就做好了删除节点的操作了，被删除的节点会被python的垃圾回收机制处理

但是，现在的问题是，我们没有办法访问到a节点，只能从b节点向后访问，那么就需要我们换一个角度了
将c节点的值赋值给b节点，然后将b节点的next指向c的next，这样间接的实现了删除b节点的操作

思路有了，代码的实现是比较简单的

def remove_node(node):
    print(node.value)
    node.value = node.next.value
    node.next = node.next.next
    print(node.value)
    while node.next != None:
        node = node.next
        print(node.value)

二、找到链表当中的中间节点

中间节点的查找我们可能第一反应就是获取链表的长度，然后折半，这样就能找到中间节点了，这个思路是没问题的，但是有时候条件可能不是那么友好，如果加入一个限制条件，不允许我们使用链表的长度。这应该怎么办呢？
我们可以设置两个pointer，第一个pointer移动的距离是第二个pointer的2倍，那么，当第一个pointer遍历完整个链表之后，第二个pointer正好到达中间节点，此时输出第二个pointer

上代码

def find_middle_node(node):
	
	assert node.head.next is not None and node.head is None
	
	a1 = node.head  # 第一个pointer
	b1 = node.head  # 第二个pointer
	while a1.next != None and a1.next.next != None:
		a1 = a1.next.next
		b1 = b1.next
	print(b1.value)

三、判断一个链表是否有环

一个链表有环的情况无非就是两种


思路：可以准备两个pointer，第一个pointer走的快，第二个pointer走的慢，当第一个pointer追上第二个pointer的时候，说明有环，为什么呢？当pointer的next为None的时候，说明链表已经走完，此时一定无环.

上代码：

def has_cycle(node):
	if node is None:
		print('has no cycle')
	fast = node
	slow = node

	while fast != None and fast.next != None:
		fast = fast.next.next
		slow = slow.next

		if fast == slow :
			print('has cycle!')
			break
node1 = Node(1)
node2 = Node(10)
node3 = Node(6)
node1.next = node2
node2.next = node3
node3.next = node1
has_cycle(node1)
node1 = Node(10)
node2 = Node(20)
node3 = Node(50)
node1.next = node2
node2.next = node3
node3.next = node2
has_cycle(node1)
node1 = Node(102)
node2 = Node(204)
node3 = Node(504)
node1.next = node2
node2.next = node3
has_cycle(node1)

结果

四、给定一个循环链表，找到环的开始节点

一个循环链表的环的判定，有两种情况:
左侧是情况1，开始节点和结束节点是重合的
右侧是情况2，环的开始节点在链表的中间部分

情况1的思路跟上一道题的思路是一样的，可以准备两个pointer，fast_pointer每次走两个，slow_pointer每次走一个，当fast_pointer追上slow_pointer的时候，就找到了环的开始节点了

下面附上情况1的代码：

def find_the_node_of_beginCycle(node):
	fast = node
	slow = node
	while fast is not None and fast.next is not None:
		fast = fast.next.next
		slow = slow.next

		if fast == slow:
			return fast
			break
n1 = Node(10)
n2 = Node(20)
n3 = Node(4)
n4 = Node(5)
n1.next , n2.next, n3.next, n4.next = n2, n3, n4, n1
res = find_the_node_of_beginCycle(n1)
print('the begin node value : %s'%res.value)

情况2的思路需要好好分析分析了
假设情况2的链表当中环的开始节点在a点，链表开始节点到环的开始节点距离是k，那么当slow_pointer走到a点的时候,fast_pointer已经走到了距离a点向后的k个距离处，那么什么时候相遇呢？如下图所示：

首先，我们清楚的是fast_pointer的速度是slow_pointer的两倍，当fast_pointer转了一圈的之后，slow_pointer只走了半圈，这个时候是无法相遇的，那么就需要继续向后再走，当slow_pointer走完剩下的半圈的之后，fast_pointer又走了一圈，那么在这期间两个pointer相遇了，那相遇的点在哪呢？在上图所示的b点，距离a点为k.
当slow_pointer走完一圈，fast_pointer走了两圈之后，这两个指针回到原来的位置，此时slow_pointer和fast_pointer相差k,从当前状态开始，让slow_pointer和fast_pointer保持之前的速度向反方向移动，那么当slow_pointer走到b点的时候经过k个距离，fast_pointer也走到了b点，距离为2k，正好相遇，此时，整个链表中会出现三个k值

这个时候，将slow_pointer挪到起始点，fast_pointer在b点不动,两个pointer都以一个速度依次向前遍历，当两个pointer相遇的时候就找到了链表的环的开始节点

下面附上情况2的代码：

def find_the_node_of_beginCycle(node):
	fast = node
	slow = node
	while fast != None and fast.next != None:
		fast = fast.next.next
		slow = slow.next
		
		if fast == slow:
			fast = node
			break
	while fast != slow:
		fast = fast.next
		slow = slow.next
	return slow

n1 = Node(10)
n2 = Node(20)
n3 = Node(4)
n4 = Node(5)
n5 = Node(44)
n6 = Node(7)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
n6.next = n3
res = find_the_node_of_beginCycle(n1)
print('the begin node value:%s'%res.value)

五、删除一个链表中的倒数第N个节点

第一印象的话我们可能会去想得到链表的size，然后用size-n获取它的位置，通过指向要删除的节点的next来删除倒数第N个节点。但是如果不能获取size呢？

还是那个思路，准备两个pointer，fast_pointer先走N个节点之后slow_pointer开始走,当fast_pointer走完链表之后，slow_pointer的位置就是要删除的节点

上代码:

def delete_the_nth_to_last(list, n):
	fast = list.head
	slow = list.head
	while n > 0:
		fast = fast.next
		n -= 1
	while fast.next is not None:
		fast = fast.next
		slow = slow.next
	res = slow
	res.next = slow.next.next
	list.size -= 1

L = LinkedList()
L.insert_first(4)
L.insert_first(23)
L.insert_first(66)
L.insert_first(89)
L.insert_first(75)
L.print_linkedList()
delete_the_nth_to_last(L, 2)
L.print_linkedList()

六、给定一个链表，分成两个链表

如果是偶数个节点直接对半即可，如果是奇数个节点，返回靠前的节点位置
分成两个链表的话需要三个pointer,fast_pointer遍历的速度是slow_pointer的2倍，mid_pointer的速度和slow_pointer是一致的，当fast_pointer遍历完链表之后，slow_pointe和mid_pointer也就到达了链表的中间位置，然后创建一个新的链表L1，将L1的next指向左侧的链表，再创建一个新的链表L2,将L2的next指向mid_pointer.next，mid_pointer.next指向None.

下图所示的链表的操作是偶数个节点的，奇数个节点同理

代码如下：

def split_LinkedList(node):
	fast = node
	slow = node
	mid = slow
	while fast is not None:
		mid = slow
		slow = slow.next
		fast = fast.next.next if fast.next is not None else None


	left = node
	right = mid.next
	mid.next = None
	return left, right

n1 = Node(10)
n2 = Node(20)
n3 = Node(4)
n4 = Node(5)
n5 = Node(44)
n6 = Node(7)
n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = n6
left_node  = Node()
right_node = Node()
left_node, right_node = split_LinkedList(n1)
L1 = LinkedList()
L1.head.next = left_node
L1.print_linkedList()
L2 = LinkedList()
L2.head.next = right_node
L2.print_linkedList()