代码随想录算法训练营第3天|203.移除链表元素 | 707.设计链表 | 206.反转链表

阿豪只会阿巴

已于 2024-07-19 18:16:14 修改

阅读量873

点赞数 9

分类专栏：账号重生之我再也不手贱上传涩图了文章标签：算法链表数据结构

于 2024-02-23 22:16:15 首次发布

本文链接：https://blog.csdn.net/2401_83080774/article/details/136264436

版权

账号重生之我再也不手贱上传涩图了专栏收录该内容

25 篇文章 0 订阅

订阅专栏

代码随想录算法训练营第2天|203.移除链表元素 | 707.设计链表 | 206.反转链表

203.移除链表元素

题目链接：https://leetcode.cn/problems/remove-linked-list-elements/description/
文章讲解：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html
视频讲解： https://www.bilibili.com/video/BV18B4y1s7R9/

C语言一刷：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 //虚头结点法
struct ListNode* removeElements(struct ListNode* head, int val) {
    typedef struct ListNode ListNode;//结构体再命名
    ListNode *dummyhead;//定义一个虚头
    dummyhead=(ListNode *)malloc(sizeof(ListNode));//初始化
    dummyhead -> next =head;//把虚头的位置确定
    ListNode *p = dummyhead;//定一个指针，这个指针可以来遍历整个链表
    //删除3个里面中间的那个，其余不变。
    while(p->next != NULL)
    {
        if(p->next->val == val)
        {
            ListNode *t=p->next;//找到释放的位置
            p->next=p->next->next;//***
        free(t);//释放内存
        }
        else 
        p=p->next;//***
    }
    head=dummyhead->next;//到最后一定要指明头不然不好运行
    free(dummyhead);//释放（实际上释放是可省的）
    return head;
    
}

C++二刷

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

        dummyhead->next=head;

        ListNode* cur=dummyhead;

        while(cur->next!=NULL)
        {
            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.设计链表

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

C语言一刷：

typedef struct MyLinkedList {
    int val;
    struct MyLinkedList* next;
}MyLinkedList;

/** Initialize your data structure here. */

MyLinkedList* myLinkedListCreate() {
    //这个题必须用虚拟头指针,参数都是一级指针,头节点确定后没法改指向了!!!
    MyLinkedList* head = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    head->next = NULL;
    return head;
}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList *cur = obj->next;
    for (int i = 0; cur != NULL; i++){
        if (i == index){
            return cur->val;
        }
        else{
            cur = cur->next;
        }
    }
    return -1;
}

/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList *nhead = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    nhead->val = val;
    nhead->next = obj->next;
    obj->next = nhead;

}

/** Append a node of value val to the last element of the linked list. */
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList *cur = obj;
    while(cur->next != NULL){
        cur = cur->next;
    }
    MyLinkedList *ntail = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    ntail->val = val;
    ntail->next = NULL;
    cur->next = ntail;
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index == 0){
        myLinkedListAddAtHead(obj, val);
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL; i++){
        if (i == index){
            MyLinkedList* newnode = (MyLinkedList *)malloc(sizeof (MyLinkedList));
            newnode->val = val;
            newnode->next = cur->next;
            cur->next = newnode;
            return;
        }
        else{
            cur = cur->next;
        }
    }
}

/** Delete the index-th node in the linked list, if the index is valid. */
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index == 0){
        MyLinkedList *tmp = obj->next;
        if (tmp != NULL){
            obj->next = tmp->next;
            free(tmp);     
        }
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL && cur->next != NULL; i++){
        if (i == index){
            MyLinkedList *tmp = cur->next;
            if (tmp != NULL) {
                cur->next = tmp->next;
                free(tmp);
            }
            return;
        }
        else{
            cur = cur->next;
        }
    }
    
}

void myLinkedListFree(MyLinkedList* obj) {
    while(obj != NULL){
        MyLinkedList *tmp = obj;
        obj = obj->next;
        free(tmp);
    }
}

/**
 * Your MyLinkedList struct will be instantiated and called as such:
 * MyLinkedList* obj = myLinkedListCreate();
 * int param_1 = myLinkedListGet(obj, index);
 
 * myLinkedListAddAtHead(obj, val);
 
 * myLinkedListAddAtTail(obj, val);
 
 * myLinkedListAddAtIndex(obj, index, val);
 
 * myLinkedListDeleteAtIndex(obj, index);
 
 * myLinkedListFree(obj);
*/

C++二刷：

 /*
class MyLinkedList {
public:
// 初始化链表
    struct Linknode
    {
        int val;
        Linknode* next;
        Linknode(int val):val(val),next(nullptr){}
    };

    MyLinkedList() {
       Linknode* dummyhead=new Linknode(0);
       size=0;

    }
// 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    
    int get(int index) {

        if(index>(size-1)||index<0)
        return -1;

        Linknode* cur=dummyhead->next;
        while(index--)// 如果--index 就会陷入死循环
        {
            cur=cur->next;
        }
        return cur->val;
    }
 // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点    
  void addAtHead(int val) {
        Linknode* newode=new Linknode(val);

        newode->next=dummyhead->next;
        dummyhead->next=newode;

        size++;

    }
// 在链表最后面添加一个节点    
    void addAtTail(int val) {
        Linknode* lastnode=new Linknode(val);

        Linknode* cur=dummyhead;

        while(cur->next!=nullptr)
        {
            cur=cur->next;
        }
        cur->next=lastnode;
        size++;
    }

// 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果index大于链表的长度，则返回空
// 如果index小于0，则在头部插入节点    
    void addAtIndex(int index, int val) {
        if(index>size) return;
        if(index<0) index=0;

        Linknode* newnode=new Linknode(val);
        Linknode* cur=dummyhead;

        while(index--)
        {
            cur=cur->next;
        }

        newnode->next=cur->next;
        cur->next=newnode;

        size++;

    }
//删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的    
    void deleteAtIndex(int index) {

        if(index>=size||index<0)
        return;

        Linknode* cur=dummyhead;

        while(index--)
        {
            cur=cur->next;
        }


        Linknode* tmp=cur->next;
        cur->next=cur->next->next;

        delete tmp;

        tmp=nullptr;

        size--;

    }

    private:

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

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

总结

206.反转链表

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

C语言一刷:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 //双指针法
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* p;
    struct ListNode* q=NULL;//在head 前先给NULL用来好反转（反后相当于一开始链表的NULL）
    while(head != NULL)
    {
        p=head->next;//保存原head后面的结点
        head->next=q;//反转指针方向

        q=head;//q前进一个结点到原先head的结点上面
        head=p;//head把保存自身的后面结点赋给自己,也前进一结点
    }
    return q;
}

C++二刷：

/**
 * 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=NULL;

        while(cur)
        {
            temp=cur->next;
            cur->next=pre;

            pre=cur;
            cur=temp;
            
        }
        return pre;

    }
};

总结

阿豪只会阿巴

关注

9
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第3天|203.移除链表元素 | 707.设计链表 | 206.反转链表

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html。文章讲解：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html。视频讲解： https://www.bilibili.com/video/BV18B4y1s7R9/
复制链接

扫一扫