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

已于 2024-01-15 01:10:42 修改
阅读量349 收藏 6
点赞数 8
文章标签： c++ python
于 2024-01-15 01:10:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56047026/article/details/135564163
版权

203.移除链表元素  

Python

直接删除节点：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        """直接删除"""
        while (head != None and head.val == val):#首先要移除头节点，确保头节点不为空，否则会报错,头节点的值==值
            head = head.next
        # 如果不是头节点，将头节点赋给指针，让指针去遍历移动
        cur = head
        while (cur != None and cur.next != None):
            if (cur.next.val == val):#注意是 值==值，not 指针
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head

 虚拟头节点：只用这一种即可

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        """虚拟头节点"""
        dummyhead = ListNode(next = head)#创建虚拟头节点
        cur = dummyhead
        while cur.next:#写成dummyhead.next报错 因为下文一直用的是cur指针，操作空指针会报错
            if cur.next.val == val:#注意，此处是.val
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyhead.next#要返回head，但是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) {
        //删除头节点
        while (head != NULL && head->val == val) {
            ListNode* tmp = head;//如果没有tmp，删除节点后head将指向一个已经被删除的节点
            head = head->next;
            delete tmp;
        }
        //删除非头节点
        ListNode* cur = head;
        while (cur != NULL && cur->next != NULL){
            if (cur->next->val == val){//注意是cur->next而不是cur
                ListNode* tmp = cur->next;//为什么要定义一个指针
                cur->next = cur->next->next;
                delete tmp;}
            else{
                cur = cur->next;} 
        }
        return head;
    }
};

虚拟头节点：

