代码随想录算法训练营第四天打卡

1.两两交换链表的节点

Leetcode题目链接

非常经典的定义虚拟头节点法,这个方法一定要牢记!

代码如下:

class Solution {
public:
    ListNode* swapPairs(ListNode* head) { //非常经典!一定要牢记
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr && curr->next) {
            ListNode* temp = curr->next;
            curr->next = temp->next;
            temp->next = curr;
            prev->next = temp;

            prev = curr;
            curr = curr->next;
        }
        return dummy->next;
    }
};

可在本地IDE运行的完整代码如下:

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* swapPairs(ListNode* head) { //非常经典!一定要牢记
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* prev = dummy;
        ListNode* curr = dummy->next;
        while (curr && curr->next) {
            ListNode* temp = curr->next;
            curr->next = temp->next;
            temp->next = curr;
            prev->next = temp;

            prev = curr;
            curr = curr->next;
        }
        return dummy->next;
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr != nullptr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(6);
    head->next->next->next = new ListNode(3);
    Solution sol;
    ListNode* swapped = sol.swapPairs(head);
    printList(swapped);
    return 0;
}

2.删除链表的倒数第N个节点

Leetcode题目链接

这道题也非常巧妙,主要就是使用两个指针,并定义虚拟头节点。首先,快指针和慢指针都指向dummy虚拟头节点,然后将快指针先移动N+1步,然后快指针和慢指针一起移动,直到快指针指向链表的最后,慢指针就正好指向倒数第N个节点的前面那个节点,就可以方便的将其倒数第N个节点删除。

代码如下:

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) { //简洁版本
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* fast = dummy;
        ListNode* slow = dummy;
        n++; //fast指针先走n+1步,然后slow指针再跟着走,这样子就可以方便的实现删除倒数第n个指针
        while (n-- && fast) {
            fast = fast->next;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        ListNode* newNode = dummy->next;
        delete dummy;
        return newNode;
    }
};

可在本地IDE运行的完整代码如下:

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// class Solution {
// public:
//     ListNode* removeNthFromEnd(ListNode* head, int n) { //我自己的版本,是可以跑得出的,但是还是不够简洁,其实还可以写的更简洁
//         ListNode* dummy = new ListNode(0);
//         ListNode* curr = head;
//         dummy->next = head;
//         ListNode* prev = dummy;
//         ListNode* temp = new ListNode(0);
//         int num = 1;
//         if (head == nullptr || head->next == nullptr) {
//             return nullptr;
//         }
//         while (curr){
//             curr = curr->next;
//             if (num >= n) {
//                 temp = prev;
//                 prev = prev->next;
//             }
//             num++;
//         }
//         temp->next = prev->next;
//         return dummy->next;
//     }
// };

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) { //简洁版本
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* fast = dummy;
        ListNode* slow = dummy;
        n++; //fast指针先走n+1步,然后slow指针再跟着走,这样子就可以方便的实现删除倒数第n个指针
        while (n-- && fast) {
            fast = fast->next;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        ListNode* newNode = dummy->next;
        delete dummy;
        return newNode;
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr){
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);
    int n = 2;
    Solution sol;
    ListNode* ans = sol.removeNthFromEnd(head, n);
    printList(ans);
    return 0;
}

3.面试题02.07链表相交

Leetcode题目链接

这道题的主要思路是先将两个链表的长度求出,然后让长链表先移动,移动到和短链表长度相同的时候,再将两个链表一起移动,直到移动到两个链表相交。

代码如下:

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* currA = headA;
        ListNode* currB = headB;
        int numA = 0, numB = 0;
        while (currA) {
            currA = currA->next;
            numA++;
        }
        while (currB) {
            currB = currB->next;
            numB++;
        }
        currA = headA; //重新将其指针currA和currB复位
        currB = headB;
        if (numA > numB) {
            while (numA > numB) {
                currA = currA->next;
                numA--;
            }
        } else if (numA < numB) {
            while (numA < numB) {
                currB = currB->next;
                numB--;
            }
        }
        while (currA != currB) {
            currA = currA->next;
            currB = currB->next;
        }
        return currA;
    }
};

