链表总结(基于python)

1.单向链表的反转（迭代）

class ListNode:
	def __init__(self, x):
		self.val = x
		self.next = None

def inverse(head):
	r = None
	p = head
	while p != None:
		q = p
		p = p.next
		q.next = r
		r = q
	return q

	# q = None
	# p = head
	# while p != None:
	# 	r = q
	# 	q = p
	# 	p = p.next
	# 	q.next = r
	# return q

if __name__ == '__main__':
	nodes = [1,2,3,4]
	# 构建链表
	head = ListNode(nodes[0])
	ptr = head
	for x in nodes[1:]:
		node = ListNode(x)
		ptr.next = node
		ptr = ptr.next

	# 遍历链表
	point = head
	while point != None:
		print(point.val, end = "\t")
		point = point.next
	print("\n")

	# 反转后打印链表
	reversed_head = inverse(head)
	while reversed_head != None:
		print(reversed_head.val, end = "\t")
		reversed_head = reversed_head.next

2. 单向链表反转（递归）

前面非递归方式是从前面数1开始往后依次处理，而递归方式则恰恰相反，它先循环找到最后面指向的数5，然后从5开始处理依次翻转整个链表。

首先指针H迭代到底如下图所示，并且设置一个新的指针作为翻转后的链表的头。由于整个链表翻转之后的头就是最后一个数，所以整个过程NewH指针一直指向存放5的地址空间

然后H指针逐层返回的时候依次做下图的处理，将H指向的地址赋值给H->next->next指针

继续返回操作：

递归程序

data = [1,2,3,4,5,6]

class ListNode:
	def __init__(self, val):
		self.val = val
		self.next = None

# 构建链表
head = ListNode(data[0])
ptr = head
for val in data[1:]:
	node = ListNode(val)
	ptr.next = node
	ptr = ptr.next

# 链表反转
def inverse(head):
	if head == None or head.next == None:
		return head
	# 一直循环到链尾
	newHead = inverse(head.next)
	# 翻转链表指向
	head.next.next = head
	head.next = None
	return newHead

# 打印链表
newHead = inverse(head)
while newHead != None:
	print(newHead.val, end="\t")
	newHead = newHead.next

输出

6	5	4	3	2	1