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

一. 203 移除链表元素

思路:需要一个临时指针来储存要删除结点释放内存。推荐使用虚拟头结点的方式。不然删除head要另外讨论。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
         ListNode* dummyHead = new ListNode();
         dummyHead-> next = head;
         ListNode* q = dummyHead;
         while(q->next!=NULL){
             if(q->next->val == val){
                 ListNode* temp = new ListNode();
                 temp = q->next;
                 q-> next = temp->next;
                 delete temp ;
             }else{
                q = q->next;
             }
         }
         head = dummyHead->next;//这一点很关键，如果head被删除就找不到head了
         delete dummyHead;
         return head;
    }
};

二.707 设计链表

推荐使用虚拟头结点这样就不要考虑其他情况

class MyLinkedList {
public:
   struct ListNode{
       int val;
       ListNode* next;
   };
   ListNode* dummyHead;
   int size;
    MyLinkedList() {
        size = 0;
        dummyHead = new ListNode();

    }
    
    int get(int index) {
        if((size -1) <index||  index < 0){
            return -1 ;
        }
        ListNode* p = dummyHead->next;
        
        while(index--){
            p=p->next;

        }
        return p->val;


    }
    
    void addAtHead(int val) {
       ListNode* head = new ListNode();
       head->val = val;
       head->next = dummyHead->next;
       dummyHead ->next = head; 
       size++;
    }
    
    void addAtTail(int val) {
     ListNode* tail = new ListNode();
     ListNode* p =new ListNode();
     p = dummyHead;
     while(p->next!=NULL){
         p = p->next;
     }
    tail ->val = val;
    p-> next = tail;
    tail -> next = NULL;
     size++;
     
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if(index<0){
            addAtHead(val);
        }
        ListNode* p = new ListNode();
       p = dummyHead;
        
        while(index--){
            p=p->next;

        }
        ListNode* q =new ListNode();
        q->val = val;
        q->next = p->next;
        p->next = q;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        ListNode* p = new ListNode();
        p = dummyHead;
        while(index--){
            p=p->next;

        }
        ListNode* q =new ListNode();
        q = p->next;
        p->next = p->next->next;
        
        delete q;
        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);
 */

三.206 反转链表

思路：需要三个指针，第一个指针指向要反转指针的前一个指针。如果是头结点就会指向NULL,第二个指针是指向反转的节点，第三个指针存储下一个反转节点的地址。然后依次反转即可

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* first = nullptr;
        ListNode* second = new ListNode();
        ListNode* temp = new ListNode();
        
        second = head;
        while(second!=nullptr){
            temp =second -> next;
            second-> next = first;
           first = second;
           second = temp;


        }
        head = first;
        return head;

        
    }
};