可在本地IDE完整运行的代码如下:

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* currA = headA;
        ListNode* currB = headB;
        int numA = 0, numB = 0;
        while (currA) {
            currA = currA->next;
            numA++;
        }
        while (currB) {
            currB = currB->next;
            numB++;
        }
        currA = headA; //重新将其指针currA和currB复位
        currB = headB;
        if (numA > numB) {
            while (numA > numB) {
                currA = currA->next;
                numA--;
            }
        } else if (numA < numB) {
            while (numA < numB) {
                currB = currB->next;
                numB--;
            }
        }
        while (currA != currB) {
            currA = currA->next;
            currB = currB->next;
        }
        return currA;
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    Solution sol;
    ListNode* headA = new ListNode(4);
    headA->next = new ListNode(1);
    headA->next->next = new ListNode(8);
    headA->next->next->next = new ListNode(4);
    headA->next->next->next->next = new ListNode(5);
    ListNode* headB = new ListNode(5);
    headB->next = new ListNode(0);
    headB->next->next = new ListNode(1);
    headB->next->next->next = new ListNode(8);
    headB->next->next->next->next = new ListNode(4);
    headB->next->next->next->next->next = new ListNode(5);
    ListNode* ans = sol.getIntersectionNode(headA, headB);
    printList(ans);
    return 0;
}

4.环形链表

Leetcode题目链接

这道题我个人认为有一定难度。其中,有两个难点:1.如何知道链表是否相交 2.如何找到链表相交的入口点。

关于第一个问题,可以定义两个指针,一个快指针和一个慢指针。快指针一次走两步,慢指针一次走一步。如果快指针和慢指针能够相遇,那么则说明该链表中有环!

关于第二个问题,需要一些数学公式的推导,Carl的代码随想录中有详细的推导公式和动图,可以去查看:代码随想录:环形链表

代码如下:

class Solution {
public:
    ListNode *detectCycle(ListNode *head) { //首先,如何判断链表是否有环?定义两个指针fast和slow,快指针每次移动两格,慢指针每次移动一格。如果有环的话,快慢指针会相遇。
    //其次,如果有环,如何找到环的起始点?这其中设计一些数学推导,推导十分醍醐灌顶,最好去代码随想录中阅读!
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
    }
};

可在本地IDE完整运行的代码如下:

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode *detectCycle(ListNode *head) { //首先,如何判断链表是否有环?定义两个指针fast和slow,快指针每次移动两格,慢指针每次移动一格。如果有环的话,快慢指针会相遇。
    //其次,如果有环,如何找到环的起始点?这其中设计一些数学推导,推导十分醍醐灌顶,最好去代码随想录中阅读!
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
    }
};

void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    Solution sol;
    
    // 创建一个带有环的链表
    ListNode* head = new ListNode(1);
    ListNode* cycleNode = new ListNode(2);
    head->next = cycleNode;
    cycleNode->next = new ListNode(3);
    cycleNode->next->next = new ListNode(4);
    cycleNode->next->next->next = cycleNode;  // 创建循环
    
    // 调用 detectCycle 函数查找环的起始点
    ListNode* cycleStart = sol.detectCycle(head);
    
    if (cycleStart) {
        cout << "链表有环,环的起始点的值为: " << cycleStart->val << endl;
    } else {
        cout << "链表没有环" << endl;
    }
    
    return 0;
}

今毕。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录算法训练营是一个优质的学习和讨论平台,提供了丰富的算法训练内容和讨论交流机会。在训练营中,学员们可以通过观看视频讲解来学习算法知识,并根据讲解内容进行刷题练习。此外,训练营还提供了刷题建议,例如先看视频、了解自己所使用的编程语言、使用日志等方法来提高刷题效果和语言掌握程度。 训练营中的讨论内容非常丰富,涵盖了各种算法知识点和解题方法。例如,在第14天的训练营中,讲解了二叉树的理论基础、递归遍历、迭代遍历和统一遍历的内容。此外,在讨论中还分享了相关的博客文章和配图,帮助学员更好地理解和掌握二叉树的遍历方法。 训练营还提供了每日的讨论知识点,例如在第15天的讨论中,介绍了层序遍历的方法和使用队列来模拟一层一层遍历的效果。在第16天的讨论中,重点讨论了如何进行调试(debug)的方法,认为掌握调试技巧可以帮助学员更好地解决问题和写出正确的算法代码。 总之,代码随想录算法训练营是一个提供优质学习和讨论环境的平台,可以帮助学员系统地学习算法知识,并提供了丰富的讨论内容和刷题建议来提高算法编程能力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [代码随想录算法训练营每日精华](https://blog.csdn.net/weixin_38556197/article/details/128462133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值