反转链表||&动静态链接

反转链表 II

第一种方法：使用数组顺序记录区间内节点的地址，然后双指针双向向内遍历节点地址，逐步交换节点存储数值。时间复杂度为on、空间复杂度为on

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode *pi = head;
        int n = 0;
        vector<ListNode*> lis;
        while(head)
        {
            n++;
            if(n>=left&&n<=right)
            {
                lis.emplace_back(head);
            }
            head = head->next;
        }
        int i = 0,j = lis.size()-1;
        while(i<j)
        {
            swap(lis[i++]->val,lis[j--]->val);
        }
        return pi;
    }
};

第二种方法：记录反转开始节点的前驱节点方便连接反转后的pre位置（结论：反转链表完成后cur处于空位，也就是反转后pre会处于right位置，可以直接使用反转开始处的前驱节点连接pre）那么pre处于right，cur处于right+1，记录反转开始处的节点用于连接cur位置，反转结束，如果left为1，也就是说是从头翻转的，那反转开始处的前驱节点为空，所以当这种情况时直接把pre设置为head，最后返回head。

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        // 边界情况检查
        if (!head || left == right) return head;

        ListNode *pre = nullptr, *cur = head;
        // 定位到 left 节点及其前驱节点
        for (int i = 1; cur && i < left; i++) {
            pre = cur;
            cur = cur->next;
        }

        // 保存反转部分的前驱节点
        ListNode *preLeft = pre, *postRight = cur;

        // 反转 [left, right] 区间的节点
        ListNode *prev = nullptr;
        for (int i = left; cur && i <= right; i++) {
            ListNode *next = cur->next;
            cur->next = prev;
            prev = cur;
            cur = next;
        }

        // 连接反转后的部分
        if (preLeft) {
            preLeft->next = prev;
        } else {
            // 如果 left 是 1，说明反转的是头部部分
            head = prev;
        }
        postRight->next = cur;

        return head;
    }
};

静态链接的特点是什么？

静态链接：

静态链接是程序和所有代码和代码所依赖的库直接链接到可执行文件的过程，在程序编译时，所有需要的库文件和目标文件都会在编译过程中合并。

特点：执行时不依赖外部库、可执行文件较大、运行时效率高、因为是静态的所以无法共享库的更新、可移植性好、编译时间较长。

动态链接的特点是什么？

动态链接：

动态链接是指在程序运行时，将程序所依赖的库文件（如 .dll 或 .so 文件）动态加载到内存中。这意味着程序在编译时并不包含所有库代码，而是依赖外部的共享库。

特点：运行时加载、较小的可执行文件、节省内存、支持共享库更新、动态加载库文件需要额外开销、依赖外部库（如果缺少必要的库文件程序无法运行）