链表的相关题解

最新推荐文章于 2024-08-29 18:01:01 发布
最新推荐文章于 2024-08-29 18:01:01 发布
阅读量48 收藏
点赞数
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56280646/article/details/130395533
版权

链表的相关题解

文章目录

1.移除链表元素

力扣：203. 移除链表元素 - 力扣（Leetcode）

思路

1.先找到这个值的节点，然后看这个节点在哪个位置

2.如果在头结点则头结点后移

3.不在头结点则定义一个辅助指针，遍历链表

4.找到要移除节点的前一位，然后让前一个节点的next指向下一个的下一个节点

代码实现

package com.algo.linkedlist;

public class Algo203 {
    public ListNode removeElements(ListNode head, int val) {
        //如果链表为空，直接返回
        if(head == null){
            return head;
        }
        while (head.val == val){
            if(head.next!=null){//如果头结点的值为要移除节点的值  则让头结点后移
                head = head.next;
            }else{
                return null;
            }
        }
        //定义一个辅助指针，遍历链表
        ListNode temp = head;
        while (temp.next!=null){
            if(temp.next.val==val){//找到要移除节点的前一位
                temp.next = temp.next.next;//让前一个节点的next指向下一个的下一个节点
                continue;//跳过本次循环
            }
            temp = temp.next;//指针后移
        }
        return head;
    }
}

2.设计链表

力扣：707. 设计链表 - 力扣（Leetcode）

思路

1.先写一个链表的构造器

2.get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

3.addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

4.addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

5.addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

6.deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

代码实现

package com.algo.linkedlist;

public class Algo707 {
    int size ;//存储链表元素个数
    ListNode head;//虚拟头结点
    //初始化链表。
    public Algo707() {
        size = 0;
        head = new ListNode(0);
    }

