C语言力扣第24题之两两交换链表中的节点。递归与非递归

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

示例 1：

输入：head = [1, 2, 3, 4]
输出：[2, 1, 4, 3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

链表中节点的数目在范围[0, 100] 内
0 <= Node.val <= 100

来源：力扣（LeetCode）
链接：https ://leetcode.cn/problems/swap-nodes-in-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

本题有两种思路：

递归利用stack：
我们利用一个 stack，然后不断迭代链表，每次取出两个节点放入 stack 中，再从 stack 中拿出两个节点。
借助 stack 后进先出的特点，放进去的时候是 1,2 。拿出来的时候就是 2，1 两个节点了。
再把这两个节点串联起来，重复这个逻辑遍历完整个链表，就可以做到两两反转的效果了。
虽然用到了 stack，但因为只存了两个元素，所以空间复杂度还是 O(1)，时间复杂度是 O(n)。

迭代实现

比 stack 方式复杂多了，需要很小心的处理节点的指向。
这里我们需要三个指针，a，b，tmp。
假设链表是
1->2->3->4->5->6
在迭代的时候，每次处理两个节点，于是第一轮 a 指向 1，b 指向 2。
第二轮的时候 a 指向 3，b 指向 4。第三轮的时候 a 指向 5，b 指向 6。
我们通过 a.next = b.next，以及b.next=a就把两个指针的位置反转了，于是1->2就变成2->1。
但这里有一个细节需要处理，当我们第二轮迭代的时候，a 指向 3，b 指向 4。按照题目要求，最终应该是2->1->4->3。
也就是节点 1 需要跟节点 4 串起来，只有两个指针就没法弄了，所以需要第三个指针 tmp，用来记录上一轮 a 的位置，然后下一轮迭代的时候，将原先的 a(也就是节点 1)指向 4。

以下仅提供迭代方法，递归方法更深层的原理请参考本人另外一篇博客考研复习之数据结构笔记（五）栈和队列（上）（包含栈的相关内容）

以下附上链接：考研复习之数据结构笔记（五）栈和队列（上）（包含栈的相关内容）_管二狗绝不摆烂的博客-CSDN博客

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <assert.h>


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


struct ListNode* swapPairs(struct ListNode* head) 
{
	struct ListNode* cur = head;
	int i = 0;
	if (head == NULL)
		return head;
	while (cur->next != NULL)
	{
		i = cur->val;
		cur->val = cur->next->val;
		cur->next->val = i;
		if (cur->next->next != NULL)
			cur = cur->next->next;
		else
			cur = cur->next;
	}
	return head;
}