【算法篇】链表类（笔记）

最新推荐文章于 2025-04-05 09:36:18 发布
最新推荐文章于 2025-04-05 09:36:18 发布
阅读量996 收藏 22
点赞数 21
分类专栏： 算法 文章标签： 算法 链表 笔记 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CXDNW/article/details/142179618
版权

目录

一、移除链表元素

二、设计链表

三、反转链表

1.双指针法

2. 递归法

四、两两交换链表中的节点

五、删除链表的倒数第N个节点

六、面试题 02.07.链表相交

七、环形链表II

一、移除链表元素

203. 移除链表元素 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/remove-linked-list-elements/description/

        给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]

思路：

        设置一个虚拟头结点移除节点操作。最后 return 头结点的时候，应为 return h->next;， 这才是新的头结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* h = new ListNode(0); // 头
        h->next = head;
        ListNode* cur = h;
        while(cur->next != NULL)
        {
            if(cur->next->val == val)
            {
                // 删除后面的一个节点
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else
            {
                cur = cur->next;
            }
        }
        return h->next;
    }
};

二、设计链表

707. 设计链表 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/design-linked-list/description/

        选择使用单链表或者双链表，设计并实现自己的链表。

        单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

        如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。
示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 虚拟头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

三、反转链表

206. 反转链表 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/reverse-linked-list/description/

        给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

 

示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]

1.双指针法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* tmp;
        while(cur != nullptr)
        {
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

        首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。然后开始反转，首先要把 cur->next 节点用tmp指针保存。接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时 pre指针就指向了新的头结点。

2. 递归法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:

    ListNode* reverse(ListNode* pre, ListNode* cur)
    {
        if(cur == nullptr) {
            return pre;
        }

        ListNode* tmp = cur->next;
        cur->next = pre;

        return reverse(cur, tmp);
    }

    ListNode* reverseList(ListNode* head) {
        // 递归法
        return reverse(nullptr, head);
    }
};

四、两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/swap-nodes-in-pairs/description/

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

 

示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr) return nullptr;
        if(head->next == nullptr) return head;

        ListNode* h = new ListNode(0);
        h->next = head;
        ListNode* cur = h;
        while(cur->next != nullptr && cur->next->next != nullptr)
        {
            ListNode* nxt = cur->next;
            
            // 交换
            cur->next = nxt->next;
            nxt->next = nxt->next->next;
            cur->next->next = nxt;
            
            cur = nxt;
        }
        ListNode* result = h->next;  // 删除头节点
        delete h;
        return result;
    }
};

五、删除链表的倒数第N个节点

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

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

实例1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]

思路：

（1）定义 fast 指针 和 slow 指针，初始值为 虚拟头结点。

（2）fast 首先走 n + 1 步 ，为什么是 n+1 呢，因为 只有这样同时移动的 时候 slow 才能 指向删除节点的 上一个节点（方便做 删除操作）。

（3）fast 和 slow 同时移动，直到 fast 指向末尾。

（4）删除 slow 指向的下一个节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head->next == nullptr && n == 1) return nullptr;
        if(head->next == nullptr && n == 0) return head;

        // 快满指针
        ListNode* h = new ListNode(0);
        h->next = head;
        ListNode* left = h;
        ListNode* right = h;

        while(n--)
        {
            right = right->next;
        }
        while(right->next != nullptr)
        {
            right = right->next;
            left = left->next;
        }

        if(right->next == nullptr)
        {
            ListNode* tmp = left->next;
            left->next = left->next->next;
            delete tmp;
        }
        return h->next;
    }
};

六、​​​​​​​面试题 02.07.链表相交

面试题 02.07. 链表相交 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

思路：

         设 curA 指向 链表 A 的头结点，curB 指向 链表 B 的头结点。求出两个链表的长度，并求出两个链表长度的 差值，然后让 curA 移动到，和 curB 末尾对齐的 位置。此时就可以比较 curA 和 curB 是否相同，如果 不相同，同时向后移动 curA 和 curB，如果遇到 curA == curB，则找到交点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 只能先对齐
        int lenA = 0;
        int lenB = 0;
        ListNode* curA = headA;
        ListNode* curB = headB;
        int relenA = 0;  // A、B 对应得下标值点
        int relenB = 0;
        // 计算长度
        while(curA != NULL)
        {
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL)
        {
            curB = curB->next;
            lenB++;
        }

        int len = lenA - lenB;
        if(len > 0)
        {
            // A 长
            relenA += len;
            while(len--)
            {
                headA = headA->next;
            }
        }
        else if(len < 0)
        {
            // B 长
            len = abs(len);
            relenB += len;
            while(len--)
            {
                headB = headB->next;
            }
        }

        // 判断
        while(headA != NULL && headB != NULL)
        {
            if(headA == headB)
            {
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
            relenA++;
            relenB++;
        }

        return NULL;
    }
};

