Design yourimplementation of the linked list. You can choose to use a singly or doubly linked list.
A node in a singlylinked list should have two attributes:valandnext.valis the value of the current node, andnextisapointer/reference to the next node.
If you want to use the doubly linked list,you will needone more attributeprev

to indicate the previous node in the linked list. Assume all nodes in the linked list are0-indexed.

Implement theMyLinkedListclass:

• MyLinkedList()InitializestheMyLinkedListobject.
• int get(int index)Get the value oftheindexthnode in the linked list. If the index is invalid, return-1.
• void addAtHead(int val)
  Add a node of valuevalbefore the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
• void addAtTail(int val)Append a node of valuevalas the last element of the linked list.
• void addAtIndex(int index, int val)Add a node of valuevalbefore theindexth
  node in the linked list.Ifindexequals the length of the linked list, the node will be appended to the end of the linked list. Ifindexis greater than the length, the nodewill not be inserted.
• void deleteAtIndex(int index)Deletetheindexthnode in the linked list, if the index is valid.

Example 1:

Input
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
Output
[null, null, null, null, 2, null, 3]

Explanation
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // linked list becomes 1->2->3
myLinkedList.get(1);              // return 2
myLinkedList.deleteAtIndex(1);    // now the linked list is 1->3
myLinkedList.get(1);              // return 3

Constraints:

• 0 <= index, val <= 1000
• Please do not use the built-in LinkedList library.
• At most2000calls will be made toget,addAtHead,addAtTail,addAtIndexanddeleteAtIndex.

練手題。注意細節：1. addAtTail的時候如果沒head直接call addAtHead 2. traverse到tail是 while(p&&p->next) break出去後p指向tail 3. add/deleteAtIndex都要特殊考慮index為0的情況，traverse的時候記得希望p停在指向index的previous，這樣p->next就剛好是要增/刪的那個位置 4. delete剛好delete tail的話也是特殊考慮，直接把next設成nullptr 實現：

class MyLinkedList {
public:
    struct ListNode{
        ListNode* next;
        int val;
        ListNode(int x) : val(x), next(nullptr) {}
    };
    
    ListNode* head;
    /** Initialize your data structure here. */
    MyLinkedList() {
        head = nullptr;
    }
    
    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    int get(int index) {
        if (index < 0)
            return -1;
        if (!head)
            return -1;
        ListNode* p = head;
        for (int i=0; i<index; i++){
            if (p->next)
                p = p->next;
            else
                return -1;
        }
        return p->val;
    }
    
    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
    void addAtHead(int val) {
        ListNode* newNode = new ListNode(val);
        newNode->next = head;
        head = newNode;
    }
    
    /** Append a node of value val to the last element of the linked list. */
    void addAtTail(int val) {
        if (!head){
            addAtHead(val);
            return;
        }
        ListNode* newNode = new ListNode(val);
        ListNode* p = head;
        while (p && p->next){
            p = p->next;
        }
        p->next = newNode;
    }
    
    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
    void addAtIndex(int index, int val) {
        if (index < 0) return;
        if (index == 0){
            addAtHead(val);
            return;
        }
        ListNode* newNode = new ListNode(val);
        ListNode* p = head;
        for (int i=0; i<index-1; i++){
            if (p->next) 
                p = p->next;
            else return;
        }
        ListNode* next = p->next;
        p->next = newNode;
        newNode->next = next;
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    void deleteAtIndex(int index) {
        if (index < 0) return;
        if (index == 0){
            head = head->next;
            return;
        }
        ListNode* p = head;
        for (int i=0; i<index-1; i++){
            if (p->next)
                p = p->next;
            else return;
        }
        if (p->next){
            ListNode* next = p->next->next;
            p->next = next;
        }
        else p->next = nullptr;
    }
};