Day3|链表

女娲补天之Day3

203 移除链表元素

很简单就直接上代码了，加一个虚拟头节点会很方便

/**
 * 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) {
        if(head==nullptr) return head;
        ListNode* preHead=new ListNode();
        preHead->next=head;
        ListNode* prev=preHead;
        ListNode* curr=head;
        while(curr!=nullptr){
            ListNode* p=curr->next;
            if(curr->val==val){
                prev->next=p;
                curr=p;
            }
            else{
                prev=curr;
                curr=p;
            }
        }
        return preHead->next;
    }
};

707设计链表

上代码

struct abListNode {
    int val;
    abListNode* next;
    abListNode() : val(0), next(nullptr) {}
    abListNode(int a) : val(a), next(nullptr) {}
}; 
class MyLinkedList {
public:
    int len;
    abListNode* preHead;
    MyLinkedList() {
        preHead=new abListNode();
        len = 0;
    }

    int get(int index) {
        if (index + 1 > len || index<0)
            return -1;
        abListNode* p = preHead->next;
        for (int i = 0; i < index; ++i) {
            p = p->next;
        }
        return p->val;
    }

    void addAtHead(int val) {
        ++len;
        abListNode* p = new abListNode(val);
        p->next = preHead->next;
        preHead->next = p;
        //head=preHead->next;
    }

    void addAtTail(int val) {
        ++len;
        abListNode* p = new abListNode(val);
        abListNode* curr=preHead;
        while(curr->next !=nullptr){
            curr=curr->next;
        }
        curr->next=p;
    }

    void addAtIndex(int index, int val) {
        if(index<0) return;
        else if (index == len)
            addAtTail(val);
        else if (index > len)//这里 判断条件
            return;
        else {
            len++;
            abListNode* p = preHead->next;
            abListNode* prev=preHead;
            for (int i = 0; i < index; ++i) {
                prev=prev->next;
                p = p->next;
            }
            abListNode* add=new abListNode(val);
            add->next=p;
            prev->next=add;
        }
        //head=preHead->next;
    }

    void deleteAtIndex(int index) {
        if(get(index)==-1) return;
        len--;
        abListNode* p = preHead->next;
        abListNode* prev=preHead;
        for (int i = 0; i < index; ++i) {
            prev=prev->next;
            p = p->next;
        }
        abListNode* after=p->next;
        prev->next=after;
        delete p;
    }
};

/**
 * 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);
 */

整体思路没啥问题，一开始加了prev后来发现没有太大作用，就把双向链表改成单向链表了。
不通过是因为else if (index > len)判断条件，
一开始写的是index+1 >=len。

206 反转链表

其实是很简单的一道题。。但是我经常忘记要从head开始反转，head的next指针应该指向nullptr
但我很习惯每次直接把prev赋head，把curr赋head->next
提交上去报错才能想起来
每次都忘每次都忘。。。写这个题也不是第一次了。。。
只要有几天稍微不练习就会马上生疏。。。真的好痛苦

/**
 * 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* p=head;
        ListNode*prev=nullptr;
        while(p!=nullptr){
            ListNode*next=p->next;
            p->next=prev;
            prev=p;
            p=next;
        }
        return prev;
    }
};