训练营打卡day4

题目：24. 两两交换链表中的节点 - 力扣（LeetCode）

感想：这道题开始是没有思路的，感觉奇数和偶数不知道怎么处理。然后看了视频，看了一点，思路来了，我先计算这个链表有多少个，如果链表个数<=1，就直接返回head，否则就进行两两交换。交换过程中主要就是新建了三个节点用来存放节点的next，这个方法不知道和最终解法是否可以，这个是一个while循环，终止条件为 size=0 或 size = 1。详细代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* node = head;
        int size = 0;
        while(node != NULL) {
            node = node->next;
            size++;
        }
        if(size <= 1) {
            return head;
        }else {
            ListNode* dummynode = new ListNode(0,head);
            ListNode* cur = dummynode;
            while(size != 1 && size >0) {
                ListNode* tmp = new ListNode(0, cur->next);
                ListNode* tmp1 = new ListNode(0, cur->next->next);
                ListNode* tmp2 = new ListNode(0, cur->next->next->next);
                cur->next = tmp1->next;
                cur->next->next = tmp->next;
                cur->next->next->next =tmp2->next;
                cur = cur->next->next;
                delete tmp, tmp1, tmp2;
                size -= 2;
            }
            return dummynode->next;
        }
    }
};

看完讲解之后，跟自己的代码对比了一下，首先不需要进行数组操作，定义虚拟头节点之后，只需要判断 dummy->next && dummy->next->next ！= NULL就行，两个顺序要注意，这个条件如果是偶数的话第一个就不满足了直接结束，如果是奇数第二个 不满足结束。除此之外 ，还有tmp的定义方式，我自己写的代码相当于新建了两个节点，而解法里只是取了原来节点的地址。

题目：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

这道题自己解出来了，然后看了看代码随想录给出的解法，发现可以用双指针。对比我的代码来看，我虽然没有用双指针，但是两者其实一样都是判断当前节点后的n+1是不是链表 末尾，如果是就执行操作。不过我的这个判断是加在wihle循环里的cur一直再增加，每次都会再遍历n此去判断该节点的下一个节点是不是要删除的。相比之下，双指针先确定两个指针差n+1，然后先给快指针赋值，之后low和fast同时增加，然后fast=NULL的时候，low->next即为要删除的节点。自己的代码附下：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0, head);
        ListNode* cur = dummyhead;
        int k = n;
        while(1) {
            ListNode* tmp = cur;
            while(k--) {
                tmp = tmp->next;
            }
            if(tmp->next == NULL) {
                ListNode* tmp1 = cur->next;
                cur->next = tmp1->next;
                delete tmp1;
                break;
            }else{
                cur = cur->next;
                k = n;
            }
        } 
        ListNode* result = dummyhead->next;
        delete dummyhead;
        return  result;
    }
};

题目：面试题 02.07. 链表相交 - 力扣（LeetCode）

这道题也自己AC了，但是中间遇到一个bug，没有通过两个第一个就相较的情况，加一个虚拟头节点解决了。看了代码随想录的解法，时间复杂度小很多，我的应该是O(n*m)他的事 O(n+m)，他开始有个 巧妙地处理是让短的和长的尾部对齐，这样两链表都从短的开始即可。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* dummyheadA = new ListNode(0, headA);
        ListNode* dummyheadB = new ListNode(0, headB);
        ListNode* curA = dummyheadA;
        while(curA->next != NULL) {
            ListNode* curB = dummyheadB;
            while(curB->next != NULL) {
                if(curB->next == curA->next) {
                    return curA->next;
                    break;
                }else {
                    curB = curB->next;
                }
            }
            curA  = curA->next;
        }
        return NULL;
    }
};

题目 ：142. 环形链表 II - 力扣（LeetCode）

这道题还是有点难度的，看完视频自己码了一边代码。

总结：总的来说其实链表的基础就那些，但是有很多思想需要我们去学习，有些题目自己能够AC过，但是基本上就是暴力解法，而有些思想是能够减少运行时间的。这几道题里双指针真的用的很多。