Day4leetcode打卡链表

24.两两交换链表中的节点

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

思路：

使用虚拟头节点；要两两交换链表中的节点，则当前节点需指向前一个节点，如[1,2,3,4]，交换1和2，则cur指向虚拟头节点，交换3和4时cur指向2。遍历的终止条件为cur.next和cur.next.next不为空。 

python版本

def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(next=head)
        cur = dummy
        while cur.next and cur.next.next:
            #[1,2,3,4]
            # 保存指向第二个数2的指针
            tmp1 = cur.next
            # 保存指向第三个数3的指针
            tmp2 = cur.next.next.next

            # 修改cur的下一个指向为2
            cur.next = cur.next.next 
            # 修改2的下一个指向为1
            cur.next.next = tmp1
            #修改1的下一个指针指向3
            tmp1.next = tmp2

            #移动cur
            cur = cur.next.next
        return dummy.next

 c++版本

ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while(cur->next !=nullptr && cur->next->next !=nullptr){
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;
            cur->next = cur->next->next;
            cur->next->next = tmp1;
            tmp1->next = tmp2;
            cur=cur->next->next;
        }
        return dummy->next;
    }

19.删除链表的倒数第n个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

思路1：[1,2,3,4,5],n=2,删除4。先求出链表的长度length 5，遍历cur至第length-n （3）（倒数第n+1）个节点，删除下一个节点。

def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy = ListNode(next=head)
        cur = dummy
        pre = head
        length = 0
        # 求解链表长度
        while pre:
            pre = pre.next
            length += 1
        # 遍历链表至前一个点
        for _ in range(length - n):
            cur = cur.next
        #删除节点
        cur.next = cur.next.next
        return dummy.next

思路2：采用虚拟头节点，快慢指针。快指针先走n+1（3）步指向3，再同时走快慢指针，这样快指针指向空时，慢指针刚好指向倒数第n个节点，删除节点。

python

def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]: 
        dummy = ListNode(next=head)
        slow = dummy
        fast = dummy
        for _ in range(n+1):
            fast = fast.next
        while fast:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummy.next

C++

ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = dummy;
        for (int i = 0; i < n + 1; i++) {
            fast = fast->next;
        }
        while (fast != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        return dummy->next;
    }

 

142.环形链表||

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

思路：参考代码随想录 (programmercarl.com)

使用快慢指针，双指针相遇时，指针与环口的距离等于头节点到环口的距离。

python 

def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow = head
        fast = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast==slow:
                tmp = fast
                pre = head
                while tmp!= pre:
                    tmp=tmp.next
                    pre=pre.next
                return pre
        return None

c++

ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 示例1快慢指针相遇，在-4处
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;

若有不足还请大佬们多多指教。