# 两两交换链表中的节点
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;

struct ListNode
{
    int val;
    struct ListNode *next;
    ListNode() : val(0), next(nullptr){};
    ListNode(int x) : val(x), next(nullptr){};
    ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp

```

## 答案
```cpp
class Solution
{
public:
    ListNode *swapPairs(ListNode *head)
    {

        ListNode *new_head = new ListNode(0);
        new_head->next = head;
        ListNode *pre = new_head;

        while (head && head->next)
        {

            ListNode *first = head;
            ListNode *second = head->next;

            pre->next = second;
            first->next = first->next;
            second->next = first;

            pre = first;
            head = first->next;
        }

        return new_head->next;
    }
};
```
## 选项

### A
```cpp

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

        ListNode *dummy = new ListNode(0);
        dummy->next = head;
        ListNode *p = dummy;

        while (p->next != NULL && p->next->next != NULL)
        {
            ListNode *node1 = p->next;
            ListNode *node2 = node1->next;
            ListNode *next = node2->next;

            node2->next = node1;
            node1->next = next;
            p->next = node2;

            p = node1;
        }
        ListNode *retnode = dummy->next;
        delete dummy;

        return retnode;
    }
};
```

### B
```cpp
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode *next = head->next;
        head->next = swapPairs(next->next);
        next->next = head;
        return next;
    }
};
```

### C
```cpp
class Solution
{
public:
    ListNode *swapPairs(ListNode *head)
    {
        ListNode *p = new ListNode(-1);
        p->next = head;
        ListNode *h = p;
        while (p->next && p->next->next)
        {
            ListNode *c = p->next;
            ListNode *n = p->next->next;
            p->next = c->next;
            c->next = n->next;
            n->next = c;
            p = c;
        }
        return h->next;
    }
};
```