LeetCode链表相关解法

最新推荐文章于 2024-07-21 15:36:00 发布
最新推荐文章于 2024-07-21 15:36:00 发布
阅读量253 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QiuYuSy/article/details/128796309
版权

LeetCode链表相关解法

LeetCode一般提供的链表节点结构如下

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

1.移除链表元素

203. 移除链表元素

不设置头节点

需要先进行删除,保证第一位不是目标元素

然后再进行后面的遍历

/**
 * 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) {
        //处理第一位,注意是while
        while(head != null && head.val == val){
            head = head.next;
        }

        if(head == null){
            return head;
        }

        ListNode pre = head;
        ListNode current = head.next;

        while(current != null){
            if(current.val == val){
                current = current.next;
                pre.next = current;
            }else{
                current = current.next;
                pre = pre.next;
            }
        }

        return head;
    }
}
设置虚拟头节点

设置一个虚拟头节点,方便操作

/**
 * 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) {
        if(head == null){
            return head;
        }
         //添加一个虚拟头节点
        ListNode VirtualHead = new ListNode(-1, head);
        ListNode pred = VirtualHead;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == val){
                cur = cur.next;
                pred.next = cur;
            }else{
                cur = cur.next;
                pred = pred.next;
            }
        }
        return VirtualHead.next;
    }
}

2.设计链表

707. 设计链表

先找前驱节点

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

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(-1);
    }
    
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index > size-1) {
            return -1;
        }
        int curIndex = 0;
        ListNode cur = head.next;
        while(cur != null){
            if(curIndex == index){
                return cur.val;
            }
            cur = cur.next;
            curIndex++;
        }
        return -1;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if(index >= size-1){
            return;
        }
        if (index < 0) {
            index = 0;
        }
        //找到要插入节点的前驱
        ListNode pre = head;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next = newNode;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index > size-1) {
            return;
        }
        if (index == 0) {
            head = head.next;
	        return;
        }
        ListNode pre = head;
        for (int i = 0; i < index ; i++) {
            pre = pre.next;
        }
        pre.next = pre.next.next;
        size--;
    }
}

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

206. 反转链表

思路

利用双指针,将所有的节点的next进行反转

img

注意点

  • 开始的时候pre为null
  • 结束条件为cur == null
  • 当前节点的next已经被修改了,cur如何到下一个节点? 使用temp临时指针
代码
/**
 * 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 reverseList(ListNode head) {
        ListNode pred = null;
        ListNode cur = head;

        while(cur != null){
            ListNode temp = cur.next;
            cur.next = pred;
            pred = cur;
            cur = temp;
        }

        return pred;
    }
}

4.两两交换链表节点

24. 两两交换链表中的节点

模拟题,A->B->C->D顺序如下

  1. 后一个节点B的指针指向前一个节点A
  2. A指向B的下一个节点C
  3. 之前的节点连接到B

注意点如下:

  • 开始时进行判断.如果节点个数小于2直接返回
  • 初始化时,pred和cur都为head,在进入循环后cur再为pred.next,避免空指针
  • 结束条件为剩下的节点不足两个
  • B节点指向A后,不知道C在哪了,所以需要一个临时指针temp指向C
  • B节点到了链表头部后,需要一个连接指针link来把头节点来指向B
/**
 * 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 swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }

        ListNode virtualHead = new ListNode(-1, head);
        ListNode pred = head;
        ListNode cur = head;
        ListNode link = virtualHead; //记录之前连接到哪个节点了
        while(pred != null && pred.next != null){
            //在这里才真正赋值,因为pred!=null可用保证不会空指针
            cur = pred.next;
            
            //更改连线
            ListNode temp = cur.next;
            cur.next = pred;
            pred.next = temp;
            link.next = cur;

            //移动
            link = pred;
            pred = pred.next;
            
        }
        return virtualHead.next;

    }
}

5.删除链表的倒数第N个节点

19. 删除链表的倒数第 N 个结点

思路

删除一个节点需要知道这个节点的上一个节点

我们可用定义两个快慢指针

  1. 快指针先走N步

image-20230130035254274

  1. 然后快慢指针一起走,直到快指针的下一个为null

image-20230130035346055

  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; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode virtualHead = new ListNode(-1, head);
        ListNode fast = virtualHead;
        ListNode slow = virtualHead;
        for(int i = 0; i < n; i++){
            fast = fast.next;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }

        //删除节点
        slow.next = slow.next.next;
 
        return virtualHead.next;
    }
}

6.链表相交

面试题 02.07. 链表相交

双指针法

思路

  1. 先各自获得链表的长度A B

  2. 假如A长,A链表从A-B的地方开始和B一起遍历

  3. 依次比较指针是否相等

计算一下两个链表的长度，让长链表先走，等两个链表长度一样的时候再一起走，结点相等直接返回，没有相交返回null

面试题02.07.链表相交_2 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0, lenB = 0;
        ListNode curA = headA;
        ListNode curB = headB;

        //获取长度
        while(curA != null){
            lenA++;
            curA = curA.next;
        }
        while(curB != null){
            lenB++;
            curB = curB.next;
        }

        //让长的为headA,短的为headB
        if(lenA < lenB){
            int temp = lenA;
            lenA = lenB;
            lenB = temp;
            ListNode tempNode = headA;
            headA = headB;
            headB = tempNode;
        }

        curA = headA;
        curB = headB;
        int gap = lenA - lenB;
        //长的走到和短的相同的地方
        for(int i = 0; i < gap; i++){
            curA = curA.next;
        }

        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }

        return null;
    }
}

哈希法

先把其中一个链表的节点都放入HashSet,然后放入另一个链表的节点,如果有包含的话,就说明是同个节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        HashSet set = new HashSet();
        ListNode curA = headA;
        ListNode curB = headB;

        while(curA != null){
            set.add(curA);
            curA = curA.next;
        }

        while(curB != null){
            if(set.contains(curB)){
                return curB;
            }
            curB = curB.next;
        }

        return null;
    }
}

7.环形链表II

142. 环形链表 II

哈希法

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        HashSet set = new HashSet();
        ListNode cur = head;


        while(cur != null){
            if(set.contains(cur)){
                return cur;
            }
            set.add(cur);
            cur = cur.next;
        }

        return null;
    }
}

双指针法

https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html#_142-%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8ii

QiuYuSy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode链表题解技巧归纳总结
小白码上飞
06-21 417
总结一下链表题型的解题技巧，以及对应题目的解题思路
LeetCode链表反转解法理解
hxq133233的博客
09-04 3393
一、题目 反转一个单链表如输入: 1->2->3->4->5->NULL；输出: 5->4->3->2->1->NULL 二、解析 1.最简单的解法是遍历链表，将元素的next的指针指向前一个元素。思路有了，接下来就是写代码了但是由于是个单向列表所以其实是拿不到前一个元素的，这个时候就需要有个变量来保存前一个元素。另外还得有个变量...
LeetCode链表（链表操作，反转链表，奇偶链表，排序链表）
ji_meng的博客
03-06 966
本篇文章更注重于链表自身的特点。链表是一种通过指针串联在一起的线性结构。链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。链表的入口节点称为链表的头结点也就是head。（1）单链表每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。（2）双链表每一个节点有两个指针域。
Leetcode链表总结
wonner_的博客
04-07 1978
    由于最近开始面临保研找实习，所以打算刷波leetcode，之前一直想做这件事，巩固一下自己的基础，但总是被各种事情耽搁，由此写下这篇博客作为督促。在这期间偶然间看到同学的博客，他也打算刷leetcode，但刚做了一题就拿到了滴滴的offer，而且那一题跟我做的第一道题一样，让人感叹的巧合。希望我也能像他一样得到满意的结果。    本篇文章不会包含代码的讲解，只是做题目的一点思路心得，相关答...
Leetcode学习之链表
hello_fengfeng的博客
02-18 538
Leetcode学习之链表链表链表定义链表的逻辑结构与存储结构单链表的定义链表插入元素带头结点插入尾插法特性链表节点插入删除双链表双链表的插入双链表的删除总结顺序表（列表和数组）与链表比较按元素查找按下标查找在某元素插入删除某元素特点练习移除链表元素旋转链表合并两个有序链表相交链表删除排序链表中的重复元素 链表 链表定义 链表是由一系列节点组成的元素集合，每个节点包括两部分，数据域**item和指向下一个节点的指针next**。通过节点之间的互相连接，最终串联成一个链表 head ----> 86|
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
leetcode反转链表问题
12-21
反转链表是编程面试中常见的一个问题，特别是在LeetCode等在线编程平台上经常出现。它主要考察的是对链表数据结构的理解以及算法实现能力。本篇将详细介绍如何解决LeetCode中的反转链表问题，包括两种主要的方法：...
【leetcode-链表】扁平化多级双向链表
01-20
本题是关于扁平化多级双向链表的问题，来自LeetCode。在多级双向链表中，每个节点除了拥有指向下一个节点（next）和前一个节点（prev）的指针，还有一个子链表指针（child），可以指向一个单独的双向链表。这种结构...
leetcode分类-LeetCode:这是刷leetcode的swift解法
06-30
leetcode ...这是刷leetcode的swift解法 包含这几类算法 基本的LeetCode题目（PS:未做分类 树相关的算法题 动态规划相关的算法题 十大排序算法 链表相关的算法题 数组相关的算法题 字符串相关的算法题
java-leetcode题解之第141题环形链表.zip
06-17
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第141题——环形链表。这道题目是数据结构和算法领域的一个经典问题，主要考察对链表的理解以及如何检测一个链表是否存在环。我们将深入探讨这个问题，并...
stack(leetcode练习题)
2301_81692739的博客
07-19 380
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 323
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 144
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 291
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 922
数组和字符串介绍以及相关例题
【LeetCode】80.删除有序数组中的重复项II
最新发布
说文科技，做有态度的研究。
07-21 95
思路很好想到，但是实现起来不是那么容易。
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 8177
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
LeetCode 150, 112, 130
qq_61350148的博客
07-21 654
讲解了栈、二叉树、搜索相关的题目。
24暑假算法刷题 | Day15 | LeetCode 110. 平衡二叉树，257. 二叉树的所有路径，404. 左叶子之和，222. 完全二叉树的节点个数
weixin_54468359的博客
07-17 1167
day15打卡：二叉树的递归与迭代
LeetCode链表专题：高效反转策略与递归解法
"LeetCode算法数据结构专训笔记，涵盖了链表、栈、递归等常见数据结构和算法，旨在提升编程能力与解决问题的技巧。笔记详细解释了如何使用不同方法，如头插法和栈，来解决链表反转问题，并通过递归深入理解反转逻辑...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值