leetcode刷题记第24题解法（python解析）（两两交换链表中的节点）

题目定义

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

来源：力扣（LeetCode）
链接: leetcode_24题.

1. 只交换值（不能说完成）

直接将两两的值进行相交换

2. 递归

算法：

    从链表的头节点
    head
    开始递归。
    每次递归都负责交换一对节点。由
    firstNode
    和
    secondNode
    表示要交换的两个节点。
    下一次递归则是传递的是下一对需要交换的节点。若链表中还有节点，则继续递归。
    交换了两个节点以后，返回
    secondNode，因为它是交换后的新头。
    在所有节点交换完成以后，我们返回交换后的头，实际上是原始链表的第二个节点。

3. 迭代

一张图说明一切

===================================================

实现

// An highlighted block
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def swapPairs(self, head):
        '''
        只交换了  节点的值
        并不能说完成
        '''
        node = head

        while node and node.next:
            node.val, node.next.val = node.next.val, node.val
            node = node.next.next
        return head

    def swapPairs_1(self, head):
        '''
         方法一：递归
        这个题目要求我们从第一个节点开始两两交换链表中的节点，且要真正的交换节点。

        算法：

        从链表的头节点
        head
        开始递归。
        每次递归都负责交换一对节点。由
        firstNode
        和
        secondNode
        表示要交换的两个节点。
        下一次递归则是传递的是下一对需要交换的节点。若链表中还有节点，则继续递归。
        交换了两个节点以后，返回
        secondNode，因为它是交换后的新头。
        在所有节点交换完成以后，我们返回交换后的头，实际上是原始链表的第二个节点。
        '''

        if head is None or head.next is None:
            return head

        first_head = head
        second_head = head.next

        first_head.next = self.swapPairs_1(second_head.next)
        second_head.next = first_head

        return second_head

    def swapPairs_2(self, head):
        '''
        方法二：迭代
        我们把链表分为两部分，即奇数节点为一部分，偶数节点为一部分，
        A  指的是交换节点中的前面的节点，
        B  指的是要交换节点中的后面的节点。在完成它们的交换，
        我们还得用prevNode记录A的前驱节点。

        算法：

        firstNode（即A） 和secondNode（即B） 分别遍历偶数节点和奇数节点，即两步看作一步。
        交换两个节点：
        firstNode.next = secondNode.next
        secondNode.next = firstNode

        还需要更新
        prevNode.next 指向交换后的头。
        prevNode.next = secondNode
        迭代完成后得到最终的交换结果。
        '''

        # 初始化节点
        dummy = ListNode(-1)
        dummy.next = head

        prev_node = dummy

        while head and head.next:
            # Nodes to be swapped
            first_node = head
            second_node = head.next

            # Swapping
            prev_node.next = second_node
            first_node.next = second_node.next
            second_node.next = first_node

            # 为下一次转换做准备
            prev_node = first_node
            head = first_node.next

        # Return the new head node.
        return dummy.next





    def print_node(self,node):
        '''
        遍历链表
        '''
        while node:
            print(node.val)
            node = node.next

a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
d = ListNode(4)
a.next = b
b.next = c
c.next = d
node = Solution().swapPairs_2(a)
Solution().print_node(node)