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

链表的构造：

link.h:

#ifndef LINK_H
#define LINK_H
#include<vector>

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

};
#endif

实现链表：

#include<iostream>
#include"Link.h"
using namespace std;

ListNode* Solution::removeElements(ListNode* head, int val)
{}

实现移除元素：

难点：

　　1，因为给的head是不是空节点的head，一定要注意这一点

　　2，需要自己定义一个空的头节点

　　3，需要设置一个游标

　　4，返回的时候，返回空节点的时候->用num

ListNode* Solution::removeElements(ListNode* head, int val)
{
    ListNode* DyHead = new ListNode();
    //注意 cur_ == head 
    DyHead->next = head;
    auto cur_ = DyHead;

    while (cur_->next != nullptr)
    {
        if (cur_->next->val == val)
        {
            ListNode* mid = cur_->next;
            cur_->next = mid->next;
        }
        // 不是的话，就下一个
        else 
        {
            cur_ = cur_->next;
        }
    
    }

    //不是原数组的head 而是 dyhead->next
    return DyHead->next;
}

 

设计列表 ，仍然出现访问空指针的问题，需要查看

class MyLinkedList {
public:
struct LinkNode
    {
        int val;
        LinkNode* next;
        LinkNode(int v) : val(v), next(nullptr) {};
    };
    MyLinkedList() {
    head = new LinkNode(0);
    head->next = nullptr;

    }
    
    int get(int index) {
auto cur_ = head;

    int idx = 0;
    while (cur_->next != nullptr)
    {
        if (idx == index)
        {
            return cur_->next->val;
        }
        else
        {
            cur_ = cur_->next;
        }

        idx++;
    }

    return -1;
    }
    
    void addAtHead(int val) {
    auto* cur = head->next;
    LinkNode* mid = new LinkNode(val);
    head->next = mid;
    mid->next = cur;
    }
    
    void addAtTail(int val) {
    LinkNode* mid = new LinkNode(val);
    auto* cur = head;
    while (cur->next != nullptr)
    {
        cur = cur->next;
    }

    cur->next = mid;
    }
    
    void addAtIndex(int index, int val) {
int length = 0, idx = 0;
    LinkNode* cur = head;
    LinkNode* newNode = new LinkNode(val);

    // 一定要把循环写进去，因为while(index--)，最后一层，会把index -- 多一步
    while (index > 0)
    {
        if (cur->next != nullptr)
        {
            cur = cur->next;
        }
        else
        {
            break;
        }
        index = index - 1;
    }

    if (index == 0 && cur->next != nullptr)
    {
        LinkNode* mid = cur->next;
        cur->next = newNode;
        newNode->next = mid;
    }
    else if (index == 0 && cur->next == nullptr)
    {
        cur->next = newNode;
    }
    }
    
    void deleteAtIndex(int index) {
LinkNode* cur = head;
    while (index >0)
    {
        if (cur->next != nullptr)
        {
            cur = cur->next;
        }
        else
        {
            break;
        }
        index = index - 1;
    }

    if (index == 0)
    {
        cur->next = cur->next->next;
    }
    }
    private:
    LinkNode* head;
};

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

 

反转列表：

ListNode* MyLinkedList::reverseList(ListNode* head) {
    ListNode* dyHead = new ListNode();
    dyHead->next = head;
    auto* cur = dyHead;
    
    ListNode* result = new ListNode();
    while (cur->next !=nullptr)
    {
        ListNode* currentNode = new ListNode(cur->next->val);
        auto mid = result->next;
        result->next = currentNode;
        currentNode->next = mid;

        cur = cur->next;
    }

    return result->next;
}