链表——非连续线性表

已于 2024-01-13 22:39:00 修改
阅读量806 收藏 16
点赞数 19
文章标签： 链表 数据结构 c++
于 2023-12-10 19:44:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74421524/article/details/134911995
版权

链表（Linked List）是最简单的线性的、动态数据结构。理解它是理解树结构、图结构的基础。

区别于数组，链表中的元素不是存储在内存中连续的一片区域，链表中的数据存储在每一个称之为「结点」复合区域里，在每一个结点除了存储数据以外，还保存了到下一个节点的指针（Pointer）。

image.png

由于不必按顺序存储，链表在插入数据的时候可以达到 O(1) 的复杂度，但是查找一个节点或者访问特定编号的节点则需要 O(n) 的时间。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（links）。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的访问往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。

链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。

链表通常可以衍生出循环链表，静态链表，双链表等。对于链表使用，灵活使用虚拟头结点可以简化问题。

单链表

结点结构

以下是单链表中结点的典型定义：

// Definition for singly-linked list.
struct SinglyListNode {
    int val;
    SinglyListNode *next;
    SinglyListNode(int x) : val(x), next(NULL) {}
};

在大多数情况下，我们将使用头结点(第一个结点)来表示整个列表。

操作

与数组不同，我们无法在常量时间内访问单链表中的随机元素。 如果我们想要获得第 i 个元素，我们必须从头结点逐个遍历。 我们按索引来访问元素平均要花费 O(N) 时间，其中 N 是链表的长度。

在开头添加结点

众所周知，我们使用头结点来代表整个列表。

因此，在列表开头添加新节点时更新头结点 head 至关重要。

1.初始化一个新结点 cur ；
2.将新结点链接到我们的原始头结点 head。
3.将 cur 指定为 head 。

删除第一个结点

如果我们想删除第一个结点，策略会有所不同。

正如之前所提到的，我们使用头结点 head 来表示链表。我们的头是下面示例中的黑色结点 23。

如果想要删除第一个结点，我们可以简单地将下一个结点分配给 head。

设计链表

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

单链表中的节点应该具备两个属性：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);    
myLinkedList.get(1);              
myLinkedList.deleteAtIndex(1);    
myLinkedList.get(1);              

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

class MyLinkedList {
private:
    int size;
    ListNode *dummyhead;
public:
    MyLinkedList() {
        size = 0;
        dummyhead = new ListNode();
    }
    
    int get(int index) {
        if(index < 0 || index > size - 1){
            return -1;
        }
        ListNode *head = dummyhead -> next;
        while(index--)
        {
            head = head -> next;
        }
        return head -> val;
    }
    
    void addAtHead(int val) {
        // if(val < 0 || val > 1000||val>size){
        //     return ;
        // }
        // ListNode *cur = dummyhead -> next;
        ListNode *n = new ListNode(val);
        n -> next = dummyhead -> next;
        dummyhead -> next = n;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode *n = new ListNode(val) , *cur = dummyhead;;
        if(val < 0 || val > 1000){
            return;
        }
        while(cur->next){
            cur = cur -> next;
        }
        cur -> next = n;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(val < 0 || val > 1000 || index > size){
            return;
        }
        if(index <= 0){
            addAtHead(val);
        }
        else if(index == size){
            addAtTail(val);
        }
        else{
            ListNode *n = new ListNode(val) , *cur = dummyhead;
            while(index--){
                cur = cur -> next;
            }
            n -> next = cur -> next;
            cur -> next = n;

            size++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >= size ){
            return;
        }
        ListNode *cur = dummyhead , *t ;
        while(index--){
            cur = cur -> next;
        }
        t = cur -> next;
        cur -> next = t -> next;
        delete t;
        size--;
    }
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

链表中的双指针

让我们从一个经典问题开始：

给定一个链表，判断链表中是否有环。

我们在链表中使用两个速度不同的指针时会遇到的情况：

  1. 如果没有环，快指针将停在链表的末尾。
  2. 如果有环，快指针最终将与慢指针相遇。

所以剩下的问题是：

这两个指针的适当速度应该是多少？

每次移动慢指针一步，而移动快指针两步。每一次迭代，快速指针将额外移动一步。如果环的长度为 M，经过 M 次迭代后，快指针肯定会多绕环一周，并赶上慢指针。

环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

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

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

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

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

