【Leetcode】 707. 设计链表

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

单链表中的节点应该具备两个属性：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); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3

提示：

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

---

AC:

/*
 * @lc app=leetcode.cn id=707 lang=cpp
 *
 * [707] 设计链表
 */

/**
 * 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);
 */
// @lc code=start
class MyLinkedList {
public:
    struct LinkNode {
        int val;
        LinkNode* next;
        LinkNode(int val):val(val), next(nullptr){}
    };

    MyLinkedList() {
        _dummyHead = new LinkNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index > (_size - 1) || (index < 0)) {
            return -1;
        }
        LinkNode* cur = _dummyHead->next;
        while(index--) {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkNode* newNode = new LinkNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkNode* newNode = new LinkNode(val);
        LinkNode* cur = _dummyHead;
        while(cur->next) {
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size)
            return ;
        if(index < 0)
            index = 0;
        LinkNode* newNode = new LinkNode(val);
        LinkNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index >= _size || index < 0)
            return ;
        LinkNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        LinkNode* tmp = cur->next;
        cur->next = cur->next->next;
        tmp = nullptr;
        delete(tmp);
        _size--;
    }
private:
    int _size;
    LinkNode* _dummyHead;
};
// @lc code=end

---

需要注意的是，链表初始化时出现的c++11 构造函数与成员初始化器列表语法
C++11引入了新的成员初始化器列表语法，可以更方便地初始化成员变量。使用该语法的构造函数的函数体之前，必须有一个成员初始化器列表，用冒号（:）分隔。初始化器列表的语法如下：

class MyClass {
public:
    // 无参构造函数
    MyClass() : member1(initialValue1), member2(initialValue2), ... {
        // 构造函数体
    }

    // 有参构造函数
    MyClass(int arg1, double arg2, ...) : member1(arg1), member2(arg2), ... {
        // 构造函数体
    }

private:
    // 成员变量
    int member1;
    double member2;
    ...
};

其中，initialValue1、initialValue2等为成员变量的初始值，arg1、arg2等为构造函数的参数。在成员初始化器列表中，每一个成员变量的初始化语句使用逗号分隔，每个语句由成员变量名称和初始化表达式组成（也可以使用成员函数返回值进行初始化）。对于没有在初始化器列表中出现的成员变量，它们会使用它们的默认构造函数进行初始化。

使用成员初始化器列表可以减少代码行数和内存分配次数，提高程序的效率和可读性。

---

假设有一个类 Person，包含了名字(name)、年龄(age)、职业(job)等成员变量，我们可以使用成员初始化器列表来初始化这些成员变量：

class Person {
public:
    // 有参构造函数
    Person(string _name, int _age, string _job) 
        : name(_name), age(_age), job(_job)
    {
        // 构造函数体
    }

private:
    string name;
    int age;
    string job;
};

在上面的代码中，我们使用了成员初始化器列表来初始化 name、age 和job 这三个成员变量，代码更加简洁高效。

如果不使用成员初始化器列表，代码如下：

class Person {
public:
    // 有参构造函数
    Person(string _name, int _age, string _job) {
        name = _name;
        age = _age;
        job = _job;
        // 构造函数体
    }

private:
    string name;
    int age;
    string job;
};

这样的代码虽然跟使用成员初始化器列表的代码基本相同，但是在代码实际执行的时候，由于需要对成员变量进行多次赋值，所以效率会低一些。因此，在实际开发中推荐使用成员初始化器列表。