LeetCode 707. 设计链表 双链表

题目描述

题目来源：力扣（LeetCode）
题目链接：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 个节点。
示例 1:

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

提示：

• 所有val值都在 [1, 1000] 之内。
• 操作次数将在  [1, 1000] 之内。
• 请不要使用内置的 LinkedList 库。

解题方法：双链表

思路

为了方便操作，使用头部、尾部哑节点，并且使用双链表。
获取指定位置元素时，如果该位置位于双链表前半部分，那么从左向右遍历；否则，从右向左遍历。

代码

struct Node {
    int val;
    Node* next;
    Node* prev;
    Node(int val) : val(val), next(nullptr), prev(nullptr) {}
    Node() : val(0), next(nullptr), prev(nullptr) {}
};
class MyLinkedList {
public:
    MyLinkedList() : size(0) {
        // 头部哑节点
        head = new Node;
        // 尾部哑节点
        tail = new Node;
        head->next = tail;
        tail->prev = head;
    }

    int get(int index) {
        auto p = getNode(index);
        if(!p) {
            return -1;
        }
        return p->val;
    }

    void addAtHead(int val) {
        auto p = new Node(val);
        p->next = head->next;
        p->prev = head;
        p->next->prev = p;
        head->next = p;
        // 更新长度
        ++size;
    }

    void addAtTail(int val) {
        auto p = new Node(val);
        p->next = tail;
        p->prev = tail->prev;
        tail->prev = p;
        p->prev->next = p;
        // 更新长度
        ++size;
    }

    void addAtIndex(int index, int val) {
        if(index > size) {
            return;
        }
        if(index < 0) {
            addAtHead(val);
            return;
        }
        Node* p;
        if(index == size) {
            // 指向尾节点
            p = tail;
        }else {
            p = getNode(index);
        }
        auto tmp = new Node(val);
        tmp->next = p;
        tmp->prev = p->prev;
        tmp->next->prev = tmp;
        tmp->prev->next = tmp;
        // 更新长度
        ++size;
    }

    void deleteAtIndex(int index) {
        if(index < 0 || index >= size) {
            return;
        }
        auto p = getNode(index);
        // 移除 p 节点
        p->prev->next = p->next;
        p->next->prev = p->prev;
        // 释放内存
        delete p;
        // 更新长度
        --size;
    }

    Node* getNode(int index) {
        // 参数错误
        if(index < 0 || index >= size) {
            return nullptr;
        }
        Node* p;
        if(index < size / 2) {
            p = head->next;
            // 从左边遍历
            for(int i = 0; i < index; ++i) {
                p = p->next;
            }
        }else {
            p = tail->prev;
            // 从右边遍历
            for(int i = size - 1; i > index; --i) {
                p = p->prev;
            }
        }
        return p;
    }
private:
    int size;
    Node* head;
    Node* tail;
};