算法题目-链表

已于 2024-03-11 12:05:05 修改
阅读量113 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 算法 链表 数据结构
于 2023-08-15 19:10:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51240148/article/details/132296452
版权

文章目录

Leetcode 206. 反转链表

在这里插入图片描述
思路：从链表中依次取节点—>>头插入新链表，为了避免元素丢失，需要记录原链表没插入节点
优点：重用节点，不需要创建另外节点对象，节省空间

public ListNode reverseList(ListNode o1) {
    if (o1 == null || o1.next == null) {
        return o1;
    }
    ListNode n1 = null;
    while (o1 != null) {
        ListNode o2 = o1.next;
        o1.next = n1;
        n1 = o1;
        o1 = o2;
    }
    return n1;
}

根据值删除节点-力扣 203 题

在这里插入图片描述
思路：加哨兵，要删除得记录前一个节点，用其next指向跳过当前要删除得节点

/**
 * 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 s = new ListNode(-1, head);
        ListNode pre = s;
        ListNode now = s.next;
        while(now != null){
            if(now.val == val){
                //删除，now后移
                pre.next = now.next;
                now = now.next;
            }else{
                //pre、now都后移
                pre = pre.next;
                now = now.next;
            }
        }
        return s.next;

    }
}

删除倒数节点-力扣 19 题

在这里插入图片描述
思路：要删除倒数第n个节点，就要知道倒数第n个节点的前一个节点，再将其next跳过删除节点
定义p1指向待删除节点前一个节点，p2为相对p1的后n+1个节点，p2为null时表示此时遍历链表结束，此时p1为待删除节点的前一个节点

/**
 * 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) {
       //快慢指针法，p1指向待删除前一个节点，p2相对p1多走n+1步
       ListNode s = new ListNode(-1, head);
       ListNode p1 = s;
       ListNode p2 = s;
       for(int i=0; i<n+1; i++){
           p2 = p2.next;
       }
       while(p2 != null){
           p1 = p1.next;
           p2 = p2.next;
       }
       p1.next = p1.next.next;
       return s.next;
}

    
}

有序链表去重-力扣 83 题

题目数据保证链表已经按升序 排列

在这里插入图片描述
在这里插入图片描述

思路：链表升序有序，定义p1指向head，p2指向head后一个，比较p1与p2，一样则p1的next跳过p2，不一样则都向后平移

/**
 * 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 deleteDuplicates(ListNode head) {
        // ListNode s = new ListNode(-101, head);
        // ListNode p1 = s;
        // ListNode p2 = p1.next;
        // while(p2 != null){
        //     if(p1.val == p2.val){
        //         p1.next = p2.next;
        //         p2 = p2.next;
        //     }else{
        //         p1 = p1.next;
        //         p2 = p2.next;
        //     }
        // }
        // return s.next;

        
        // 链表节点 < 2
        if (head == null || head.next == null) {
            return head;
        }
        // 链表节点 >= 2
        ListNode p1 = head;
        ListNode p2;
        while ((p2 = p1.next) != null) {
            if (p1.val == p2.val) {
                p1.next = p2.next;
            } else {
                p1 = p1.next;
            }
        }
        return head;

    }
}

删除链表重复元素-力扣 82 题

在这里插入图片描述
思路：定义三节点p1、p2、p3，p1指向待删除节点的前一个节点，p2和p3用于寻找重复元素边界，p2指向重复元素开始，p3指向最后一个重复元素的下一个位置，则用p1.next指向p3即可删除全部重复元素

/**
 * 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 deleteDuplicates(ListNode head) {
        if(head==null || head.next==null){
            return head;
        }
        ListNode s = new ListNode(-1,head);
        ListNode p1 = s;
        ListNode p2, p3;
        while((p2 = p1.next) != null && (p3 = p2.next) != null){
            if(p2.val == p3.val){
                while((p3 = p3.next) !=null && p3.val == p2.val){}
                //找到了不重复的值
                p1.next = p3;
            }else{
                p1 = p1.next;
                // p2 = p2.next;
                // p3 = p3.next;
            }


        }
        return s.next;

    }
}

合并有序链表-力扣 21 题

在这里插入图片描述
思路：依次比较两个链表的值，谁小则吧谁加入新链表，当两个链表有一个为空时，因为链表有序，直接将不为空的加入新链表即可

/**
 * 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 mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode s = new ListNode(-1,null);
        ListNode p = s;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                p.next = list1;
                p = p.next;
                list1 = list1.next;
            }else{
                p.next = list2;
                p = p.next;
                list2 = list2.next;
            }
        }
        if(list1 != null){
            p.next = list1;
        }
        if(list2 != null){
            p.next = list2;
        }
        return s.next;

    }
}

合并多个有序链表-力扣 23 题

在这里插入图片描述

思路：递归方式:想二叉树，多个链表，在最底层，我们将其变为两个链表，再合并两个链表，递归解决多个链表的合并（不太准确：类比左右中的遍历，左右都为单个链表，中操作为对这两个链表合并，）。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

/**
 * 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 mergeKLists(ListNode[] lists) {
    if (lists.length == 0) {
        return null;
    }
    return split(lists, 0, lists.length - 1);
}
	//返回合并后的链表，i，j代表左右边界
    public ListNode split(ListNode[] lists, int i, int j) {
        if (j == i) {
            return lists[i];
        }
        int m = (i + j) >>> 1;
        ListNode left = split(lists, i, m);
        ListNode right= split(lists, m+1, j);
        return mergeTwoLists(left, right);
    }
    public ListNode mergeTwoLists(ListNode p1, ListNode p2) {
        ListNode s = new ListNode(-1, null);
        ListNode p = s;
        while (p1 != null && p2 != null) {
            if (p1.val < p2.val) {
                p.next = p1;
                p1 = p1.next;
            } else {
                p.next = p2;
                p2 = p2.next;
            }
            p = p.next;
        }
        if (p1 != null) {
            p.next = p1;
        }
        if (p2 != null) {
            p.next = p2;
        }
        return s.next;
    }
}

查找链表中间节点-力扣 876 题

在这里插入图片描述
思路：使用快慢指针法，考虑链表个数是单数还是偶数的情况，如下图：
在这里插入图片描述

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;
        while(p2 != null && p2.next != null){
            p1 = p1.next;
            p2 = p2.next.next;
        }
        return p1;

    }
}

判断回文链表-力扣 234 题

用 O(n) 时间复杂度和 O(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 boolean isPalindrome(ListNode head) {

        ListNode middle = middle(head);
        ListNode reverse = reverse(middle);

        while(reverse != null){
            //只要有一个不等，则返回假
            if(reverse.val != head.val){
                return false;
            }
            reverse = reverse.next;
            head = head.next;
        }
        return true;
       
    }


    //找中间节点并返回中间节点，快慢指针法
    private ListNode middle(ListNode head){
        ListNode p1 =head;//慢指针，一次一步
        ListNode p2 = head;//快指针，一次两步
        while(p2 != null && p2.next != null){
            p1 = p1.next;
            p2 = p2.next.next;
        }
        return p1;
    }

    //反转链表 本题不用考虑链表为空的情况，题目中链表节点做了规定
    private ListNode reverse(ListNode o1){
        ListNode n1 = null;
        while(o1 != null){
            ListNode o2 = o1.next;
            o1.next = n1;
            n1 = o1;
            o1 = o2;
        }
        return n1;
    }
}

上面算法运行时间大leetcode上拿不上高分，对其改进：将反转操作与找中间位置操作同步进行，反转的是前半部分，当找到中间位置时也反转了前半部分，用反转的前半部分与后半部分比较（后半部分的开始就是此时的中间位置即慢指针此时所指的位置。但注意原链表基数和偶数对结果的影响：
在这里插入图片描述
当原链表为奇数时，让p1（中间节点的后一个位置）与n1节点中的值逐一比较。

/**
 * 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; }
 * }
 */
 //思路：找到原链表的中间位置，将此位置以后的链表（即原链表的后半段）反转，