    //获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
    public int get(int index) {
        //如果index无意义，返回-1
        if(index<0||index>size){
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        int i =0;
        while (i<=index) {
            currentNode = currentNode.next;
            i++;
        }
        return currentNode.val;
    }

    //将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    //将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
    //如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。
    //如果 index 比长度更大，该节点将 不会插入 到链表中
    public void addAtIndex(int index, int val) {
        if (index>size) {
            return;
        }
        if(index<0){
           index = 0;
        }
        size++;
        ListNode pred = head;
        int i=0;
        while (i<index){
            i++;
            pred = pred.next;
        }
        ListNode valNode = new ListNode(val, null);
        valNode.next = pred.next;
        pred.next = valNode;
    }

    //如果下标有效，则删除链表中下标为 index 的节点。
    public void deleteAtIndex(int index) {
        if(index<0||index>=size){
            return;
        }
        size--;
        if(index == 0){
            head = head.next;
            return;
        }
        ListNode pred = head;
        int i =0;
        while (i<index){
            pred = pred.next;
            i++;
        }
        pred.next = pred.next.next;
    }
}

3.翻转链表

力扣：206. 反转链表 - 力扣（Leetcode）

思路(栈)

1.首先将所有的结点入栈

2.然后创建一个虚拟虚拟头结点，让cur指向虚拟头结点。

3.然后开始循环出栈

4.每出来一个元素，就把它加入到以虚拟头结点为头结点的链表当中，最后返回即可。

代码实现

package com.algo.linkedlist;

import java.util.Stack;

public class Algo206 {
    /**
     * 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; }
     * }
     */
    public ListNode reverseList(ListNode head) {
        /**
         * 首先将所有的结点入栈
         * 然后创建一个虚拟虚拟头结点，让cur指向虚拟头结点。然后开始循环出栈，
         * 每出来一个元素，就把它加入到以虚拟头结点为头结点的链表当中，最后返回即可。
         */
        if (head == null || head.next == null) {
            return head;
        }
        Stack<ListNode> stack = new Stack<>();
        ListNode cur = head;
        //将所有节点入栈
        while (cur!=null){
            stack.push(cur);
            cur = cur.next;
        }
        //定义一个虚拟头结点
        ListNode newhead = new ListNode(0,null);
        //指向虚拟头结点
        cur = newhead;
        //如果栈中还有元素   则一直出栈  出栈之后让辅助指针后移
        while (stack.size()!=0){
            cur.next = stack.pop();
            cur = cur.next;
        }
        //当到最后一个元素的时候，让最后一个元素指向null
        cur.next=null;
        return newhead.next;
    }


}

思路(双指针)

1.首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null

2.首先要把 cur.next 节点用temp指针保存一下

3.要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了

4.接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针

5.最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点

代码实现

package com.algo.linkedlist;

import java.util.Stack;

public class Algo206 {
    /**
     * 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; }
     * }
     */
    public ListNode reverseList(ListNode head) {
        /**
         * 双指针
         * 首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。
         *
         * 首先要把 cur.next 节点用temp指针保存一下。
         *
         * 要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。
         *
         * 接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。
         *
         * 最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点
         */
        ListNode prev = null;
        ListNode cur  = head;
        ListNode temp = null;
        while (cur!=null){
            temp  = cur.next;
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }


}

思路(虚拟头节点)

1.定义一个虚拟头结点

2.定义一个辅助指针，遍历原始数组

3.定义一个节点，指向当前节点的下一个位置

4.先保存辅助指针指向的下一个节点

5.再让辅助指针的next指向虚拟头结点的下一个

6.再让虚拟头结点的next指向辅助指针

7.让辅助指针指向刚才保存的节点

代码实现

package com.algo.linkedlist;

import java.util.Stack;

public class Algo206 {
    /**
     * 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; }
     * }
     */
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        //定义一个辅助指针，遍历原始链表
        ListNode cur = head;
        ListNode next = null;//定义一个节点，指向当前节点的下一个位置
        ListNode newHead = new ListNode(0,null);//创建一个新的头节点
        while (cur!=null){
            next = cur.next;
            cur.next = newHead.next;
            newHead.next = cur;
            cur = next;
        }
        head = newHead.next;
        return head;
    }
}

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

力扣：24. 两两交换链表中的节点 - 力扣（Leetcode）

思路

1.定义一个虚拟头结点，虚拟头结点的next指向head

2.再定义两个指针，分别为左指针，右指针

3.再定义一个辅助指针temp，用来遍历链表

4.当temp的next和temp的next的next不为空时，就让两个左右指针交换元素

5.交换完后再让temp指向右节点下一个的节点

代码实现

package com.algo.linkedlist;

public class Algo24 {
    public ListNode swapPairs(ListNode head) {
        //双指针法
        //如果链表为空或者链表中只有一个元素    直接返回
        if(head==null||head.next==null){
            return head;
        }
        //定义一个虚拟头结点
        ListNode newHead =new ListNode(0,null);
        newHead.next = head;
        //定义两个辅助指针
        ListNode left;
        ListNode right;
        ListNode temp = newHead;
        while (temp.next!=null&&temp.next.next!=null){
            left = temp.next;
            right = temp.next.next;
            temp.next = right;
            left.next = right.next;
            right.next = left;
            temp = left;
        }
        return newHead.next;
        /*
        //递归    太深奥
        //如果链表为空或者链表中只有一个元素    直接返回
        if(head==null||head.next==null){
            return head;
        }
        // 获取当前节点的下一个节点
        ListNode next = head.next;
        // 进行递归
        ListNode newNode = swapPairs(next.next);
        // 这里进行交换
        next.next = head;
        head.next = newNode;

        return next;*/
    }
}

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

力扣：19. 删除链表的倒数第 N 个结点 - 力扣（Leetcode）

思路

1.先定义一个虚拟头结点，让虚拟头结点的next指向head

2.定义两个指针，分别为left和right，让right先移动n次

3.再让两个指针同时移动，当right移动到最后一位时，left所指就是要删除节点的前一个

4.让left.next==left.next.next

代码实现

package com.algo.linkedlist;

public class Algo19 {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //定义一个虚拟头结点
        ListNode newHead = new ListNode(0,null);
        newHead.next = head;
        //定义两个辅助指针
        ListNode left = newHead;
        ListNode right = newHead;
        //先让一个节点移动n次
        for (int i = 0; i < n; i++) {
            right = right.next;
        }
        //再让left和right同时移动，移动到right的下一个节点为空
        //总之right与left一直相差n个节点  当right指向尾结点时right指的就是要删除节点的前一个
        while (right.next!=null){
            left = left.next;
            right = right.next;
        }
        left.next = left.next.next;
        return newHead.next;
    }
}

