DAY 03 操作链表 反转链表

链表相较于数组，它的元素个数可以随时改变，每一个节点（Node）都是独立分配的，是不连续的，因此它不需要大块连续内存，内存利用率高。

但是因为不连续，无法进行内存随机访问，只能从头节点开始逐节点遍历。

203. 移除链表元素 - 力扣（LeetCode）

 设置一个虚拟头节点.数据域为0.地址域为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(0,head);
        ListNode*cur=dummyHead;
        while(cur->next!=nullptr){
            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. 设计链表 - 力扣（LeetCode）

第一遍写的时候定义结构体 } 后面忘写 ； 会报这个错误： 

class MyLinkedList {
public:
    struct listNode{
        int val;
        listNode* next;
        listNode(int val):val(val),next(NULL){}
    };
    MyLinkedList() {
        dummyHead=new listNode(0);//设置虚拟节点
        size=0;//用来记录链表长度
    }
    
    int get(int index) {
     
        //索引值无意义
        if(index>size-1||index<0){
        return -1;
        }
        listNode* cur=dummyHead->next;
        //index不为0，判断为真
        while(index){
            index--;
            cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        listNode* newNode=new listNode(val);
        listNode* cur=dummyHead;
        newNode->next=cur->next;
        cur->next=newNode;
        size++;

    }
    
    void addAtTail(int val) {
        listNode* newNode=new listNode(val);
        listNode* cur=dummyHead;
        while(cur->next!=NULL){
            cur=cur->next;
        }
        cur->next=newNode;
        size++;
        
    }
    
    void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        if(index<0){
            index=0;
        }
        listNode* newNode=new listNode(val);
        listNode* cur=dummyHead;
        while(index){
            index--;
            cur=cur->next;
        }
        newNode->next=cur->next;
        cur->next=newNode;
        size++;    
    }
    void deleteAtIndex(int index) {
        if(index<0||index>size-1){
            return;
        }

        listNode* cur=dummyHead;
        while(index){
            index--;
            cur=cur->next;
        }
        listNode* tmp = cur->next;
        cur->next=cur->next->next;
        delete tmp;
        tmp=NULL;//被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。
        size--;
        
    }
     void printLinkedList() {
        listNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int size;
    listNode* dummyHead;
};

/**
 * 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. 反转链表 - 力扣（LeetCode）

上图引用 代码随想录

/**
 * 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* temp;
        ListNode* cur=head;
        ListNode* pre=nullptr;
        while(cur){
            temp=cur->next;
            cur->next=pre;
            
            pre=cur;
            cur=temp;

        }
        return pre;
    }
};

 做链表类题时勤动手画画图，逻辑更容易捋顺。