/**
 * 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.设计链表

力扣题目链接(opens new window)

题意：

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

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

 python3

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.dummy_head = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        """ 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。"""
        # 如果index无效，则返回1，判断在范围之外
        if index < 0 or index >= self.size:#[0,size-1]
            return -1
        
        #在范围内，定义指针
        current = self.dummy_head.next #要返回当前节点的值，cur直接放到head即可
        #遍历下标内所有
        for i in range(index):
            current = current.next
        
        return current.val

    def addAtHead(self, val: int) -> None:
        """将一个值为 val 的节点插入到链表中第一个元素之前。
        在插入完成后，新节点会成为链表的第一个节点。"""
        # 直接在dummy_head后面加一个dumm_head.next即可
        self.dummy_head.next = ListNode(val, self.dummy_head.next)#直接在虚你头后面接一个节点
        self.size += 1

    def addAtTail(self, val: int) -> None:
        """ 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。"""
        # 定义指针
        current = self.dummy_head
        while current.next:#遍历，当下一个节点不是NULL，一直向下走，直到最后一个
            current = current.next
        current.next = ListNode(val)
        self.size += 1      

    def addAtIndex(self, index: int, val: int) -> None:
        """将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
        如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。
        如果 index 比长度更大，该节点将 不会插入 到链表中。"""
        if index < 0 or index >= self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val,current.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        """如果下标有效，则删除链表中下标为 index 的节点。"""
        if index < 0 or index >= self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1 


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

 c++

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    //初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    //获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
    int get(int index) {
        if (index < 0 || index >(_size - 1)){
            return -1;
        }

        LinkedNode* cur = _dummyHead->next;//将指针指向要返回的head
        while (index){
            cur = cur->next;
            index--;
        }
        return cur->val;

    }
    //将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    void addAtHead(int val) {
        LinkedNode* newNode =new LinkedNode(val);
        newNode->next = _dummyHead->next;//!!!先将原本head的值赋给插入的节点，否则就找不见了
        _dummyHead->next = newNode;
        _size++;
    }
    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    void addAtTail(int val) {
        LinkedNode* newNode =new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    // 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
    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;
            index--;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    //如果下标有效，则删除链表中下标为 index 的节点。
    void deleteAtIndex(int index) {
        if (index < 0 || index >=_size){//??
            return;
        }
        LinkedNode* cur = _dummyHead;
        while (index){
            cur = cur->next;
            index--;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete 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;

};

/**
 * 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.反转链表 

力扣题目链接(opens new window)

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL+

 方法一：双指针法

pyhton3

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """双指针法"""
        cur = head
        pre = None
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre

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

方法二：递归法

python3

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """双指针基础上的递归法"""
        return self.reverse(head, None)

    def reverse(self, cur, pre):
        if cur == None:
            return pre
        tmp = cur.next
        cur.next = pre
        return self.reverse(tmp, cur)

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) {
        return reverse(NULL, head);
        }

    ListNode* reverse(ListNode* pre,ListNode* cur){
        if (cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        return reverse(cur, temp);
        }

};

2_33_
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
leetcod 203.移除链表元素：
08-24
题目描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。...解题思路有两种：（一）要移除...具体思路详解请看拿捏链表（一）---------移除链表元素
力扣203 返回head时报错，而dummyHead.next正确的原因
qq_45866899的博客
08-13 164
*
Leetcode_147_对链表进行插入排序_数据结构+插入排序
HDUCheater的博客
11-21 297
class Solution { public ListNode insertionSortList(ListNode head) { //防止调用head.next报错 if (head == null) { return head; } //相当于c++里的头指针 ListNode dummyHead = new ListNode(0); dummyHead.next = he
链表面试题 python
weixin_44181070的博客
08-29 450
找出两个链表的交点 p1 = headA p2 = headB while p1 != p2: p1 = p1.next if p1 else headB p2 = p2.next if p2 else headA return p1 链表反转 # Definition for singly-linked list. # class ListNode(object): # def.
代码随想录算法训练营第三天 | 203.移除链表元素 707.设计链表 206.反转链表
U_L_Yxan的博客
07-06 1883
链表的题目中重要的就是虚拟头结点边界条件处理（可以自己假设如果只有一个头结点的情况来判断自己的边界情况对不对），执行各种操作（交换，插入……）时temp的临保存，next的不同顺序调用。
代码随想录算法训练营第三天｜203.移除链表元素 707.设计链表 206.反转链表
qq_39981702的博客
07-19 994
链表是一种线性数据结构，其中元素不是在内存中连续存放的，而是通过节点之间的链接来组织。每个节点包含两部分：一部分是存储数据的区域，另一部分是一个指针，指向链表中的下一个节点。最后一个节点的指针通常为null，表示链表的结束。代码随想录203链表移除元素代码随想录707设计链表代码随想录206.反转链表。
代码随想录算法训练营第三天 |203.移除链表元素 707.设计链表 206.反转链表
weixin_64028235的博客
06-08 643
`:value(x),next(NULL)`: 这是初始化列表。在这里，`value` 被初始化为 `x`，而 `next` 被初始化为 `NULL`（表示该节点是链表的最后一个节点，或者它还没有指向任何下一个节点）。使用虚拟头节点统一删除规则，这个写法没有释放内存空间，下面是释放内存空间的写法,在删除时多设一个指针把需要删除的删了就行，记得删虚拟头节点。在这个例子中，它是空的，因为所有的初始化都已经在初始化列表中完成了。`int x`: 这是构造函数的参数，表示要初始化给新节点的值。
代码随想录算法训练营第三天| 203.移除链表元素 707.设计链表 206.反转链表
qq_40816326的博客
07-21 179
移除链表元素是我早期刷题接触到的题目，当时对链表这个数据结构不是很熟悉，很多方法都是硬背下来的。但是在回过头来看，现在的理解清晰了许多，将链表的索引与数组的索引进行类比理解，他们有相通之处也有不同的地方。这样对链表的处理就清晰了很多。所以还是要多练才行呀。移除链表元素，可以用虚节点作为头结点，这样就避免了第一个元素移除时，要重新创建头结点的过程。反转链表是很容易出错的一个题，也是我实习面试的时候遇到过的题目，所以印象十分深刻。注释里面是递归法，思路是一样的。
代码随想录算法训练营第三天 | 203. 移除链表元素 707. 设计链表 206. 反转链表
m0_73857425的博客
06-07 309
为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL。然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。题意：删除链表中等于给定值 val 的所有节点。
[力扣] 203.移除链表元素
12-23
移除链表元素" 是一个典型的链表操作问题，主要涉及链表节点的删除操作。题目要求从链表中删除所有值等于给定值 `val` 的节点。 链表删除操作通常分为两种情况：删除头节点和删除非头节点。在处理这个问题时，我们...
xiaoxfan#leetcode#203. 移除链表元素1
07-25
示例:输出: 1->2->3->4->5方法一递归func removeElements(head *ListNode, val int) *ListNode
bestlyg#bestlyg-leetcode#203.移除链表元素1
07-25
简介：删除链表中等于给定值val的所有节点。编辑时间：2020.2.13执行用时：1ms内存消耗：40.1MB编程语言：java解法介绍：创建新链表，遍历节点，
代码随想录算法训练营第3天 | 203. 移除链表元素 707.设计链表 206.反转链表
Chloe0123的博客
05-24 255
203. 移除链表元素。
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 705
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 487
c++ error: ‘*’ does not name a type； did you mean ‘**’?
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
本文是关于LeetCode中三道与链表相关的算法题目的刷题笔记，包括203.移除链表元素、707.设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值