Day 3 203.移除链表元素 707.设计链表 206.反转链表

链表理论基础

链表由一系列在内存中不相连的结构组成，每个结构均含有表元素和指向包含该元素后继的指针。

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

循环链表：链表首尾相连。

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
}

203.移除链表元素  

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 

在链表的头节点删除是一种特殊情况，其改变了链表的头节点，同时在链表删除时是通过操作被删节点的前一节点来移除节点，对于头节点不存在前一个节点。

因此可以添加一个虚拟头节点来统一删除操作。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0);//虚拟头节点
        dummyHead ->next = head;
        ListNode* cur = dummyHead; //通过操作前一节点来删除当前节点，所以指向 dummyhead 而非
                                   // dummyHead->next
        while(cur->next!=NULL){
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }else
                cur = cur->next;
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

707.设计链表

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

class MyLinkedList {

public:
struct LinkedNode { //定义节点
    int val;
    LinkedNode* next;
    LinkedNode(int val):val(val),next(nullptr){}
};
    MyLinkedList() { //初始化
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index > (_size-1) || index <0)
            return -1;
        LinkedNode* cur = _dummyHead->next;
        while(index--){
            cur = cur ->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newHead = new LinkedNode(val);
        newHead->next = _dummyHead ->next;
        _dummyHead->next = newHead;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* newHead = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next!=nullptr){
            cur = cur->next;
        }
        cur->next = newHead;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > _size || index < 0) {
            return;
        }
        LinkedNode* newHead = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        newHead->next = cur->next;
        cur->next = newHead;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--; 
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

 206.反转链表 

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp = NULL;
        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};