LeetCode-中等-24. 两两交换链表中的节点

LeetCode-中等-24. 两两交换链表中的节点

题目

引用自：LeetCode-中等-24. 两两交换链表中的节点（如有侵权联系删除）

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例2：

输入：head = []
输出：[]

示例3：

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

解题：

没什么好说的（狗头护体），数据结构学链表应该有类似的题，但是本体需要注意的两点：

• 1、 这个是不带链头的链表，所以翻转部分位置的过程中，前两个节点需要单独处理，后续的话直接循环操作完成即可。同时，我写的时候，使用了temp1，temp2两个临时变量标记了需要翻转的两个节点，因为很容易拿到每个节点，所以操作顺序就不重要了，但是如果只标记两个节点中的其中一个的时候，操作可能需要保持一定的先后顺序，要不然可能会导致连接错误。
• 2、 每次在循环选择下两个节点的时候，需要用提前保存需要操作的这两个节点的前面那个节点，因为这两个节点调换位置之后，需要用前面的节点再连起来整个链。如示例1中，当翻转节点3、4的时候，需要保存节点2，因为交换完节点3、4之后，还需要把节点2与节点4连起来。

代码：

class Solution:
    def swapPairs(self, head):
        if head == None or head.next == None:
            return head
        before = None
        temp1 = head
        temp2 = head.next
		
		# 单独处理前两个节点
        temp1.next = temp2.next
        temp2.next = temp1
        before = temp1
        # 处理头节点
        head = temp2
        
		#后面的都有规律
        while before.next is not None and before.next.next is not None:
        	# 两个标记位后移
            temp1 = before.next
            temp2 = temp1.next
			
			# 翻转两个节点
            temp1.next = temp2.next
            temp2.next = temp1
            before.next = temp2
            
			# 标记前一个节点
            before =temp1

        return head

测试：

# Python

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def swapPairs(self, head):
        if head == None or head.next == None:
            return head

        temp1 = head
        temp2 = head.next

        # 单独处理前两个节点
        temp1.next = temp2.next
        temp2.next = temp1
        before = temp1
        # 处理头节点
        head = temp2
		
		#后面的都有规律
        while before.next is not None and before.next.next is not None:
            # 两个标记位后移
            temp1 = before.next
            temp2 = temp1.next

            # 翻转两个节点
            temp1.next = temp2.next
            temp2.next = temp1
            before.next = temp2
			
			# 标记前一个节点
            before =temp1
            
        return head

# 打印 link 链表
def out_all(head):
    temp = head
    while temp is not None:
        print(temp.val)
        temp = temp.next

# 把 list 转换为 link 链表
def list_2_link(l):
    head = None
    temp = None
    for i in range(len(l)):
        if i == 0:
            head = ListNode(val=l[i], next=None)
            temp = head
        else:
            temp.next = ListNode(val=l[i], next=None)
            temp = temp.next
        i += 1
    return head

# # 把 link 转换为 list 链表
def link_2_list(head):
    temp = head
    l = []
    while temp is not None:
        l.append(temp.val)
        temp = temp.next
    return l

if __name__=='__main__':
    print('测试 1  \n输入：head = [1]')
    a = [1]
    head = list_2_link(a)
    so = Solution()
    head = so.swapPairs(head)
    print('输出:', link_2_list(head), '\n')

    print('测试 2  \n输入：head = [1, 2, 3, 4]')
    b = [1,2,3,4]
    head = list_2_link(b)
    head = so.swapPairs(head)
    print('输出:', link_2_list(head), '\n')

    print('测试 3  \n输入：head = [1, 2, 3, 4, 5]')
    c = [1,2,3,4,5]
    head = list_2_link(c)
    head = so.swapPairs(head)
    print('输出:', link_2_list(head), '\n')

结果：

总结：
写的有点慢，需要提升一下速度！！！