今天的四道题是链表相关
可以画图，理清思路，构造一个虚拟头结点会容易很多；
注意将初始化时prev的下一个设置为head，或者先判断只有一个节点的情况；
注意更新prev时，是将prev更新为交换后的节点，也就是说原来是curr->next，交换后变为next->curr，此时prev应该更新为curr；
注意有奇数个节点的情况，也就是最后一次交换只有一个一个节点，此时nextNext为空。
AC代码：
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if (head == nullptr)
return nullptr;
ListNode dummyHead = ListNode(-1);
ListNode* prev = &dummyHead;
prev->next = head;
ListNode* curr = head;
ListNode* next = head->next;
ListNode* nextNext = nullptr;
while (next != nullptr) {
nextNext = next->next;
prev->next = next;
curr->next = nextNext;
next->next = curr;
prev = curr;
curr = nextNext;
if (nextNext != nullptr) {
next = nextNext->next;
} else {
next = nullptr;
}
}
return dummyHead.next;
}
};
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
dummyHead->next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
ListNode* cur = dummyHead;
while(cur->next != nullptr && cur->next->next != nullptr) {
ListNode* tmp = cur->next; // 记录临时节点
ListNode* tmp1 = cur->next->next->next; // 记录临时节点
cur->next = cur->next->next; // 步骤一
cur->next->next = tmp; // 步骤二
cur->next->next->next = tmp1; // 步骤三
cur = cur->next->next; // cur移动两位，准备下一轮交换
}
ListNode* result = dummyHead->next;
delete dummyHead;
return result;
}
};
- 先求长度，后求倒数第n个节点；
- 使用栈记录节点，然后出栈，第n个就是我们需要的节点；
- 双指针，fast先走n步，然后slow和fast同时走，fast到链表尾，slow就到了倒数第n个节点。 AC代码：
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
int size = 0;
ListNode* curr = head;
while (curr != nullptr) {
size++;
curr = curr->next;
}
ListNode* dummyHead = new ListNode();
dummyHead->next = head;
ListNode* prev = dummyHead;
curr = head;
for (int i = 0; i < size - n; i++) {
prev = curr;
curr = curr->next;
}
prev->next = curr->next;
head = dummyHead->next;
delete dummyHead;
return head;
}
};
//快慢指针
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* slow = dummyHead;
ListNode* fast = dummyHead;
while(n-- && fast != NULL) {
fast = fast->next;
}
fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
while (fast != NULL) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
// ListNode *tmp = slow->next; C++释放内存的逻辑
// slow->next = tmp->next;
// delete tmp;
return dummyHead->next;
}
};
直观的思路，我们遍历两个链表，使用set保存所有节点，如果发现有相同节点，则直接返回；没有则返回NULL；
双指针法，先求两个链表的长度n，m，然后将指向较长的链表的指针移动abs(n-m)个单位（即对齐两个链表的末尾位置），此时我们只需要比较currA与currB是否相同即可，相同，返回；不相同，比较下一个。
AC代码：
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
set<ListNode*> s;
while(headA!=NULL){
s.emplace(headA);
headA=headA->next;
}
while(headB!=NULL){
if(s.find(headB) == s.end()){
headB=headB->next;
}
else{
return headB;
}
}
return NULL;
}
};
class Solution {
public:
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
int n = 0, m = 0;
ListNode* = headA;
ListNode* currB = headB;
while (currA != NULL) {
n++;
currA = currA->next;
}
while (currB != NULL) {
m++;
currB = currB->next;
}
int gap = abs(n - m);
currA = headA;
currB = headB;
if (m > n) {
while (gap > 0) {
currB = currB->next;
gap--;
}
} else {
while (gap > 0) {
currA = currA->next;
gap--;
}
}
while (currA != NULL) {
if (currA == currB) {
return currA;
}
currA = currA->next;
currB = currB->next;
}
return NULL;
}
};
哈希表法，遍历链表中的每个节点，并将它记录下来；一旦遇到了此前遍历过的节点，就可以判定链表中存在环
快慢指针，fast和slow都从头结点出发，slow每次走一步，fast每次走两步；假设链表长度为n，环的长度为m，假如有环，则slow和fast必定在环内相遇，此时slow走过x+y，fast走过x+y+n(y+z)，其中x为环外长度，y为slow在环内走过的距离，z为环剩下的长度，即n=x+y+z，m=y+z，又因为fast的速度是slow的两倍，有2(x+y)=x+y+n(y+z)，得x=(n-1)(y+z)+z，这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是环形入口的节点。
class Solution {
public:
ListNode* detectCycle(ListNode* head) {
if (head == NULL || head->next == NULL)
return NULL;
ListNode* fast = head;
ListNode* slow = head;
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
if (fast == slow) {
ListNode* curr = head;
while (curr != slow) {
slow = slow->next;
curr = curr->next;
}
return curr;
}
}
return NULL;
}
};
