1.回文链表
限制时间复杂度是O（n），空间复杂度为O（1）；
给定一个链表的 头节点 head ，请判断其是否为回文链表。
如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。
示例 1：
输入: head = [1,2,3,3,2,1] 输出: true
示例 2：
输入: head = [1,2] 输出: false
提示：
- 链表 L 的长度范围为
[1, 105] 0 <= node.val <= 9
分析：
先找到中间位置，从中间位置到末尾的链表进行逆置，将逆置完毕的链表和开始位置到中间位置的链表进行比对，若相同那么就是回文链表。
1.找到链表的中间位置
这里使用快慢指针，对于快指针一次走两步，慢指针一次走一步；
如果链表元素个数是偶数那么快指针走到NULL停止，如果链表元素个数是奇数，快指针走到链表最后一个元素停止，停止的条件是:fast->next == NULL || fast == NULL，那么继续的条件就是取反：fast->next ！= NULL && fast != NULL；
如此以来循环结束之后，slow指针指向的就是链表的中间位置。
2.逆置链表
使用三个指针，分别指向NULL，head，head->next，这里需要在程序之前判断链表元素的个数为0或者1直接返回头结点。
n2指向n1，n1更新为n2，n2更新为n3，n3更新为n3->next，当n3为空的时候，终止循环，此时链表的最后两个节点没有完成逆置，所以需要手动进行逆置。
逆置完毕之后，n2就是逆置之后的链表的头结点。
3.衔接的问题
当链表是偶数的时候，逆置中间的元素，那么此时需要将中间元素的前一个元素的指针进行断开，奇数也是如此。
想要断开与中间节点的连接，这里还需要知道中间节点的前一个节点，在求中间节点的时候可以设置变量记录下来，然后使其指向NULL，这样一来就断开与中间节点的连接了；
最后就是比较回文了，我们发现回文链表有可能是奇数也有可能是偶数，如果是偶数就不用担心比较的方法，如果是奇数，则这里需要按照前半段的链表（较短）来比较。
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode ListNode;
ListNode* reverseList(ListNode* head) {
// 如果0、1个节点，返回自身
if (head == NULL || head->next == NULL) {
return head;
}
// 定义三个指针
ListNode* p1 = NULL;
ListNode* p2 = head;
ListNode* p3 = head->next;
while (p3) {
p2->next = p1;
p1 = p2;
p2 = p3;
p3 = p3->next;
}
// n3为空的时候，最后一次反转还没开始
p2->next = p1;
return p2;
}
bool isPalindrome(struct ListNode* head) {
ListNode* fast = head;
ListNode* slow = head;
ListNode* prev = head; // 中间节点的前一个节点
// 链表个数为偶数，fast会在NULL，链表个数为奇数，fast会在最后一个元素
while (fast != NULL && fast->next != NULL) {
prev = slow; // 记录中间节点的前一个节点
fast = fast->next->next;
slow = slow->next;
}
prev->next = NULL; // 断开后半部分
ListNode* scHead = reverseList(slow); // 翻转之后的头结点
// 进行比较，如果是奇数那么两边的链表长度不一致，所以循环按照前半部分链表
while (head) {
if (head->val == scHead->val) {
head = head->next;
scHead = scHead->next;
}else
{
return false;
break;
}
}
return true;
}2.相交链表
给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Intersected at '8' 解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Intersected at '2' 解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。 在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 输出：null 解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。 由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 这两个链表不相交，因此返回 null 。
提示：
listA中节点数目为mlistB中节点数目为n0 <= m, n <= 3 * 1041 <= Node.val <= 1050 <= skipA <= m0 <= skipB <= n- 如果
listA和listB没有交点，intersectVal为0 - 如果
listA和listB有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]
进阶：能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？
分析：
首先需要计算出每一个链表的长度，再计算长度的差值，需要让长一点的指针走差值那么多步，使得两个指针处于同一起跑线上，此时同时再进行遍历，直到两个指针相同（不是值相同），需要在循环中判断如果任意一方（因为同步走）的指针是NULL，说明没有交点，返回空，否则就继续循环，退出循环的条件是两个指针不同，如果没有提前return，说明循环正常结束，那么就直接返回任意一个指针即可。
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
ListNode* p1 = headA;
ListNode* p2 = headB;
// 先计算出各自链表的长度，链表长的可以先走几步，保证指针在同一个位置
int la = 0;
int lb = 0;
int between = 0;
while(p1)
{
p1 = p1->next;
la++;
}
while(p2)
{
p2 = p2->next;
lb++;
}
// 保持同步
if(la > lb)
{
between = la - lb;
while(between--)
{
headA = headA->next;
}
}else
{
between = lb - la;
while(between--)
{
headB = headB->next;
}
}
// 同时走
while(headA != headB)
{
headA = headA->next;
headB = headB->next;
if(headA ==NULL)
{
return NULL;
}
}
return headA;
}3.环形链表
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
示例 1：
输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1 输出：false 解释：链表中没有环。
提示：
- 链表中节点的数目范围是
[0, 104] -105 <= Node.val <= 105pos为-1或者链表中的一个 有效索引 。
进阶：你能用 O(1)（即，常量）内存解决此问题吗？
分析：
带环链表最恶心的地方是在于不能遍历，这里可以用快慢指针来实现。
快指针先进环，慢指针后进环，如果有环，那么快指针一定能追上慢指针，一旦追上就判定有环。
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL)
{
fast = fast->next->next;
slow = slow->next;
if(fast == slow)
{
return true;
}
}
return false;
}面试提问：
请正面快指针如何追上慢指针？为什么快指针的步长是2步，3步行不行，n步行不行？
假设两个指针进环以后他们之间的距离是x，那么slow每走一步，fast就走两步，那么它们之间的距离就会是x、x-1、x-2.......0
那么如果fast指针一次走3步，那么他们之间的距离是x-2、x-4、x-6，此时x如果是奇数那么快慢指针就会永不相遇。
4.环形链表II
给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点 解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1 输出：返回 null 解释：链表中没有环。
提示：
- 链表中节点的数目范围在范围
[0, 104]内 -105 <= Node.val <= 105pos的值为-1或者链表中的一个有效索引
进阶：是否可以使用 O(1) 空间解决此题？
分析：
未完待续......