链表操作综合

1题目

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();

linkedList.addAtHead(1);

linkedList.addAtTail(3);

linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3

linkedList.get(1); //返回2

linkedList.deleteAtIndex(1); //现在链表是1-> 3

linkedList.get(1); //返回3

提示：

• 0 <= index, val <= 1000

• 请不要使用内置的 LinkedList 库。

• get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

2链接

题目链：707. 设计链表 - 力扣（Leetcode）

视频链接：帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

3解题思路

这道题目设计链表的五个接口，已经覆盖了链表的常见操作：

1.获取链表第index个节点的数值

2.在链表的最前面插入一个节点

3.在链表的最后面插入一个节点

4.在链表第index个节点前面插入一个节点

5.删除链表的第index个节点

后面统一采用设置一个虚拟头节点进行操作。

首先在public中定义链表节点结构体并初始化，初始化所需要的变量在private中定义。

注意链表结构体的定义方式

1. 获取链表第index个节点的数值

定义指针cur，指向虚拟头节点的下一个节点，while（index--）循环遍历整个链表。直到index==0时，证明cur指向了目标节点，返回cur->val。

不知道cur究竟指向dummyHead还是dummyHead->next时，就用极限思维。

加入index==0，即获取第0个节点的值，不进入while循环。此时cur如果定义为dummyHead->next，打印cur->val就是0节点的值。cur如果定义为dummyHead，打印cur->next->val就是0节点的值。

2. 在链表的最前面插入一个节点

注意操作顺序为先1后2。

因为我们不知道head的地址，只能用它的上一个节点和指针（虚拟节点）来表示相关操作。如果先2后1，会造成dummyHead断开与head的链接，newNode再想链接head已经找不到head地址了。头节点(head)被虚拟头节点(dummyHead)所锚定，丢失了虚拟头节点(dummyHead)就找不到了，除非有一个在丢失虚拟头节点(dummyHead)前有一个新的节点(newNode)锚定了头结点(head)。

3. 在链表的最后面插入一个节点

cur指向dummyHead或者dummyHead->next（没啥影响），然后遍历直到cur->next == nullptr，说明cur指向了最后一个节点。

然后把cur->next和newNode进行链接就完事了。

4. 在链表第index个节点前面插入一个节点

这里定义cur指向dummyHead，举例index=2时，while(index--)循环2次，cur往后挪2位。在链表的第2个节点前插入新节点newNode。

注意本题的节点从0开始，在我的示意图里第2个节点就是指最后一个节点了。

此时只要操作cur->next和newNode就行了。

5. 删除链表的第index个节点

这里设置cur指向dummyHead，例如index=1，删除第1个节点，cur循环后移1个位置。

待删除的节点为cur->next，设临时指针temp指向此处。

先让cur->next指向cur->next->next，完后再删除temp，释放cur->next所指向的节点内存。

注意每一个节点的地址都是由上一个节点的指针所表示，cur指向的节点，这个节点出来的指针实际上是cur->next。待删除的节点地址就是cur->next，它下一个节点的地址是cur->next->next。

4代码

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

    //初始化链表
    MyLinkedList() {
        //注意dummyHead和size在私有成员变量中定义，代码最后面。
        dummyHead = new LinkedNode(0);//new分配一个虚拟头结点
        size = 0;
    }

    //获取链表中第 index 个节点的值。如果索引无效，则返回-1。注意index=0指的是第一个节点
    int get(int index) {
        if (index > (size - 1) || index < 0) {
            return -1;
        }
        else {
            LinkedNode* cur = dummyHead->next;
            while (index--) {
                cur = cur->next;
            }
            return cur->val;
        }
    }
    
    //在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = dummyHead->next;//注意顺序，先让newNode指向head
        dummyHead->next = newNode;//再让dummyHead指向newNode
        size++;
    }
    
    //将值为 val 的节点追加到链表的最后一个元素。
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);//根据结构体定义，创建新的节点，默认指向nullptr
        LinkedNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newNode;
        size++;
    }
    
    //在链表中的第 index 个节点之前添加值为 val  的节点。
    //如果 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;
            index--;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }
    
    //如果索引 index 有效，则删除链表中的第 index 个节点。
    void deleteAtIndex(int index) {
        if (index < 0 || index > (size - 1)) return ;
        else {
            //注意不能用dummyHead->next，否则删除的节点就是cur了，不知道cur的前一个指针，无法执行删除操作。
            //因为删除是把前一个节点的指针指向后一个节点，
            LinkedNode* cur = dummyHead;
            while (index) {
                cur = cur->next;
                index--;
            }
            LinkedNode* temp = cur->next;//待删除的节点是cur->next，因为这样才能知道前一个节点
            cur->next = cur->next->next;
            delete temp;
            size--;
        }
    }

    //打印链表
    void PrintLinkedList() {
        LinkedNode* cur = dummyHead;//cur指向虚拟节点，则待打印的是cur->next->val
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout <<endl;
    }

private:
    int size;
    LinkedNode* dummyHead;
};

/**
 * 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);
 */