七、环形链表II

142. 环形链表 II - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/linked-list-cycle-ii/description/

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

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

        不允许修改 链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

思路：

        可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指 针 每次移动 两个节点，slow 指针 每次移动 一个节点，如果 fast 和 slow指针在途中 相遇 ，说明这个 链表有环。

        fast 指针一定先进入环中，如果 fast 指针 和 slow 指针相遇的话，一定是 在环中相遇，这是毋庸置疑 的。

        因为 fast 是走两步，slow 是走一步，其实相对于 slow 来说，fast 是一个节点一个节点的 靠近 slow 的，所以 fast 一定 可以 和 slow 重合。

        假设从 头结点到环形入口节点 的节点数为 x。 环形入口节点到 fast 指针 与 slow 指针 相遇节点 节点数为 y。 从 相遇节点 再到环形入口 节点节点数为 z。如下图：

        那么相遇时： slow 指针 走过的节点数为: x + y， fast 指针走过的节点数：x + y + n (y + z)，n 为 fast 指针在环内走了 n 圈 才遇到 slow 指针， （y+z）为 一圈内节点的个数 A。

        因为 fast 指针 是一步走两个节点，slow 指针 一步走一个节点， 所以 fast 指针 走过的节点数 = slow 指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)。所以 x = n (y + z) - y 。整理公式得：x = (n - 1) (y + z) + z ，这里 n 一定是大于 等于 1 的，因为 fast 指针 至少要多 走一圈才能 相遇 slow 指针。

        当 n 为 1 的时，公式就化解为 x = z，这表示 fast 指针 在环形里 转了一圈 之后，就 遇到了 slow 指针 了。所以，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 快慢指针
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast != NULL && fast->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;

            // 环内相遇节点
            if(slow == fast)
            {
                ListNode* index1 = head;
                ListNode* index2 = slow;
                while(index1 != index2)
                {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};

数据结构与算法学习笔记
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Hello算法——笔记
淡水瑜的博客
05-10 5390
不同的数据结构在空间占用、时间复杂度和操作效率等方面有所不同，合理选择和使用数据结构可以提高程序的性能和效率。理解和掌握不同的数据结构对于解决复杂的计算问题和设计高效的程序非常重要。总之，算法是计算机科学中非常重要的概念，它们是解决问题和执行任务的基础工具，对于计算机程序的设计和优化起着关键作用。不同的数据结构适用于不同的场景和问题，可以提供高效的数据存储和访问方式。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。算法的设计和分析是计算机科学的重要研究领域，有许多经典的算法被广泛应用于各种领域。
算法通关村第一关——链表青铜挑战笔记
weixin_45876773的博客
09-11 647
删除的过程不算复杂，也是找到要删除的结点的前驱结点，这里同样要在提前一个位置判断，例如下图中删除 40，其前驱结点为 7。节点类存储数据和指向前一个以及后一个节点的指针。这里通过栈中的引用（也就是地址）就可以找到 val(1) ，然后 val(1) 结点又存了指向 val(2) 的地址，而 val(3) 又存了指向 val(4) 的地址，所以就构造出了一个链条访问结构。首先要理解 JVM 是怎么构建出链表的，JVM 里有栈区和堆区，栈区主要存引用，也就是一个指向实际对象的地址，而堆区存的才是创建的对象。
Leetcode刷题笔记——排序算法篇
qq_42898642的博客
02-16 2145
本文给大家介绍了面试中常考的关于排序问题的算法题，本文重点介绍了计数排序、快速排序、堆排序（重点）、插入排序、归并排序（重点）、桶排序、还有自定义排序规则
python学习笔记（9）算法（2）链表
m0_74370400的博客
11-24 1262
内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。 链表（linked list）是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。 引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。 链表的设计使得各个节点可以分散存储在内存各处，它们的内存地址无须连续。 2.初始化链表 建立链表分
c++刷算法【链表】
m0_52712579的博客
03-08 648
温习数据结构与算法，准备一些比赛，为了学业和就业，以及提升自己的编程能力，将系统的刷刷算法，入手c++跟着carl，leetcode刷题笔记将持续更新… 链表 定义链表节点方式，如下所示： // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 通过自己定义构造函数初始化节点
算法通关村第一关———链表青铜挑战笔记
m0_74313947的博客
07-17 1181
通过类来构建节点，用next指针将节点连起来。
数据结构与算法——链表
LoveXming的博客
03-12 1677
数据结构与算法——链表
【算法模板】链表篇—（附牛客习题）
小宝的博客
07-15 3082
我们必须先学会承受，再学会参与。承受是需要阅历和沉实的，参与也有需要勇气和激情。生活就是在热情与平淡中慢慢的磨合的。
算法笔记3_算法笔记_浙大_
09-30
《算法笔记3》是针对浙江大学计算机科学与技术专业学生及准备参加PAT（全国计算机等级考试——编程类）的考生编写的参考资料，主要采用C/C++语言进行讲解。这本书旨在帮助读者提升算法理解与编程能力，为机试和PAT...
LeetCode算法数据结构专训笔记,
03-26
【LeetCode算法数据结构专训笔记】 LeetCode是一个广受欢迎的在线平台，它提供了大量的算法和数据结构问题供用户练习和提升。通过刷LeetCode的题目，你可以显著提高自己的算法能力，尤其是对于链表、树等数据结构的...
算法笔记.胡凡
03-23
《算法笔记.胡凡》是一本深入浅出的算法学习资料，主要针对想要提升算法能力的读者，无论你是初学者还是有一定基础的程序员，都能从中受益。这本书通过丰富的实例和清晰的代码，帮助读者理解并掌握各种算法的核心...
【LeetCode 热题100】 45. 跳跃游戏 II 的算法思路及python代码
pljnb的博客
04-03 569
给定一个长度为 n 的 0 索引整数数组nums。初始位置为nums[0]。每个元素nums[i]表示从索引 i 向后跳转的最大长度。换句话说，如果你在nums[i]处，你可以跳转到任意返回到达的最小跳跃次数。生成的测试用例可以到达。
[dp_3 路径问题] 不同路径 | 障碍物 II | 珠宝的最高价值
一个人知道自己为什么而活，他就能够接收任何一种生活
04-03 1082
初始化 | 虚拟节点 | 想从dp表找回之前矩阵的位置所以下标都要统一-1才行。i-1，j-1。 依赖前两位,所以要初始两位 if(s[0]=='0') return 0; //这个是这个题目的特殊意思要领悟到 ● 动态规划就是一个从小往大的有逻辑性的计算 ● 以此来避免对相同的事情重复计算很多次 ● 因为填表之后，如果碰到已经计算过的数值就可以直接进行调用啦~
算法 ｜ 神教优化算法(Divine Religions Algorithm, DRA)原理，公式，应用，算法改进研究综述，matlab代码
尘世冰封的专栏
04-03 116
神教优化算法；元启发式算法；宗教行为模拟；群体智能；MATLAB实现。
深入解析力扣39.组合总和：回溯算法的妙用
2302_81116822的博客
04-01 549
给定一个无重复元素的数组candidates和一个目标值target，找出candidates中所有可以使数字和为target的组合。数组中的数字可以被重复使用。
【算法/c++】利用中序遍历和后序遍历建二叉树
qq_72680384的博客
04-04 907
树，数组模拟树，c++
算法刷题记录——LeetCode篇(2.3) [第121~130题](持续更新)
最新发布
weixin_42826353的博客
04-05 750
LeetCode121-130个人刷题总结。
算法 ｜ 基于灰狼优化算法求解带时间窗的车辆路径问题（VRPTW）研究（附matlab代码）
尘世冰封的专栏
04-02 254
带时间窗的车辆路径问题（Vehicle Routing Problem with Time Windows, VRPTW）是物流配送领域的关键挑战。本文提出一种基于灰狼优化算法（Grey Wolf Optimizer, GWO）的求解方法，通过模拟灰狼群体狩猎行为，结合动态参数调整策略，优化车辆路径的总行驶距离与时间窗约束满足率。实验结果表明，GWO算法在求解VRPTW时，相较于粒子群优化（PSO）和遗传算法（GA），具有更快的收敛速度和更优的路径成本。
C++学习：数据结构与算法分析笔记
数据结构包括数组、链表、栈、队列、树、图等，而算法则涉及排序、查找、图算法等。学习者需要理解每种数据结构的特点、优缺点以及适用场景，同时掌握不同算法的实现方式和效率。 2. **权衡概念**：在选择数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值