day03第二章链表（二刷）

weixin_48668772

于 2022-12-28 18:17:20 发布

阅读量63

点赞数

分类专栏：力扣刷题文章标签：链表数据结构 leetcode

本文链接：https://blog.csdn.net/weixin_48668772/article/details/128472346

版权

力扣刷题专栏收录该内容

39 篇文章 0 订阅

订阅专栏

今日任务

链表理论基础
203.移除链表元素
707.设计链表
206.反转链表

203.移除链表元素

题目链接：

https://leetcode.cn/problems/remove-linked-list-elements/description/

题目描述：

给你一个链表的头节点

head

和一个整数

val

，请你删除链表中所有满足

Node.val == val

的节点，并返回新的头节点。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

题解代码：

/**
 * 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* virtualHead = new ListNode(-1);
        virtualHead->next = head;

        ListNode* cur = virtualHead;
        
        while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* no = cur->next;
                cur->next = cur->next->next;
                delete no;
            }
            else{
                cur = cur->next;
            }
        }

        return virtualHead->next;

        ///一刷/
        /*
        //创建虚拟头结点，赋元素值为 -1
        ListNode* dummyHead = new ListNode(-1); 
        dummyHead->next = head; //虚拟头结点指向实际的头结点
        
        ListNode* cur = dummyHead;//表示当前指针的位置

        while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* temp = cur->next;//记录这个即将要被删除的结点
                cur->next = cur->next->next;//删除
                delete temp; //释放被删除结点的指针
            }
            else{
                cur = cur->next;
            }
        }

        //返回新的实际头结点
        return dummyHead->next;
        */
    }
};

707.设计链表

题目链接：

https://leetcode.cn/problems/design-linked-list/description/

题目描述：

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

题解代码：


///二刷
class MyLinkedList{
    public:
    //定义链表节点结构体
    struct ListNode{
        int val;
        ListNode* next;
        ListNode():val(0),next(nullptr){}//参数为空
        ListNode(int v):val(v),next(nullptr){}//一个参数
        ListNode(int v,ListNode* n):val(v),next(n){}//两个参数
    };
    int len;//链表长度 
    ListNode* virtualHead; //链表虚拟头结点

    public:
    MyLinkedList(){
        len = 0;
        virtualHead = new ListNode();
    }

    //获取链表中第index个节点的值
    int get(int index){
        if(index<0 || index>len-1){
            return  -1;
        }

        ListNode* head = virtualHead->next;
        while(index--){
            head = head->next;
        }

        return head->val;
    }

    //在链表的第一个元素之前添加一个值为val的节点
    void addAtHead(int val){
        if(val<0 || val>1000){ //给val值设定一个有限的范围
            return;//不在有效的范围内就直接结束掉
        }
        ListNode* temp = new ListNode(val);
        temp->next = virtualHead->next;
        virtualHead->next = temp;
        len++;
    }

    //在链表的结尾添加 一个新的节点
    void addAtTail(int val){
        if(val<0 || val>1000){
            return;
        }
        ListNode* temp = new ListNode(val);
        ListNode* cur = virtualHead;
        while(cur->next){
            cur = cur->next;
        }
        cur->next = temp;
        len++;
    }

    //在 链表 中的第Index个节点之前添加一个节点
    void addAtIndex(int index, int val){
        if(val<0 || val>1000 || index>len){
            return;
        }
        if(index <= 0){
            addAtHead(val);
        }
        else if(index == len){
            addAtTail(val);
        }
        else{
            ListNode* temp = new ListNode(val);
            ListNode* cur = virtualHead;
            while(index--){
                cur = cur->next;

            }
            temp->next = cur->next;
            cur->next = temp;
            len++;
        }
    }

    //删除链表中的第index个节点
    void deleteAtIndex(int index){
        if(index<0 || index>len-1){
            return;
        }
        ListNode* cur = virtualHead;
        ListNode* temp = nullptr;
        while(index--){
            cur = cur->next;
        }
        temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        len--;
    }

};


一刷
class MyLinkedList {
public:

    struct Listnode{//定义链表结点结构体
        int val;//结点的值val
        Listnode* next;//结点的指针域next,指向下一个结点
        //三个Listnode构造函数
        Listnode():val(0),next(nullptr){}//参数为空
        Listnode(int v):val(v),next(nullptr){}//一个参数
        Listnode(int v,Listnode* n):val(v),next(n){}//两个参数
    };
    int len;//链表长度
    Listnode* dummyhead;//链表虚拟头结点
public:
    MyLinkedList() {//MyLinkedList构造函数
        len=0;//链表长度初始化为0
        dummyhead=new Listnode();//创建链表虚拟头结点
    }
    
    int get(int index) {//获取链表中第index个节点的值
        if(index<0||index>len-1) return -1;//索引无效返回-1
        Listnode* head=dummyhead->next;//dummyhead是虚拟头结点,而dummyhead->next是头结点
        while(index--) head=head->next;//找到第index个链表结点
        return head->val;//返回第index个链表结点的值val
    }
    
    void addAtHead(int val) {//在链表的第一个元素之前添加一个值为val的节点
        if(val<0||val>1000) return;//val值无效，直接返回
        Listnode* n=new Listnode(val);//新建值为val的链表结点n
        n->next=dummyhead->next;//将新链表结点n插入头结点前,新结点的指针域next为头结点指针,即新结点n的next指针指向头结点
        dummyhead->next=n;//虚拟头结点指针域next为新结点指针n,即虚拟头结点的next指针指向新结点n
        len++;//链表长度加一
    }
    
    void addAtTail(int val) {//将值为val的节点追加到链表的最后一个元素
        if(val<0||val>1000) return;//val值无效，直接返回
        Listnode* n=new Listnode(val),*cur=dummyhead;//新建值为val的链表结点n和当前结点指针变量cur
        while(cur->next) cur=cur->next;//通过cur找到链表中最后一个结点
        cur->next=n;//将新结点n插入链表末尾,即最后一个结点的指针域为新结点指针n
        len++;//链表长度加一
    }
    
    void addAtIndex(int index, int val) {//在链表中的第index个节点之前添加值为val的节点
        if(val<0||val>1000||index>len) return;//val值或index值无效，直接返回
        if(index<=0) addAtHead(val);//index<=0时,在头部插入值为val的新结点
        else if(index==len) addAtTail(val);//index=len时,在尾部插入值为val的新结点
        else{
            Listnode* n=new Listnode(val),*cur=dummyhead;//新建值为val的链表结点n和当前结点指针变量cur
            while(index--) cur=cur->next;//找到第index-1个链表结点
            n->next=cur->next;//将新链表结点n插入第index个链表结点前,新结点的指针域next为第index个链表结点的指针域next,即新结点n的next指针指向第index个链表结点
            cur->next=n;//第index个链表结点的指针域next为新结点指针n,即第index个链表结点的next指针指向新结点n
            len++;//链表长度加一
        }
    }
    
    void deleteAtIndex(int index) {//删除链表中的第index个节点
        if(index<0||index>len-1) return;//index值无效，直接返回
        Listnode* cur=dummyhead,*t=nullptr;//当前结点指针变量cur和临时结点t
        while(index--) cur=cur->next;//找到第index-1个结点
        t=cur->next;//t保存要删除的第index个结点
        cur->next=t->next;//第index-1个结点的指针域next为第index个结点的指针域next,即删除第index个结点
        delete t;//释放第index个结点的空间
        len--;//链表长度减一
    }
};

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

206.反转链表

题目链接：

https://leetcode.cn/problems/reverse-linked-list/description/

题目描述：

给你单链表的头节点

head

，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
5000 <= Node.val <= 5000

题解代码：

/**
 * 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* cur = head;
        ListNode* newBack = NULL;
        ListNode* temp;

        while(cur){
            temp = cur->next;
            cur->next = newBack;
            newBack = cur;
            cur = temp;
        }

        return newBack;

        //一刷//
        /*
        //双指针吧
        ListNode* pre = NULL;
        ListNode* cur = head;

        while(cur != NULL){
            ListNode* tmp = cur->next;//提前保存cur后面那一个结点，以免丢失
            cur->next = pre; //改指针方向
            pre = cur;//pre后移
            cur = tmp;//cur后移 
        }

        return pre;
        */
    }
};