leetcode

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

交换相邻的两个结点，若只有奇数个结点，则最后一个结点不做改变

个人思路：

1，从链表头部开始遍历，分别用current指针记录当前结点，next指针记录下一个结点，pre指针记录前一个结点，每次循环都是把next指针指向的结点插入到pre指针之后，然后重新设置一下这3个指针，直到遍历结束

2，注意一下结束条件即可

代码：

#include <stddef.h>

struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *swapPairs(ListNode *head) {
        if (!head || !head->next)
        {
            return head;
        }

        ListNode dummy(-1);
        dummy.next = head;
        ListNode *pre = &dummy;
        ListNode *current = dummy.next;
        ListNode *next = NULL;

        while (current && current->next)
        {
            next = current->next;

            current->next = next->next;
            next->next = current;
            pre->next = next;

            pre = current;
            current = current->next;
        }

        return dummy.next;
    }
};

网上基本是这个思路