代码随想录算法训练营第3-4天|203,707,206,24,19,142,0207|链表-CSDN博客

本文链接：https://blog.csdn.net/qq_56162645/article/details/130662259

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *p=head;
        ListNode *prev=NULL;
        while(p!=NULL){
            if(p->val == val){
                if(p==head){
                    head=head->next;
                }else{
                    prev->next=p->next;
                }
            }else{
                prev=p;
            }
            p=p->next;
        }
        return head;
    }
};

LC 707

设计链表

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) {
        //判断范围！！
        cout<<_size;
        if(index<0 || index>=_size){
            return -1;
        }
        LinkedNode * tmp = _dummyHead->next;
        int i = 0;
        while(tmp!=nullptr){
            if(index==i){
                return tmp->val;
            }
            i++;
            tmp=tmp->next;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        LinkedNode * tmp = _dummyHead->next;
        _dummyHead->next = new LinkedNode(val);
        _dummyHead->next->next = tmp;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode * tmp = _dummyHead;
        while(tmp->next!=nullptr){
            tmp = tmp->next;
        }
        tmp->next=new LinkedNode(val);
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<0 || index>_size){
            return;
        }else if(index==0){
            return addAtHead(val);
        }else if(index==_size){
            return addAtTail(val);
        }
        LinkedNode * tmp = _dummyHead->next;
        int i = 0;
        while(tmp!=nullptr){
            if(index-1==i){
                LinkedNode *t = tmp->next;
                tmp->next = new LinkedNode(val);
                tmp->next->next = t;
                _size++;
                break;
            }
            i++;
            tmp=tmp->next;
        }
        return;
    }
    
    void deleteAtIndex(int index) {
        if(index<0 || index>=_size){
            return;
        }
        LinkedNode * tmp = _dummyHead;
        int i = -1;
        while(tmp!=nullptr){
            if(i==index-1){
                // cout<<"d"<<i<<" "<<tmp->val<<endl;
                if(tmp->next!=nullptr&&tmp->next->next!=nullptr)
                    tmp->next=tmp->next->next;
                else
                    tmp->next=nullptr;
                _size--;
                break;
            }
            i++;
            tmp = tmp->next;
        }
        return;
    }
private:
    int _size;
    LinkedNode* _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);
 */

LC 206 反转链表

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

LC 24 两两交换链表中的节点

/**
 * 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* swapPairs(ListNode* head) {
        ListNode *dum = new ListNode(0);
        ListNode *tmp;
        ListNode *tmpp;
        dum->next=head;
        if(head==nullptr || head->next==nullptr) return head;
        head = dum;
        while(dum!=nullptr){
            if(dum->next!=nullptr&&dum->next->next!=nullptr){
                tmp = dum->next;
                tmpp = dum->next->next->next;
                dum->next->next->next=tmp;
                dum->next=dum->next->next;
                tmp->next=tmpp;
                dum = dum->next->next;
            }else{
                break;
            }  
        }
        return head->next;
    }
};

LC 19 删除链表的倒数第 N 个结点

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode *s= new ListNode(0);
        s->next=head;
        ListNode *dum= s;
        ListNode *f=head;
        int i=0;
        bool before_head = true;
        while(f!=nullptr){
            if(i>=n){
                s=s->next;
                before_head=false;
            }
            f=f->next;
            i++;
        }
        if(s->next!=nullptr)
            s->next=s->next->next;
        else
            s->next=nullptr;
        return dum->next;
    }
};

面试题 02.07. 链表相交

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 长度差
        int i=0,j=0;
        ListNode *tmp = headA;
        while(tmp!=nullptr&&++i){
            tmp = tmp->next;
        }
        tmp = headB;
        while(tmp!=nullptr&&++j){
            tmp=tmp->next;
        }
        i = i-j;
        while(i>0){
            headA=headA->next;
            i--;
        }
        while(i<0){
            headB=headB->next;
            i++;
        }
        while(headA!=nullptr&&headB!=nullptr){
            if(headA==headB){
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
        }
        return NULL;
    }
};

LC 142 环形链表 II

相遇点和head到环起始点距离相等

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *f=head;
        ListNode *s=head;
        while(f!=nullptr&&f->next!=nullptr){
            f = f->next->next;
            s = s->next;
            if(f==s){
                while(s!=head){
                    s=s->next;
                    head=head->next;
                }
                return s;
            }
        }
        return nullptr;
    }
};