//  再将反转后的链表和原链表元素逐一比较，当比较到有不相等元素时表示不是回文链表，
//  比较完都一样表示是回文链表。但要注意基数偶数情况
//1->2->3->4->5  基数  此时p2不为null
//12  345
//1->2->3->4->5->6  偶数
//123   456
class Solution {
    public boolean isPalindrome(ListNode head) {

        ListNode p1 = head;//慢指针
        ListNode p2 = head;//快指针
        ListNode n1 = null;//新头
        ListNode o1 = head;//旧头
        //实现反转前半部分链表与找中间位置
        while(p2 != null && p2.next != null){

            p1 = p1.next;
            p2 = p2.next.next;

            ListNode o2 = o1.next;
            o1.next = n1;
            n1 = o1;
            o1 = o2;

        }
        //判断原链表是基数还是偶数
        if(p2 != null){//奇数节点
            p1 = p1.next;
        }
        while(n1 != null){
            if(n1.val != p1.val){
                return false;
            }
            n1 =n1.next;
            p1 = p1.next;
        }
        return true;
    }         
    
}

龟兔赛跑算法

在这里插入图片描述
如果链表上存在环，那么在环上以不同速度前进的两个指针必定会在某个时刻相遇。算法分为两个阶段：

阶段1

  • 龟一次走一步，兔子一次走两步
  • 当兔子能走到终点时，不存在环
  • 当兔子能追上龟时，可以判断存在环