  • 链表中节点的数目范围是 [0, 104]
  • -105 <= Node.val <= 105
  • pos 为 -1 或者链表中的一个 有效索引 。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

​
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *p=head;
        ListNode *q=head;
        if (p==NULL){return false;}
        else if(p->next==NULL){
        return false;
        }
        else if(p->next->next==NULL){
        return false;
        }
        else{
        p=p->next->next;
        q=q->next;
        while(p!=q&&p->next!=NULL&&p->next->next!=NULL){
        p=p->next->next;
        q=q->next;
        }}
        if(p==q){return true;}
        else {return false;}
    }
};

​

环形链表 II

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

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

不允许修改 链表。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

  • 链表中节点的数目范围在范围 [0, 104] 内
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？

/**
 * 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) {
        unordered_set<ListNode*> s;
        ListNode* p = head;
        while (p) {
            if (s.find(p) != s.end())
                return p;
            s.insert(p);
            p = p->next;
        }
        return NULL;
    }
};

相交链表

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

  • intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
  • listA - 第一个链表
  • listB - 第二个链表
  • skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
  • skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

 

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

 

示例 2：

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

示例 3：

输入：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 。

 

提示：

  • listA 中节点数目为 m
  • listB 中节点数目为 n
  • 1 <= m, n <= 3 * 104
  • 1 <= Node.val <= 105
  • 0 <= skipA <= m
  • 0 <= skipB <= n
  • 如果 listA 和 listB 没有交点，intersectVal 为 0
  • 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

 

/**
 * 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) {
//         if(headA == nullptr || headB == nullptr){
//             return nullptr;
//         }
//         auto pa = headA, pb = headB;
//         while(pa != pb){
//             pa = pa == nullptr ? headB : pa->next;
//             pb = pb == nullptr ? headA : pb->next;
//         }
//         return pa;
//     }
// };


int init = [] {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ofstream out("user.out");
    for (string s; getline(cin, s);) {
        if (s != "0") out << "Intersected at '" << s << "'\n";
        else out << "No intersection\n";
        for (int i = 0; i < 4; ++i) getline(cin, s);
    }
    out.flush();
    exit(0);
    return 0;
}();
class Solution {
    public:
        ListNode *getIntersectionNode(ListNode *, ListNode *) { return 0; }
};

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

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

给你一个链表，删除链表的倒数第 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]

提示：
  • 链表中结点的数目为 sz
  • 1 <= sz <= 30
  • 0 <= Node.val <= 100
  • 1 <= n <= sz

进阶：你能尝试使用一趟扫描实现吗？

/**
 * 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:
    void earase(ListNode* pos){
        auto *del=pos->next;
        pos->next=pos->next->next;
        delete del;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        auto* gan=new ListNode(666,head);
        int len=0;
        for(auto* pos=head;pos;pos=pos->next){
            ++len;
        }
        auto* pos=gan;
        for(int i=1;i<=len-n;i++){
            pos=pos->next;
        }
        earase(pos);
        return gan->next;
    }
    
};

在这里，我们为你提供了一个模板，用于解决链表中的双指针问题。

// Initialize slow & fast pointers
ListNode* slow = head;
ListNode* fast = head;
/**
 * Change this condition to fit specific problem.
 * Attention: remember to avoid null-pointer error
 **/
while (slow && fast && fast->next) {
    slow = slow->next;          // move slow pointer one step each time
    fast = fast->next->next;    // move fast pointer two steps each time
    if (slow == fast) {         // change this condition to fit specific problem
        return true;
    }
}
return false;   // change return value to fit specific problem

复杂度分析

在前面的查找循环示例中，假设我们每次移动较快的指针 2 步，每次移动较慢的指针 1 步。

1.如果没有循环，快指针需要 N/2 次才能到达链表的末尾，其中 N 是链表的长度。
2.如果存在循环，则快指针需要 M 次才能赶上慢指针，其中 M 是列表中循环的长度。
显然，M <= N 。所以我们将循环运行 N 次。对于每次循环，我们只需要常量级的时间。因此，该算法的时间复杂度总共为 O(N)。

经典问题

反转链表

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

