第3天-代码随想录刷题训练|● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

1. 203移除链表元素

原题链接

给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。

  • 注意点
    • 如果头结点就是要删除的元素,应该怎么写
    • 注意使用 ListNode和ListNode * 遍历的区别
/**
 * 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 *vir = new ListNode(0);
        vir->next = head;
        ListNode *temp = vir;

        while(temp->next != nullptr){
            if(temp->next->val == val){
                // 这里要记得删除等于val的节点
                ListNode *temNode = temp->next;
                temp->next = temp->next->next;
                delete temNode;  
            }else{
            // 如果不相等这个指针后移动, 这里如果不使用指针的话,不好操作  tem是ListNode, 而next是 *ListNode
                temp = temp->next;   
            }
        }
        return vir->next;
    }
};

2.设计链表

原题链接

class MyLinkedList {
public:

    // 1. ListNode的构造函数后面不加;
    // 2. struct完后需呀加;
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr){}
    };

    MyLinkedList() {
        virNode = new LinkedNode(0);
        _size = 0;
    }
    
int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = virNode->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    
    void addAtHead(int val) {
        // new ListNode只能赋值给指针
        LinkedNode* newHead = new LinkedNode(val);
        // ListNode* newHead(val);          // 这么做会报错
        newHead->next = virNode->next;
        virNode->next = newHead;
        _size++;
    }


    void addAtTail(int val) {
        // ListNode* newTail(val);
        LinkedNode* newTail = new LinkedNode(val);
        LinkedNode* tempNode = virNode;
        while(tempNode->next != nullptr){
            tempNode = tempNode->next;
        }
        tempNode->next = newTail;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        // 注意这里是下标为index的节点之前, 这里节点下标从0开始
        if(index > _size){
            return ;
        }
        if(index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* curNode = virNode;
        while(index--){
            curNode = curNode->next;
        }
        newNode->next = curNode->next;
        curNode->next = newNode;
        _size++;
    }

    void deleteAtIndex(int index) {
        // if(index >= _size-1 || index < 0){    
        if(index >= _size || index < 0){    // 这里应该是 >= size
            return;
        }
        LinkedNode* curNode = virNode;
        while(index--){
            curNode = curNode->next;
        }
        LinkedNode* temNode = curNode->next;
        curNode->next = curNode->next->next;
        delete temNode;
        _size--;        
    }
private:
    int _size;
    LinkedNode* virNode;
};

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

3.翻转链表

原题链接

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

  • 非递归写法
    • 注意这里开始操作的节点是虚拟头结点和头结点,方便翻转后判断是否到结尾
    ListNode* reverseList(ListNode* head) {
        // 非递归法
        ListNode *tem;    // 暂存下一个节点
        ListNode *first = nullptr;
        ListNode *second = head;
        while(second){
            tem = second->next;
            second->next = first;

            first = second;
            second = tem;
        }

        return first;
    }
  • 递归写法
    • 这里的递归要注意如何返回新的头结点
class Solution {
public:
    ListNode* reverse(ListNode* per, ListNode* cur){
        if(cur == nullptr){
            return per;
        }
        ListNode *tem = cur->next;
        cur->next = per;
        return reverse(cur, tem);
    }

    ListNode* reverseList(ListNode* head) {
        if(head == nullptr){
            return head;
        }
        ListNode* virHead = nullptr;
        ListNode* newHead = reverse(virHead, head);

        return newHead;
    }
};
  • 需要让head->next 每次都指向空,否则最后一个节点会和倒数第二个节点互相指,无限循环输出
  • 再考虑为什么reverList要卸载 head的操作之前
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode *last = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;       // 如果不指向空,最后一个节点会和倒数第二个节点互相指
        return last;
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值