Leetcode移除链表元素203/设计链表707/反转链表206

已于 2024-08-25 01:32:44 修改
阅读量637 收藏 21
点赞数 32
文章标签： leetcode 链表 算法
于 2024-04-02 17:00:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43969379/article/details/137240320
版权

前言

链表理论知识点总结：

1、真实做题环境可能不会给出链表定义，这里强调一下写法：

 //Definition for singly-linked list.
  public class ListNode {
      int val;
      ListNode next;
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next;}
  }

2、List item

一、203题（移除链表元素）

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

题解1

题解1（mine）:用时打败100%，内存打败31.95%(・∀・(・∀・(・∀・*)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode node = head;
        //首先处理val在最开头的位置的情况
        while(node!=null&&node.val==val){
            node = node.next;
        }
        if(node==null){
            return null;
        }
        head=node;
        while(node.next!=null){
            //证明当前node非链表中最后一个元素
            if(node.next.val == val){
                //删除该节点
                node.next = node.next.next;
            }else{
                node = node.next;
            }
        }
        return head;
    }
}

算法思路：

  • 没啥思路，就是一个很基础的删除链表删除题。出错点在于while(node!=null&&node.val==val)要先判断node是否为null，才能用node.val。和数组要判断是否出界才能引用下标一样。
  • 要说有什么思考点，就这个吧：首先要处理1个到多个重复元素在最开头的情况。找到一个真正的head结点。

备注：mine解法也是一个正统的解法，解法2能让代码更加简洁，思想其实差不多😀

题解2（dummy head）

虚拟头节点解法

public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
    ListNode dummy = new ListNode(-1, head);
    ListNode pre = dummy;
    ListNode cur = head;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}

算法思想：
在head前添加一个虚拟头节点dummy head，从而统一链表操作（题解1中需要对头节点进行一个特殊处理）

二、707题（设计链表）

题目描述：题意：

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

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

我的辛勤劳动

这题我的评价是：纯折磨😩
以下只为记录我的辛苦劳作，不作为学习的备忘记录，太稀碎了。

class ListNode{
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    }
}
class MyLinkedList {
    int size;
    ListNode head;
    public MyLinkedList() {
    }
    public void printList() {
    	if(size==0) {
    		System.out.println("没有元素");
    		return;
    	}
    	ListNode cur = head;
    	while(cur.next!=null) {
    		System.out.print(cur.val+",");
    		cur=cur.next;
    	}
    	System.out.println(cur.val);
    }
    //获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
    public int get(int index) {
        int i = 0 ;
        ListNode node = head;
        if(index>=size) return -1;
        while(i<index){
            node = node.next;
            i++;
        }
        return node.val;
    }
    //将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    public void addAtHead(int val) {
    	ListNode node = new ListNode(val);
    	if(size==0) {
    		head = node;
    		size++;
    		return;
    	}
        node.next = head;
        head = node; 
        size++;
    }
    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    public void addAtTail(int val) {
        ListNode node = new ListNode(val);
        if(size==0) {
        	addAtHead(val);
        	return;
        }
        ListNode cur = head;
        while(cur.next!=null){
            cur=cur.next;
        }
        //cur当前指向链表中最后一个元素
        cur.next = node;
        size++;
    }
    //将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
    public void addAtIndex(int index, int val) {
        if(index==size){
            addAtTail(val);
            return;
        }
        if(index>size){
            return;
        }
        if(index==0){
            addAtHead(val);
            return;
        }
        ListNode node = new ListNode(val);
        ListNode cur=head;;       
        int i = 0;
        //找到index的prev节点
        while(i<index-1){
            cur=cur.next;
            i++;
        }
        //执行插入操作
        ListNode cur2 = cur.next;
        cur.next = node;
        node.next = cur2;
        size++;
    }
    //如果下标有效，则删除链表中下标为 index 的节点。
    public void deleteAtIndex(int index) {
        if(index>=size){
            return;
        }
        if(size==1) {
        	head = null;
        	size--;
        	return;
        }
        if(index==0){
            head=head.next;
            size--;
            return;
        }
        //中间元素的删除
        //找到位于index-1的元素
        ListNode cur = head;
        int i = 0;
        while(i<index-1){
            cur=cur.next;
            i++;
        }
        cur.next = cur.next.next;
        size--;
    }
}

我的评价是很crazy，执行时间10ms打败了27.75%的用户，消耗内存击败49.56%的用户，整一个稀碎。🆒不是这里size++忘了，就是调用另一个函数size++了两次，i++也能忘。特殊情况大概是：一个元素没有，有一个元素，多个元素，总是会漏掉处理某一种情况。我真的是一个个对着用例找出来的错误，一把心酸老泪。