6.链表相交

力扣:面试题 02.07. 链表相交 - 力扣（Leetcode）

思路

1.先分别遍历两个链表，统计两个链表分别有多少个元素

2.然后计算出元素多的链表比少的链表多多少个元素

3.让链表元素个数多的先移动元素个数之差次

4.让两个指针同时移动，当两个指针指向同一个节点，就说明找到相交的节点了

5.没有找到就返回null

代码实现

package com.algo.linkedlist;

public class Algo160 {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //第一步，分别遍历两个链表   分别统计出有多少个元素
        int countA = 0;
        int countB = 0;
        ListNode tag = null;//如果相交，则用此变量来保存相交的起始节点
        ListNode temp = headA;
        while (temp != null) {
            temp = temp.next;
            countA++;
        }
        //当跳出循环时就统计出了headA中的元素个数
        temp = headB;
        while (temp != null) {
            temp = temp.next;
            countB++;
        }
        //当跳出循环时就统计出了headB中的元素个数
        ListNode curA = headA;
        ListNode curB = headB;
        if (countA > countB) {//如果headA的元素多余headB的元素，则先将A中的辅助指针向右移动countA-countB次
            for (int i = 0; i < countA - countB; i++) {
                curA = curA.next;
            }
        }else {
            for (int i = 0; i < countB - countA; i++) {
                curB = curB.next;
            }
        }
        //移动后再同时移动两个辅助指针，当两个指针所指节点为同一节点时就表明找到了  否则没找到
        while (curA != null && curB != null) {
            if (curA == curB) {
                tag = curA;
                break;
            }
            //同时后移
            curA = curA.next;
            curB = curB.next;
        }
        //跳出循环后，如果tag==null,表明没找到
        if (tag == null) {
            return null;
        } else {
            return tag;
        }
    }
}

7.环形链表

力扣：142. 环形链表 II - 力扣（Leetcode）

思路

1.先判断是否有环，定义两个指针，先同时指向头结点

2.一个指针每次走两步，一个指针每次走一步，当他们指向同一个节点时就说明有环

3.否则就没有环，当有环时就需要分析环的头结点在哪儿

4.当两个节点指向同一个节点时，让快的节点再次指向头节点，然后让他们同时移动

5.当两个指针再次相遇的时候就是环的头结点，返回这个头节点

代码实现

package com.algo.linkedlist;

