Leetcode算法——24、链表成对交换

给定一个链表，将每两个相邻的节点交换位置，最后返回头结点。

备注：
算法只能使用常量的空间。
不可以修改节点的值，只能改变节点本身。

示例：

输入：1->2->3->4
输出：2->1->4->3

思路

链表中某两个相邻节点 p1 和 p2 互换位置，这是链表的基本操作之一。

比如有一个链表 p1 -> p2 -> p3 -> p4，想要交换 p2 和 p3 的位置，则：

1、将 p3悬挂起来，将 p2 直接指向 p4，得到 p1 -> p2 -> p4
2、将 p1指向 p3，得到 p1 -> p3， p2 -> p4
3、将 p3 指向 p2，得到 p1 -> p3 -> p2 -> p4

这样，就实现了 p2 和 p3 的互换。

本题需要每两个相邻的元素都要互换，因此需要添加一个循环扫描所有节点，每两个节点交换一次。

python实现

class ListNode:
    def __init__(self, x):
        
        if isinstance(x, list):
            self.val = x[0]
            self.next = None
            head = self
            for i in range(1, len(x)):
                head.next = ListNode(x[i])
                head = head.next
        else:
            self.val = x
            self.next = None
        
    def output(self):
        '''
        输出链表
        '''
        result = str(self.val)
        head = self.next
        while(head is not None):
            result += f' -> {head.val}'
            head = head.next
        return '(' + result + ')'
    
def swapPairs(head):
    """
    :type head: ListNode
    :rtype: ListNode
    
    """
    head2 = ListNode(0)
    head2.next = head
    p = head2
    while(p and p.next and p.next.next):
        p2 = p.next
        p3 = p2.next
        p2.next = p3.next
        p.next = p3
        p3.next = p2
        p = p2
    return head2.next

if '__main__' == __name__:
    head = ListNode([1])
    print(swapPairs(head).output())