题解

讲解
其实思路都差不多，主要是实现方式的差异

虽然想到了可以一个方法里使用另外一种方法，但没想到下面代码这种利用:

//在链表最前面插入一个节点，等价于在第0个元素前添加
public void addAtHead(int val) {
    addAtIndex(0, val);
}

//在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
public void addAtTail(int val) {
    addAtIndex(size, val);
}）

果然还是得先整体思考，而不是一上来就哐哐一顿写✍

补充：使用dummy head时，要在MyLinkedList类中加入成员变量ListNode head,用在构造器中直接初始化head = new ListNode(0);//初始化虚拟头节点。

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);//初始化虚拟头节点
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

思路说明：那三个Add都是一个套路，所以只用写一个AddIndex即可，其余的调用它。这么说来，就是写增删查函数。

三、206题（反转链表）

题目描述：
反转一个单链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

题解1（双指针）

mine

/**
 1. Definition for singly-linked list.
 2. public class ListNode {
 3.     int val;
 4.     ListNode next;
 5.     ListNode() {}
 6.     ListNode(int val) { this.val = val; }
 7.     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 8. }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //处理0-1个结点
        if(head==null||head.next==null){
            return head;
        }
        //2个结点以上
        //思路：
        ListNode left=head,right=head.next;
        head.next = null;//斩断循环
        ListNode tmp;
        while(right!=null){
            tmp = right.next;
            right.next = left;
            left = right;
            right = tmp;
        }
        return left;
    }
}

算法思路：

  1. 特殊情况：空链表或者只有1个元素，直接返回
  2. 两个以上：[left,right]指向相邻的两个元素，执行代码"right.next->left"，然后[left,right]往后移动。过程如下所示（如a->b->c->d）：
· L指向a，R指向b：R.next = L; //则变成a<-b... c->d
· L指向b，R指向c：R.next = L; //则变成a<-b<-c ... d
会发现一旦执行了R.next = L，原来的R.next元素和R元素之间会断开连接，
这样无法往右移动了，所以需要拿一个tmp来在反转之前记录下R.next。

易错点：

  • 斩断循环点：如A->B->C的反转，反转时要把A.next置空，不然会变成C->B->A->B
  • 三组一处理时，如"a->b->c"，要记录三个位置，a和b的位置毋庸置疑需要拿两个指针来记录，因为用于遍历的指针走到需要处理的b元素时，无法倒退回a，所以a要用一个指针记录。由于b.next=a，不再指向c了，所以要再拿一个变量tmp存储c，即b.next。

代码版本2

算法思路：①cur指针：当前要处理的节点。将指向下一个元素的指针next改为指向前一个元素。②pre指针：记录cur的前一个节点。③tmp指针：保存cur的next指针指向的元素（因为如果不记录，cur处理完之后就找不到下一个元素了）

重点：①初始化：cur=head,pre=null
②迭代：tmp=cur.next; cur.next = pre;pre = cur;
③循环退出条件：cur=null时，因为null节点无需处理。

更简洁的原因：在mine版本中pre=head,cur=head.next，所以要特殊处理head为空的情况。

// 双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}

题解2（递归）

参照双指针版本很容易更改
算法思路：①很明显是[pre,cur]在递归，所以函数是reverse(pre,cur)
②递归跳出条件：cur=null时
③递归体：每轮当前递归完成pre和cur所指元素之间的反转操作。下一轮递归需要完成[cur,cur.next]，所以是reverse(cur,cur.next)。这里又涉及之前所说的指针保存问题，所以在执行反转前要记录tmp = cur.next。故下一次递归为reverse(cur,tmp)。

// 递归 
class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
}

题解3（递归）

mine版本：2024/8/25重做
算法思路：1->2->3->4->5，可以把2->3->4->5看作一个整体，过程是：先把1的next置空，然后reverse(2->3->4->5)，再把2的next指向1。顺序不能颠倒，类似汉诺塔思想。

// 递归 
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head==null) return null;
        ListNode newhead=head;
        while(newhead.next!=null) newhead=newhead.next;
        reverse(head);
        return newhead;
    }

    public void reverse(ListNode head){
        ListNode node = head.next;
        if(node==null) return;
        head.next = null;
        reverse(node);
        node.next = head;
    }
}

归纳

  1. 前两题都比较快想到了解决方法，但实现起来出错很多。206思考了一会儿，找到迭代规律后，实现起来挺快的，没有太多出错点。
  2. 要点：①头节点、无节点等的特殊情况的处理 ②dummyhead的应用 ③循环结束条件格外要小心
暮色已近却难相逢
关注
Leetcode题解-链表相关-203.移除链表元素/707.设计链表/206.反转链表
Grace_juanjuan的博客
04-10 270
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。函数int get(int index) 获取链表中下标为 index 的节点的值，链表从哪里获得的？注意的是因为是单链表，所以通过当前结点不能找到前一个结点，所以遍历的时候找的是目标结点的前一个结点。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是想系统学习链表操作的人。 能学到什么:掌握链表虚拟头节点设置...
Leetcode 203移除链表元素 707 设计链表 206 反转链表 0317
qq_42264921的博客
03-17 486
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
LeetCode_Day3 | 反转链表/移除链表的元素/设计个链表
跟Bug死扛到底
05-15 610
设计链表是一道对链表这的综合题，对理解链表有很大帮助。另外，双指针思想真是万能啊！
代码随想录刷题day3|LeetCode203 移除链表元素、LeetCode707 设计链表、LeetCode206 反转链表
m0_73687551的博客
09-01 521
很久没写链表操作了（擦汗），顺便复习一下手搓创建、输出和删除链表结点的细节，比如避免访问被释放结点内存（heap-use-after-free on address）之类的错误。，cur负责从头到尾遍历结点，pre负责在cur后面保存cur遍历的前一个结点，temp负责保存cur未遍历到的下一个结点，确保指针在交换方向前前后结点均不丢失。用c++编程移除链表元素时，在修改结点next指针指向后，还需要手动delete移除的结点，防止内存占用过多。我的代码：（写的是单链表，有时间也写下双链表。
Day3:Leetcode203移除链表元素，Leetcode707设计链表，Leetcode206反转链表
QielinRan的博客
10-14 3567
Leetcode203移除链表元素，Leetcode707设计链表，Leetcode206反转链表
代码随想录Day03 | 链表基础1 LeetCode T203 移除链表元素 T707设计链表 T206 反转链表
qiuqiushuibx的博客
09-23 376
int val;在进行循环分析的时候,一定要设置好足够的节点先保存待会会消失的节点,可以给一定的极端的例子来验证代码的可行性,考虑好空指针的判断和结束条件即可.
代码随想录 Day3 | Leetcode203 移除链表元素、Leetcode707 设计链表、Leetcode206反转链表
qq_41502639的博客
01-03 490
未来的你一定会感谢现在学习的你
LeetCode Day3 链表: 203.移除链表元素、707.设计链表、206.反转链表
iuhnkjgyi的博客
04-21 621
5)
leetcode算法练习——203.移除链表元素/707.设计链表/206.反转链表
qq_45799504的博客
11-19 131
leetcode算法——数组：203.移除链表元素/707.设计链表/206.反转链表
Leetcode 移除链表元素.go
02-21
LeetCode 203的题目是“移除链表元素”，要求从一个链表中删除所有值等于给定值val的节点，并返回新链表的头节点。这个问题考验的是对链表数据结构的理解和操作能力，包括如何遍历链表、如何处理边界条件（如头节点...
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
java-leetcode题解之第203题移除链表元素.zip
06-05
本题解集中关注的是LeetCode的第203题，即“移除链表元素”。这道题目主要涉及到链表操作，是数据结构中的基础概念，对于理解和解决实际问题具有重要意义。 链表是一种线性数据结构，它的每个元素（节点）包含数据...
C语言-leetcode题解之第203题移除链表元素.zip
07-28
c语言 C语言_leetcode题解之第203题移除链表元素
【数据结构与算法 | 灵神题单 | 删除链表篇】力扣2487, 237
2301_80912559的博客
09-09 848
每个节点的值都是 1 ，所以没有需要移除的节点。需要移除的节点是 5 ，2 和 3。移除每个右侧有一个更大数值的节点。- 节点 13 在节点 5 右侧。- 节点 13 在节点 2 右侧。- 节点 8 在节点 3 右侧。给你一个链表的头节点。返回修改后链表的头节点。
LeetCode 2181.合并零之间的节点
weixin_50878507的博客
09-09 555
给你一个链表的头节点head，该链表包含由0分隔开的一连串整数。链表的和的节点都满足。对于每两个相邻的0，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有0移除，修改后的链表不应该含有任何0。返回修改后链表的头节点head。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 508
【代码】【JavaScript】LeetCode：707设计链表。
leetcode-647. 回文子串
曼巴的博客
09-12 396
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值