代码随想录算法训练营31期day3,力扣203+707+206

___Dream

已于 2024-01-24 22:15:41 修改

阅读量468

点赞数 9

分类专栏：提高coding能力文章标签：算法 leetcode

于 2024-01-23 23:32:26 首次发布

本文链接：https://blog.csdn.net/weixin_45962681/article/details/135795435

版权

提高coding能力专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文介绍了如何使用C++实现单链表操作，包括在MyLinkedList类中添加元素（头部、尾部和指定位置）、删除元素（指定位置）以及两种反转链表的方法：迭代和递归。

摘要由CSDN通过智能技术生成

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) {
        //因为头结点可能改变，所以这里使用虚拟头结点
        auto dummy=new ListNode(-1);
        dummy->next=head;
        for(auto p=dummy;p->next;) //必须是p->next,不然循环体内会出现无指针指向值
            if(p->next->val==val)
                p->next=p->next->next;
            else 
                p=p->next;
        return dummy->next;
    }
};

707

class MyLinkedList {
public:
    struct Node{
        int val;
        Node *next;
        //定义了一个名为 Node 的类,该类表示链表的节点。在构造函数中，使用了成员初始化列表来初始化类成员。
        Node(int _val):val(_val),next(NULL){}
    }*head;
    MyLinkedList() {
        head=NULL;
    }
    int get(int index) {
        if(index<0) return -1;
        auto p=head;
        for(int i=0;i<index&&p;i++) p=p->next;
        if(!p) return -1;
        return p->val;
    }
    void addAtHead(int val) {
        auto h=new Node(val);
        h->next=head;
        head=h;
    }
    void addAtTail(int val) {
        if(!head) head=new Node(val);
        else{
            auto p=head;
            while(p->next) p=p->next;
            auto t=new Node(val);
            p->next=t;
        }
    }
    void addAtIndex(int index, int val) {
        if(index<=0) addAtHead(val);
        else{
            int len=0;
            for(auto p=head;p;p=p->next) len++;
            if(index==len) addAtTail(val);
            else if(index<len){
                auto p=head;
                for(int i=0;i<index-1;i++) p=p->next;
                auto c=new Node(val);
                c->next=p->next;
                p->next=c;
            }
        }
    }
    void deleteAtIndex(int index) {
        int len=0;
        for(auto p=head;p;p=p->next) len++;
        if(index>=0&&index<len){
            if(!index) head=head->next;
            else{
                auto p=head;
                for(int i=0;i<index-1;i++) p=p->next;
                p->next=p->next->next;
            }
        }
    }
};

206
普通+递归做法

//把指针反向
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head) return NULL;
        auto a=head,b=a->next;
        while(b){
            auto c=b->next;//缓存next，因为会改变
            b->next=a;//指针反向
            a=b;
            b=c;//去下一个指针
        }
        head->next=NULL;
        return a;
    }
};

递归做法：
在这里插入图片描述
整体思路：先将head->next传入，新的参数head接收，这样逐层递进，最后一个节点进入操作部分，逐层向前递进，完成反转

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head||!head->next) return head;
        auto tail=reverseList(head->next);
        head->next->next=head;
        head->next=NULL;
        return tail;
    }
};