示例 1：

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

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

  • 链表中节点的数目范围是 [0, 5000]
  • -5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

/**
 * 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) {
        if (head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode *prev = nullptr, *cur = head, *next = nullptr;
        while(cur != nullptr){
            next = cur->next;
            cur->next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
};

移除链表元素

给你一个链表的头节点 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
输出：[]

提示：

  • 列表中的节点数目在范围 [0, 104] 内
  • 1 <= Node.val <= 50
  • 0 <= val <= 50
  • /**
 * 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) {}
 * };
 */
 /*
 //解法1 正常解法
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};
*/
//解法2 递归
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==nullptr){
            return head;
        }
        head->next=removeElements(head->next,val);
        if(head->val==val){
            return head->next;
        }
        else{
            return head;
        }
    }
};

    奇偶链表

  • 给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。

    第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。

    请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

    你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

    示例 1:

    输入: head = [1,2,3,4,5]
输出: [1,3,5,2,4]

    示例 2:

    输入: head = [2,1,3,5,6,4,7]
输出: [2,3,6,7,1,5,4]

    提示:

  • n ==  链表中的节点数
  • 0 <= n <= 104
  • -10^6 <= Node.val <= 10^6
/**
 * 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* oddEvenList(ListNode* head) {
        ListNode* ans=new ListNode(-1);
        ListNode* res=ans;
        ListNode* pre=head;
        vector<ListNode*> vec;
        while(pre!=nullptr){
            ListNode* node=new ListNode(pre->val);
            vec.push_back(node);
            pre=pre->next;
        }
        for(int i=0;i<vec.size();i++){
            if((i+1)%2!=0){
                res->next=vec[i];
                res=res->next;
            }
        }
        for(int i=0;i<vec.size();i++){
            if((i+1)%2==0){
                res->next=vec[i];
                res=res->next;
            }
        }
        return ans->next;
    }
};

回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：head = [1,2,2,1]
输出：true

示例 2：

输入：head = [1,2]
输出：false

提示：

  • 链表中节点数目在范围[1, 105] 内
  • 0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(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:
    Solution()
    {
        ios_base::sync_with_stdio(false);
        cin.tie(nullptr);
        ofstream out("user.out");
        for (string s; getline(cin, s);)
            out << (equal(s.begin()+1, s.begin()+s.size()/2, s.rbegin()+1) ? "true\n" : "false\n");
        out.flush();
        exit(0);
    }
    bool isPalindrome(ListNode* head) {
        
        deque<ListNode*> q;

        ListNode* p = head;
        while (p != nullptr) {
            q.push_back(p);
            p = p->next;
        }

        ListNode *x, *y;
        while (q.size() >= 2) {
            x = *q.begin(), y = *q.rbegin();
            if (x->val != y->val) {
                return false;
            }
            q.pop_front();
            q.pop_back();
        }

        return true;
    }
}init;

注意：

1. 通过一些测试用例可以节省您的时间。

2. 你可以同时使用多个指针。

3. 在许多情况下，你需要跟踪当前结点的前一个结点。

双链表

双链表以类似的方式工作，但还有一个引用字段，称为“prev”字段。有了这个额外的字段，您就能够知道当前结点的前一个结点。

结点结构

下面是双链表中结点结构的典型定义：

// Definition for doubly-linked list.
struct DoublyListNode {
    int val;
    DoublyListNode *next, *prev;
    DoublyListNode(int x) : val(x), next(NULL), prev(NULL) {}
};

与单链接列表类似，我们将使用头结点来表示整个列表。

操作

1.我们不能在常量级的时间内访问随机位置。
2.我们必须从头部遍历才能得到我们想要的第一个结点。
3.在最坏的情况下，时间复杂度将是 O(N)，其中 N 是链表的长度。

添加操作

如果我们想在现有的结点 prev 之后插入一个新的结点 cur，我们可以将此过程分为两个步骤：

1.链接 cur 与 prev 和 next，其中 next 是 prev 原始的下一个节点；

2.用 cur 重新链接 prev 和 next。

与单链表类似，添加操作的时间和空间复杂度都是 O(1)。

删除操作

如果我们想从双链表中删除一个现有的结点 cur，我们可以简单地将它的前一个结点 prev 与下一个结点 next 链接起来。

不再需要遍历链表来获取前一个结点，所以时间和空间复杂度都是O(1)。

双链表删除第一个节点步骤：（删除头结点）

 1. 将原来的第一个节点的pre断开
 2. 让它的下一个节点的pre指向头节点（也就是变为头节点）
 3. 将原来的第一个节点的next节点指向null

总结

单链表和双链表的相同表现：

1.无法在常量时间内随机访问数据。
2.能够在 O(1) 时间内在给定结点之后或列表开头添加一个新结点。
3.能够在 O(1) 时间内删除第一个结点。

但是删除给定结点时略有不同。

在单链表中，它无法获取给定结点的前一个结点，因此在删除给定结点之前我们必须花费 O(N) 时间来找出前一结点。
在双链表中，这会更容易，因为我们可以使用“prev”引用字段获取前一个结点。因此我们可以在 O(1) 时间内删除给定结点。

这里我们提供链表和其他数据结构（包括数组，队列和栈）之间时间复杂度的比较：

经过这次比较，我们不难得出结论：

如果你需要经常添加或删除结点，链表可能是一个不错的选择。

如果你需要经常按索引访问元素，数组可能是比链表更好的选择。

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

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

输入：l1 = [ ],  l2 = [ ]
输出：[]
示例 3：

输入：l1 = [ ],  l2 = [0]
输出： [0]

提示：

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列
/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode *dummy = new ListNode(0);
        ListNode *cur = dummy;
        ListNode *ptr = nullptr;
        while (list1!=nullptr && list2!=nullptr)
        {
            ptr=(list1->val<list2->val) ? list1 : list2;
            cur->next = ptr;
            cur =cur->next;
            if(ptr == list1)
            {
                list1 =list1->next;
            }
            else
            {
                list2 = list2->next;
            }
            
            
        }
        cur->next =(list1) ? list1:list2;
        return dummy->next;
    }
};

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：


输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 <= Node.val <= 9
  • 题目数据保证列表表示的数字不含前导零
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head = nullptr, *tail = nullptr;
        int carry = 0;
        while (l1 || l2) {
            int n1 = l1 ? l1->val: 0;
            int n2 = l2 ? l2->val: 0;
            int sum = n1 + n2 + carry;
            if (!head) {
                head = tail = new ListNode(sum % 10);
            } else {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }
            carry = sum / 10;
            if (l1) {
                l1 = l1->next;
            }
            if (l2) {
                l2 = l2->next;
            }
        }
        if (carry > 0) {
            tail->next = new ListNode(carry);
        }
        return head;
    }
};

cc121512
关注
  • 19
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（一）线性链表、非线性链表、稀疏数组与队列、单向链表
codinglover5的博客
08-07 3100
数据结构和算法的关系 ➢数据data结 构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了 数据结构.学好数据结构可以编写出更加漂亮更加有效率的代码。 ➢要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. ➢程序=数据结构+算法 ➢数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。 线性链表和非线性链表 数据结构包括:线性结构和非线性结构。 线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在- -对- - 的线性关系（a[0]=3
线性表与链表
weixin_52744725的博客
08-08 1276
1、线性结构在数据元素的非空有限集中：存在唯一的一个被称做“第一个”的数据元素存在唯一的一个被称做“最后一个”的数据元素除第一个之外，集合中的每个数据元素均只有一个前驱除最后一个之外，集合中的每个数据元素均只有一个后继2、线性表线性表是n个数据元素的有限序列，同一线性表中的元素必定具有相同特性，相阾的数据元素之间存在着序偶关系。线性表中元素的个数n(n>=0)定义为线性表的长度，0==n时称为空表，在非空表中每个数据元素都有一个确定的位置(下标)。...
链表 一一非连续线性表
cyx6_6的博客
12-11 382
链表是物理存储上非连续的，由一系列节点组成。节点在运行时动态生成 ，每个节点包括两个部分：1）数据：存放数据，通常命名为 data,score等2）指针：存放下一个（或上一个）节点的地址，通常命名为 prev,next等。
初阶数据结构——线性表——链表——不带头单向链表
dtxew love c++
10-20 2809
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 知识回顾 在前一章中我们已经介绍了顺序表，相信大家对顺序表的实现已经有所了解了吧！ 但是，这种数据结构，难免会有以下的缺陷 我们在中间位置插入或删除数据的话，可能需要挪动后面的所有数据，时间复杂度较高==(O(n))== 我们的空间是按照2倍的常数开辟的，可能会造成空间的浪费，比
线性表——链表
weixin_46640900的博客
06-30 2488
顺序表和链表都是线性表的一种。但链表与顺序表不同的是，他的物理上与逻辑上的机构并不一致。 顺序表的话，逻辑相邻，物理上也是相邻的。所以对于一整块连续的物理地址，当我们进行插入和删除操作的时候就会需要大量的移动元素。 而链表不需要使用地址连续的存储单元，即不需要满足物理与逻辑一致，通过"链"建立数据之间的逻辑关系，当进行插入或删除操作的时候，只需要修改指针即可。线性表的链式存储为单链表，通过任意一组存储单元来存储数据。链表通过许多节点构成，节点除了放自身的数据还有存放下一个节点的地址来保证链表的逻辑关系。而链
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
链表和数组实现线性表
m0_63203388的博客
01-01 810
今天走入数据结构的线性表一节。希望各位大神多多指点哦。 (一）线性表 线性表可以看成排队列。第一个元素没有前驱元素，称为头结点。最后一个元素没有后驱元素，称尾结点。中间的每一个元素都有前驱元素和后驱元素。顺序表按照物理存储结构，又可以分为顺序表和链表。线性表没有元素的时候称为空表。表起的位置叫做表头，表结束的位置叫做表尾。常见的线性表：顺序表，链表，栈，队列，字符串。 （1）线性表是一种逻辑上连续的物理结构： 数组（物理上和逻辑上都是线性)——浪费内存 链表 (逻辑上线性，物理上非线性）——按需申
线性表的链式存储——链表
是小辰
04-14 629
链式存储是常用的动态存储方式，相对于顺序表，可以更好的任意插入与删除，而采用链式存储的结构叫做链表。 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 从链接方式的角度：链表分为单链表、双链表及循环链表； 从实现方式的角度：链表分为动态链表和静态链表；
线性表——顺序表和链表
qq_65285898的博客
08-21 2900
顺序表和链表的解释与实现
数据结构回顾——几类线性表对比与总结
只要思想不滑坡，想法总比问题多。
08-27 951
顺序表、单链表、双向链表、循环链表、静态链表等几类线性表，各自具有固有的特点、优缺点，决定其适用于不同的应用场景。
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; ...
数组和链表——精选推荐 数组和链表.pdf
04-18
数组和链表——精选推荐 数组和链表.pdf
数据结构——线性表
02-06
该文件包括各种线性表的头文件，另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的...
链表——用C++模板实现 - Microsues的专栏 - 博客频道 - CSDN1
08-03
摘要视图订阅数据结构（11）[cpp] view plain copyprint01.//单向链表的实现02.//查找、插入和移除某个元素、复制、清空单向链表的
C++语言实现线性表之链表实例
09-03
主要介绍了C++语言实现线性表之链表,实例分析了C++实现线性表中链表的原理与相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
P2【练习力扣933】【数据结构】【队列queue】C++版
qq_50891451的博客
05-18 493
，范围是 [-2900,100]，返回 2。]，范围是 [-2999,1]，返回 1。]，范围是 [1,3001]，返回 3。]，范围是 [2,3002]，返回 3。类来计算特定时间范围内最近的请求。的调用都使用比之前更大的。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 666
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 412
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 253
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
高级线性表——静态链表
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现思路是在数组中分配一段连续的空间，将链表中的各个结点存储在这个空间中，每个结点占用一个数组元素。数组中的第一个元素不存储结点数据，而是用来记录链表中第一个未被使用的结点的下标，通常称为头结点。静态链表的最后一个结点指向一个特殊的标记，通常为 -1，表示链表的结尾。 静态链表的实现可以解决链表的动态分配问题，因为它不需要像链表一样频繁地申请和释放内存。但是，静态链表的缺点是空间浪费，因为它需要预先分配一定的空间，如果链表中结点的数量超过了预分配的空间，就需要重新申请更大的空间。 静态链表支持链表基本操作，如插入、删除、查找等，具体实现可以参考链表的相关算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值