LeetCode707. 设计链表（包括单链表和双向链表）

KeepCoding♪Toby♪

于 2022-10-29 17:02:12 发布

阅读量109

点赞数 3

分类专栏： LeetCode刷题文章标签：链表数据结构

本文链接：https://blog.csdn.net/m0_61843614/article/details/127589274

版权

LeetCode刷题专栏收录该内容

90 篇文章 7 订阅

订阅专栏

707. 设计链表

一、题目

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路及代码

方法一：双向链表实现（代码的注释挺详细的）

class MyLinkedList {
public:
    struct LinkNode
    {
        int val;
        LinkNode *next,*prev;
        LinkNode(int value):val(value),next(nullptr),prev(nullptr){}
    };

    //构造函数
    MyLinkedList() {
        head = new LinkNode(0);//头尾都是哨兵结点
        tail = new LinkNode(0);
        head->next = tail;
        tail->prev = head;
        size = 0;
    }
    
    //得到index位置的元素
    int get(int index) {
        //输入的index是否有效
        if(index >= size || index < 0){
            return -1;
        }
        LinkNode *p;
        //设head的序号为-1，tail为size，那么index与head距离为index+1,与tail距离为size-index
        if(index+1 < size-index)
        {
            p = head;
            for(int i = 0; i < index+1; i++){
                p = p->next;
            }
        }else{
            p  = tail;
            for(int i = 0; i < size-index; i++){
                p = p->prev;
            }
        }
        return p->val;
    }
    
    //在头上插入结点
    void addAtHead(int val) {
        LinkNode *newnode = new LinkNode(val);
        //因为head是哨兵结点，所以就在head后面插入即可
        newnode->next = head->next;
        newnode->prev = head;
        head->next->prev = newnode;
        head->next = newnode;
        size++;
        //addAtIndex(0,val);
    }
    
    //在尾部插入结点
    void addAtTail(int val) {
        LinkNode *newnode = new LinkNode(val);
        newnode->prev = tail->prev;
        newnode->next = tail;
        tail->prev->next = newnode;
        tail->prev = newnode;
        size++;
        //addAtIndex(size-1,val);
    }
    
    void addAtIndex(int index, int val) {
        if(index <= size){//因为可以插在第index个，所以这里可以取等
            //判断index和head近还是和tail近,从head出发只要到index-1就够了，从tail出发要到index
            //index-1到head的距离为index，index到size的距离为size-index
            if(index < size-index){
                LinkNode *p = head;
                //移动指针index次
                for(int i = 0; i < index; i++){
                    p = p->next;
                }
                //插入结点
                LinkNode *newnode = new LinkNode(val);
                newnode->next = p->next;
                newnode->prev = p;
                p->next->prev = newnode;
                p->next = newnode;
                size++;
            }else{
                LinkNode *p = tail;
                for(int i = 0; i < size-index; i++){
                    p = p->prev;
                }
                //插入结点
                LinkNode *newnode = new LinkNode(val);
                newnode->next = p;
                newnode->prev = p->prev;
                p->prev->next = newnode;
                p->prev = newnode;
                size++;
            }
        }
    }
    
    void deleteAtIndex(int index) {
        if(index < size){
            //判断index到head的距离长还是到tail的距离长
            //index到head的距离为index+1,index到tail的距离为size-index
            if(index+1 < size-index){
                LinkNode *p = head;
                for(int i = 0; i < index+1; i++){
                    p = p->next;
                }
                p->prev->next = p->next;
                p->next->prev = p->prev;
                delete p;
                size--;
            }else{
                LinkNode *p = tail;
                for(int i = 0; i < size-index; i++){
                    p = p->prev;
                }
                p->prev->next = p->next;
                p->next->prev = p->prev;
                delete p;
                size--;
            }
        }
    }
private:
    LinkNode *head;
    LinkNode *tail;
    int 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);
 */

方法二：虚拟头结点（单链表）

在真正意义上的head之前加一个虚拟的头结点，这样可以方便进行插入删除等操作。

class MyLinkedList {
public:
    struct LinkNode
    {
        int val;
        LinkNode *next;
        LinkNode(int value):val(value),next(nullptr){}
    };

    //构造函数
    MyLinkedList() {
        Vhead = new LinkNode(0);//头为虚拟头结点
        size = 0;
    }
    
    //得到index位置的元素
    int get(int index) {
        //输入的index是否有效
        if(index >= size || index < 0){
            return -1;
        }
        LinkNode *p = Vhead->next;//指针初始位置在虚拟头结点以后
        while(index--){//指针向后移动index次
            p = p->next;
        }
        return p->val;
    }
    
    //在头上插入结点
    void addAtHead(int val) {
        LinkNode *newnode = new LinkNode(val);
        //因为head是虚拟头结点，所以就在head后面插入即可
        newnode->next = Vhead->next;
        Vhead->next = newnode;
        size++;
        //addAtIndex(0,val);
    }
    
    //在尾部插入结点
    void addAtTail(int val) {
        LinkNode *newnode = new LinkNode(val);
        LinkNode *p = Vhead;
        while(p->next != NULL){
            p = p->next;
        }
        p->next = newnode;
        size++;
        //addAtIndex(size-1,val);
    }
    
    void addAtIndex(int index, int val) {
        //检验输入是否符合条件
        if(index > size || index < 0){
            return;
        }
        LinkNode *newnode = new LinkNode(val);
        LinkNode *p = Vhead;
        //移动指针
        while(index--){
            p = p->next;
        }
        //插入结点
        newnode->next = p->next;
        p->next = newnode;
        size++; 
    }
    
    void deleteAtIndex(int index) {
        //检验输入是否符合条件
        if(index >= size || index < 0){
            return;
        }
        LinkNode *p = Vhead;
        //移动指针
        while(index--){
            p = p->next;
        }
        //删除结点
        LinkNode *tmp = p->next;
        p->next = p->next->next;
        delete tmp;
        size--;
    }

private:
    LinkNode *Vhead;
    int 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);
 */