public class Algo160 {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //第一步，分别遍历两个链表   分别统计出有多少个元素
        int countA = 0;
        int countB = 0;
        ListNode tag = null;//如果相交，则用此变量来保存相交的起始节点
        ListNode temp = headA;
        while (temp != null) {
            temp = temp.next;
            countA++;
        }
        //当跳出循环时就统计出了headA中的元素个数
        temp = headB;
        while (temp != null) {
            temp = temp.next;
            countB++;
        }
        //当跳出循环时就统计出了headB中的元素个数
        ListNode curA = headA;
        ListNode curB = headB;
        if (countA > countB) {//如果headA的元素多余headB的元素，则先将A中的辅助指针向右移动countA-countB次
            for (int i = 0; i < countA - countB; i++) {
                curA = curA.next;
            }
        }else {
            for (int i = 0; i < countB - countA; i++) {
                curB = curB.next;
            }
        }
        //移动后再同时移动两个辅助指针，当两个指针所指节点为同一节点时就表明找到了  否则没找到
        while (curA != null && curB != null) {
            if (curA == curB) {
                tag = curA;
                break;
            }
            //同时后移
            curA = curA.next;
            curB = curB.next;
        }
        //跳出循环后，如果tag==null,表明没找到
        if (tag == null) {
            return null;
        } else {
            return tag;
        }
    }
}
Admin-fqw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表相关题目
破浪会有时的博客
08-05 161
这里会总结一点链表相关的题目来供自己复习 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1
【JavaScript】leetcode链表相关题解
m0_63300737的博客
10-26 2143
链表的官方定义：链表是一种物理存储单位上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。看到这里，相信你肯定一知半解。没关系，接下来我们将链表与我们熟悉的数组进行一个对比，就好理解多了！数组：使用一块连续的内存空间地址存放数据链表：使用不连续的内存地址存放数据在存储数据方面，链表相较数组更加自由，节省内存资源，更利于内存空间的利用率。数组：每个元素都有其对应的索引，可以直接通过索引访问值链表：链表没有索引，每个链表节点至少由两部分组成：值，指向下一个节点的指针。
链表相关题解总结
zjsru_Beginner的博客
01-20 698
链表的一些基础知识就不赘述了 自己总结了几个链表的几种题型 和基础方法 有些题型的相似方法就一概而过 都是自己总结 有意见希望多多指出 我好加以修改 合并两个有序数组 leetcode 21 1.双指针 引入一个结果结点 对其比较遍历插入 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* prehead=new ListNode(-1); ListNode* prev..
反转链表LeetCode题解
weixin_45295612的博客
05-11 406
反转链表 给你单链表的头节点 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 进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？ 解题思路： 首先定义一个cur指针，指向头结
python-leetcode面试题解之第61题旋转链表-题解.zip
03-19
在本压缩包中，我们关注的是Python编程语言与...熟练掌握这些技巧，不仅能够提升编程技能，还有助于在Python相关的求职面试中脱颖而出。在实际工作中，这种问题解决能力也会在处理复杂数据结构和算法挑战时大显身手。
python-leetcode面试题解之第160题相交链表-题解.zip
05-21
本题解将详细讨论LeetCode中的第160题——"相交链表"，并使用Python语言进行解答。此题目的解决方法对于理解和掌握链表操作具有很高的价值，特别是在面试中常被问及。 相交链表问题的描述是这样的：给定两个链表的...
python-leetcode面试题解之第143题重排链表-题解.zip
05-14
本题解将深入探讨Python在解决LeetCode第143题——“重排链表”（Reorder List）时所涉及的关键知识点。 "重排链表"这道题目要求我们给定一个单链表，按原顺序将其分为两部分，然后将这两部分交替连接，以实现链表...
python-leetcode面试题解之第148题排序链表-题解.zip
05-14
在这个题解中，你将学习如何处理链表操作，包括遍历、分割、递归以及合并操作。这些技能对于理解和解决涉及链表的其他复杂问题至关重要。同时，归并排序是基础排序算法之一，理解它的实现原理有助于你在面试中展示出...
python-leetcode面试题解之第86题分隔链表-题解.zip
04-23
在本压缩包中，我们关注的是Python编程语言与LeetCode面试题目相关的知识，特别是涉及到第86题——“分隔链表”。这是一道典型的链表处理问题，常见于技术面试，尤其是对于寻找具备优秀算法解决能力和数据结构理解的...
25版王道数据结构课后习题详细分析 第五章 树与二叉树 5.4 树、森林
2406_86301373的博客
08-26 628
解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：
数据结构之单向、双线链表
2301_78503818的博客
08-28 1254
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
【笔记】数据结构——8月27日
m0_52024881的博客
08-27 1272
考研用笔记
二叉搜索树：数据结构之美
wgr050505的博客
08-26 831
本文介绍了二叉搜索树的基本概念、主要操作以及一些高级主题。通过学习这些内容，您不仅能够理解二叉搜索树的工作原理，还能够掌握如何有效地使用它们来解决实际问题。此外，本文还探讨了自平衡二叉搜索树的概念，这是处理大规模数据集时的一个重要工具。
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 1029
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 1490
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 855
KMP算法：构造next[]表
初识数据结构
qixi_ao的博客
08-26 616
数据结构
十大排序算法
Hubery_sky的博客
08-29 1577
int t = u;if (u!i;if (!n) break;n --;down(1);return 0;
链表经典题解：剑指 Offer 中的返回倒数第k个节点与合并排序链表
在这个资源中，主要讨论了链表相关的一些经典LeetCode题目，包括《剑指 Offer》中的两道题目：返回倒数第k个节点和合并两个有序链表。以下是每个知识点的详细解析： 1. **返回倒数第k个节点（剑指 Offer 22）**: -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值