阶段2

  • 从它们第一次相遇开始，龟回到起点，兔子保持原位不变
  • 龟和兔子一次都走一步
  • 当再次相遇时，地点就是环的入口

为什么呢？
当它们第一次相遇时，直线上兔子都比龟快，所以相遇只能在环中，它们都走了直线距离，而兔子走的是龟的两倍，兔=2龟---->兔-龟=龟---->直线+n圈+k（相遇点距离入口距离）-（直线+m圈+k）=(n-m)圈，也是绕环的倍数，
入口：对于龟来说=直线+绕环倍数圈
此时相遇的位置就是绕环（n-m）圈，所以在此位置再走一个直线距离就是入口。

环形链表-力扣 141 题

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next !=null){

            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                return true;
            }

        }
        return false;
    }
}

环形链表检测入口-力扣 142 题

在这里插入图片描述
易错点：当我们在第二个阶段找入口时，将龟放入起点，此时若兔子也在起点时表示他们的第二此相遇，此时就是环的入口。

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

    //     ListNode fast = head;
    //     ListNode slow = head;
    //     while(fast != null && fast.next !=null){

    //         slow = slow.next;
    //         fast = fast.next.next;
    //         if(slow == fast){//进入第二阶段
    //             slow = head;
    //             while(true){
    //                 fast = fast.next;
    //                 slow = slow.next;
    //                 if(fast == slow){
    //                     return slow;
    //                 }              
    //             }
    //         }

    //     }
    //     return null;
        
    // }
    public ListNode detectCycle(ListNode head) {

        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next !=null){

            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){//进入第二阶段
                slow = head;
                while(true){
                    if(fast == slow){//当此时龟放到起点，而恰好兔子也在起点是说明
                                    //这是第二此相遇，直接返回入口即可（这种情况是没有直线只有环的
                                    //情况）
                        return slow;
                    }   
                    fast = fast.next;
                    slow = slow.next;           
                }
            }

        }
        return null;
        
    }
}

return 语句的作用域是整个函数，而不仅仅是内层循环。当执行 return 语句时，函数会立即结束，并返回指定的值。

