给定一个单链表，两两交换其中相邻的节点，并返回交换后的链表。注：此题中的单链表是不带头节点的单链表

以下是 Python 代码实现：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def swapPairs(head: ListNode) -> ListNode:
    if not head or not head.next:
        return head
    first = head
    second = head.next
    first.next = swapPairs(second.next)
    second.next = first
    return second

解释：

我们定义一个 `ListNode` 类表示链表节点。函数 `swapPairs` 的参数是链表头节点 `head`，返回值是交换后的链表头节点。当链表为空或只有一个节点时，不需要交换，直接返回原链表头节点。否则，我们将链表分成两个节点一组，分别为 `first` 和 `second`，交换它们的位置，然后对剩余节点进行递归操作。最后返回交换后的链表头节点 `second`。

相关问题

用c语言实现给定一个单链表，两两交换其中相邻的节点，并返回交换后的链表。注：此题中的单链表是不带头节点的单链表

以下是使用 C 语言实现的代码：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* swapPairs(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode* new_head = head->next;
    struct ListNode* prev = NULL, *curr = head;
    while (curr != NULL && curr->next != NULL) {
        struct ListNode* next = curr->next;
        curr->next = next->next;
        next->next = curr;
        if (prev != NULL) {
            prev->next = next;
        }
        prev = curr;
        curr = curr->next;
    }
    return new_head;
}

int main() {
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = 1;
    head->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->val = 2;
    head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->val = 3;
    head->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->next->val = 4;
    head->next->next->next->next = NULL;

    struct ListNode* new_head = swapPairs(head);

    while (new_head != NULL) {
        printf("%d ", new_head->val);
        new_head = new_head->next;
    }
    printf("\n");

    return 0;
}

在函数 `swapPairs()` 中，我们首先判断链表是否为空或者只有一个节点，如果是，则直接返回原链表。接着定义一个新的头节点 `new_head`，用来保存交换后的链表的头节点。然后定义两个指针 `prev` 和 `curr`，分别表示当前节点的前一个节点和当前节点。在循环中，我们每次取出两个相邻的节点，将它们交换，并将 `prev` 指向交换后的后一个节点，`curr` 指向交换后的后一个节点的下一个节点。最后将 `new_head` 返回即可。

在 `main()` 函数中，我们构造了一个单链表，然后调用 `swapPairs()` 函数进行相邻节点的交换，并输出交换后的链表。

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

在C语言中，要实现这个功能，我们可以使用迭代的方式来解决。首先，我们需要创建一个结构体来表示链表节点，然后定义一个辅助函数来进行节点的交换。由于题目限制我们不能修改节点内部值，我们将只对指针进行操作。

这是一个简单的示例：

#include <stdio.h>
#include <stdlib.h>

// 链表节点结构体
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

// 辅助函数，用于交换两个节点
ListNode* swapNodes(ListNode* node) {
    if (node == NULL || node->next == NULL) {
        return node;
    }
    
    ListNode temp = *node;
    ListNode* nextTemp = temp.next;
    temp.next = nextTemp->next;
    nextTemp->next = temp;
    return nextTemp;
}

// 主函数：给定链表，两两交换相邻节点
ListNode* twoWaySwap(ListNode* head) {
    ListNode* current = head;
    while (current != NULL && current->next != NULL) {
        current->next = swapNodes(current->next);
        current = current->next->next;
    }
    return head;
}

// 创建链表并测试上述函数
void createLinkedList(ListNode** head, int arr[], int size) {
    ListNode* node = (*head) = malloc(sizeof(ListNode));
    node->val = arr[0];
    node->next = NULL;

    for (int i = 1; i < size; ++i) {
        node = realloc(node, sizeof(ListNode) + sizeof(int));
        node->next = malloc(sizeof(ListNode));
        node->next->val = arr[i];
        node->next->next = NULL;
        node = node->next;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    ListNode* head = NULL;
    createLinkedList(&head, arr, n);

    // 打印原始链表
    printf("Original list: ");
    printList(head);

    // 交换节点后
    head = twoWaySwap(head);
    printf("\nAfter swapping: ");
    printList(head);

    return 0;
}

// 辅助函数：打印链表
void printList(ListNode* node) {
    while (node != NULL) {
        printf("%d -> ", node->val);
        node = node->next;
    }
    printf("NULL\n");
}

在这个程序中，`twoWaySwap`函数通过遍历链表，每次交换当前节点和下一个节点，直到链表结束。`createLinkedList`函数用于构建初始链表。注意，这里没有涉及到真正的数据交换，只是改变了节点之间的引用，实现了题目要求。