代码随想录算法【Day4】

Day4

1.链表的题目,要在草稿纸上模拟清晰后就简单了

2.双指针更加灵活的应用。

3.环形链表多练习。

24. 两两交换链表中的节点
复制代码
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* _dummyHead = new ListNode(0); //虚拟头结点
        _dummyHead -> next = head;
        ListNode* cur = head;
        ListNode* pre = _dummyHead;
        ListNode* tmp;
        while(cur != NULL && cur -> next != NULL){
            tmp = cur -> next -> next;
            //三个步骤
            pre -> next = cur -> next; 
            cur -> next -> next = cur;
            cur -> next = tmp;
            //更新值
            pre = cur;
            cur = tmp;
        }
        ListNode* result = _dummyHead->next;
        delete _dummyHead;
        return result;
    }
};
19.删除链表的倒数第N个节点

直接法:

复制代码
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //直接法,需要两次遍历
        ListNode* _hummyHead = new ListNode(0); //虚拟头结点
        _hummyHead -> next = head;
        ListNode* tmp = nullptr, *cur = _hummyHead; 
        int count = 0; //记录节点个数
        if(cur -> next == NULL) return head;
        while(cur -> next != NULL){
            cur = cur -> next;
            count ++;
        }
        cur = _hummyHead;
        int m = count - n;
        //移动到要删除的节点的前一个位置
        while(m--){
            cur = cur -> next;
        }
        //删除操作
        if(cur -> next -> next != nullptr) 
                tmp = cur -> next ->next;
        delete cur -> next;
        cur -> next = tmp;
        return _hummyHead -> next;
    }
};

第一次写,没有加"if(cur -> next == NULL) return head;"这句,程序一直报错,在这里我debug了很久。

要注意,cur -> next为nullptr的话,cur -> next -> next 就是非法的。

双指针法

复制代码
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //快慢指针,只用遍历一遍就可以删除节点
        ListNode *_hummyHead = new ListNode(0);
        _hummyHead -> next = head;
        ListNode *slow = _hummyHead, *fast = _hummyHead;
        //先正常写,然后判断边界情况
        while (n --){
            fast = fast -> next;
        }
        while(fast -> next != nullptr){
            slow = slow -> next;
            fast = fast -> next;
        }
        //删除节点
        ListNode *tmp = slow -> next;
        slow -> next = tmp -> next;
        delete tmp;
        return _hummyHead -> next;
    }
};
面试题 02.07. 链表相交

有点类似模拟题,思路清晰后挺简单的。

题目示例里面提到的,"题目条件如果两个链表相交则不能为 0",意思是,0代表了NULL。

复制代码
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //相交的节点指地址是相同的,值相同的节点不一定地址相同
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB =0;
        while(curA != NULL){
            lenA ++;
            curA = curA -> next;
        }
        while(curB != NULL){
            lenB ++;
            curB = curB -> next;
        }
        curA = headA;
        curB = headB;
        //让curA成为最长链表的头
        if(lenA < lenB){
            swap(lenA, lenB);
            swap(curA, curB);
        }
        int gap = lenA - lenB;
        //让两表对齐
        while(gap --){
            curA = curA -> next;
        }
        while(curA != curB && curA != nullptr){
            curA = curA -> next;
            curB = curB -> next;
        }
        return curA;
    }
};
142.环形链表II

1.如何判断链表有环?

快慢指针相遇

2.假如慢指针每次移动一步,快指针每次移动两步,会不会存在这样的一个情况,即快慢指针永远无法相遇?

可以这样来看,慢指针相对于快指针静止,快指针每次相对移动一步来遇到慢指针,所以不存在永远无法相遇的情况。

3.如何判断快慢指针一定会相遇?

假如快指针每次移动5步,慢指针每次移动2步,以3步为单位的相对移动。

本质上是看以3步为单位的移动,是否一定能遍历环上的所有节点

所以只有当环长L不是3的倍数时才能相遇

4.环的入口怎么找?

快慢指针的运动如下图所示:

假设快慢指针在环中的某一点相遇,设:

①slow = x + y

(而不是 slow = x+y+n(y+z),因为慢指针被快指针追上的时候,慢指针一定在走第一圈)

②fast = x + y + n(y+z)

因为fast = 2 * slow

有等式: 2 * (x + y) = x + y + n(y +z)

得到:x = n(y + z) - y,整理得:③x = (n - 1)(y + z) + z,其中n ≥ 1

由③式可知,让慢指针1和慢指针2分别从起点和相遇点出发,他们总会在环的入口相遇,这样就找到了环的入口。

5.慢指针被快指针追上的时候,为什么一定是在慢指针走第一圈的时候?

假设快指针已经走了3圈,把环铺开,如下图,慢指针没转完一圈,一定就被快指针追上了。

以下是我ac的代码,做的多余判断太多了,建议去看一下网站上的代码。

复制代码
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //判断是否有环
        //记得考虑一下只有一个节点的情况和没有节点的情况
        ListNode* slow = head, *fast = head;
        if(head == nullptr || head->next == NULL) return NULL;
        while(fast != nullptr && fast->next != NULL){
            slow = slow -> next;
            fast = fast -> next -> next;
            if(slow == fast) break;
        }
        if(fast == nullptr|| fast->next == NULL) return NULL;
        //如果有环,返回入环的第一个节点
        ListNode *cur = head;
        while(cur != slow){
            slow = slow -> next;
            cur = cur -> next;
        }
        return cur;
    }
};

以下是我第一次写的报错的代码,刚开始就让快指针走了两步,导致表达式发生变化,所以报错,代码一定要严格按照表达式来。

复制代码
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //判断是否有环
        //特殊判断一下只有一个节点的情况和没有节点的情况
        if(head == NULL && head -> next == NULL) return NULL;
        ListNode* slow = head, *fast = head -> next -> next;
        while(fast != nullptr && slow != fast){
            slow = slow -> next;
            fast = fast -> next -> next;
        }
        if(fast == nullptr) return NULL;
        //如果有环,返回入环的第一个节点
        ListNode *cur = head;
        while(cur != slow){
            slow = slow -> next;
            cur = cur -> next;
        }
        return cur;
    }
};
相关推荐
xindafu44 分钟前
代码随想录算法训练营第五十天|图论part1
c语言·算法·图论
满分观察网友z1 小时前
从选择困难到最优策略:我如何用DP搞定“鱼和熊掌兼得”的排程难题(1751. 最多可以参加的会议数目 II)
后端·算法
满分观察网友z1 小时前
从一团乱麻到井然有序:我的海量任务调度“秘密武器”( 1353. 最多可以参加的会议数目)
算法
m0_535064602 小时前
C++类模版与友元
java·c++·算法
满分观察网友z2 小时前
从“最短响应路径”到二叉树最小深度:一个Bug引发的BFS探险之旅(111. 二叉树的最小深度)
后端·算法
阿里云大数据AI技术2 小时前
Post-Training on PAI (4):模型微调SFT、DPO、GRPO
人工智能·算法·云计算
CoovallyAIHub2 小时前
卷积网络到底能不能“定位”?一次对空间表示能力的深度解析
深度学习·算法·计算机视觉
用户40315986396633 小时前
和谐程序组
java·算法
用户40315986396633 小时前
缓存优化模拟
java·算法
用户40315986396633 小时前
遥控小车
java·算法