ITfeib
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【算法-链表-python】相交链表
檀越的博客
07-09 1万+
的输入如下（你设计的程序。
链表经典算法题
Frank的博客
10-03 1644
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
【数据结构与算法】【腾讯阿里链表面试题】算法题--链表易懂版讲解
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
02-10 1561
腾讯面试题：复制随机节点 题目说明： 给定一个链表，每个节点包含一个指向任意节点的随机指针，同时每个节点有一个指向同一链表中节点的指针，输出这个链表的深拷贝。 阿里巴巴面试题：合并K个排序链表 题目说明： 给你一个链表数组，每个链表都已经按升序排列，请你将所有的链表合并到一个升序链表中，返回合并后的链表。
算法面试题-----链表完整刷题总结
爱喝舒化奶的博客
03-05 1364
关于面试中你一定要会的链表算法题！！ 再次注意，涉及到删除操作的时候，一定要考虑空表，删除在表头，在表中等操作。 1、O（1）时间删除链表节点 题目：给定一个链表和一个节点指针，在O（1）时间删除该节点。 方法：狸猫换太子，用后一个节点数据覆盖要删除的节点，然后删除下一个节点。 解答：leetcode 237. Delete Node in a Linked List（删除链表中的特定节点） 2、...
LeetCode初级算法--链表01：反转链表
小明的博客
10-21 1080
LeetCode初级算法--链表01：反转链表 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法、机器学习干货 csdn：https://blog.csdn.net/baidu_31657889/ csdn：https://blog.csdn.net/abcgkj/ github：https://github.com/aimi-cn/AILearners ...
算法--反转链表 II(Kotlin)
男儿不展风云志，空有天生八尺躯
04-29 1669
题目： 给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。 示例 1： 输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5] 示例 2： 输入：head = [5], left = 1, right = 1 输出：[5] 提示： 链表中节点数目为 n 1 <= n <= 500 -500 &l
算法笔记-链表
KeepThinking_的专栏
06-18 1195
链表结构如下： struct ListNode{ int m_nValue; ListNode * m_pNext; }; 1.输入一个链表，输出该链表中倒数第K个结点。 2.求链表的中间结点。如果链表中结点总数为奇数，返回中间结点，如果结点总数是偶数，返回中间两个结点的任意一个。 3.判断一个单向链表是否形成了环形结构。（如果是环形结构，则尾结点的下一个结点不一定是
【算法--链表】用Js解决环形链表问题（简单易懂）
Emily's Blog
11-02 894
用Js解决LeetCode 141.环形链表问题解题思路解题步骤代码演示 解题思路 两个人在圆形操场上的起点同时起跑，速度快的人一定会超过速度慢的人一圈 用一快一慢两个指针遍历链表，如果指针能够相逢，那么链表有圈 解题步骤 用一块一慢两个指针遍历链表，如果指针能够相逢，就返回true 遍历结束后，还没有相逢就返回false 代码演示 /** * Definition for singly-linked list. * function ListNode(val) { * this.va
面试算法 牛客题目 链表的奇偶重排
she666666的博客
10-03 948
题目： 链表的奇偶重排 描述 给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。 注意是节点的编号而非节点的数值。 数据范围：节点数量满足 0 < n< 10^5 5节点中的值都满足 0
力扣初级算法-17-链表-删除链表中的节点
nvluco的博客
11-19 652
学习目标： 本次学习目标为 力扣初级算法-链表，其中主要的LC如下： 删除链表中的节点 学习内容： 删除链表中的节点 -----（链接） 请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 。 示例1： 示例2： 输入：head = [4,5,1,9], node = 1 输出：[4,5,9] 解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
算法大全-面试题-链表-栈-二叉树-数据结构
11-22
算法大全-面试题-链表-栈-二叉树-数据结构，程序员找工作必备
数据结构实验-链表及栈的应用-天津理工大学
05-04
1、复习线性表（顺序表、链表）、栈（顺序存储、链式存储）、队列（顺序 存储、链式存储）的特点和基本操作；充分了解实验内容，进行问题分析，复习 相关知识并完成算法设计，初步完成程序设计，为实验作好充分的...
04-反转链表.md
03-31
大厂前端面试算法|# 数据结构和算法 数据结构和算法，是大厂前端...- 不仅关注题目本身，更要关注知识点和解题思路 - 按顺序学习（本章课程按顺序设计的） ## 看几个面试题 列举几个代表性的面试题，具体参考视频。
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 来源：力扣（LeetCode） 链接：...
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
最新发布
littlegengjie的博客
05-13 591
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 377
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 301
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
数据结构与算法题目集
09-02
数据结构与算法题目集是指一些包含了各种数据结构和算法相关问题的集合。通过解答这些问题，可以帮助学习者加深对数据结构和算法知识的理解和应用能力。这些题目集通常包括算法分析、链表操作、树的创建与遍历等内容...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值