一个超链接 多个网站深圳十大品牌策划公司

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 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= 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 <= 105
• pos 为 -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 <= 105
• pos 的值为 -1 或者链表中的一个有效索引

进阶：是否可以使用 O(1) 空间解决此题？

分析：

未完待续......