链表面试题

已于 2023-11-13 19:27:10 修改
阅读量510 收藏 3
点赞数 16
分类专栏： 拿捏数据结构 文章标签： 算法
于 2023-11-13 16:38:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74312445/article/details/134374485
版权

目录

前言：

1. 删除链表中等于给定值 val 的所有节点。 

2. 反转一个单链表。 

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

4. 输入一个链表，输出该链表中倒数第k个结点。

5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。

7. 链表的回文结构。

8. 输入两个链表，找出它们的第一个公共结点。

前言：

在些数据结构算法题，画图分析无疑是一把利刃。

在脑海里数据结构中单链表的结构可以理解为下图

a8eb3dc320074db5a6f76c67c5ada565.png

1. 删除链表中等于给定值 val 的所有节点。 

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/remove-linked-list-elements/description/

题目描述：

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

测试样例：

20770b2a58d043a3aa7e883dbbcffecf.png

代码实现：

思路：

a1c6561bc0384af7a0fabd5300e13d0e.png


class Solution {
    public ListNode removeElements(ListNode head, int val) {
    // 头结点为空的情况
        if(head == null) {
            return null;
        } 
    // 定义一个结点遍历整条链表，头结点最后考虑
    // 定义一个前驱，方便删除操作
        ListNode cur = head.next;
        ListNode prev = head;
    //  遍历到cur为空，整条链表可以遍历完
        while(cur != null ) {
            if(cur.val==val) {
                prev.next = cur.next;
                cur = cur.next;
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        // 头结点和头结点后一个 都要删除的情况 到这一步都在这不存在（所以判断头结点放到最后），
        //  画图便知
        if(head.val==val) {
            head = head.next;   
    }
    return head;
}
}

2. 反转一个单链表。 

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/reverse-linked-list/description/

题目描述：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

测试样例：

71b4bdeb1d98474d8baa69cdd6cb9e66.png

5b669e46c086411684e4a855a87d6f41.png

代码实现：

思路：从第二个节点开始，头插法实现逆转

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null) {
            return null;
        }
        ListNode cur = head.next;
        
        head.next = null;
        while(cur!=null) {
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }    
        return head;

    }
}

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/middle-of-the-linked-list/description/

题目描述：

给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

测试样例：

d931ea2387a44868adb5b9343797bafa.png

思路：同样的路程下，fast的速度是slow的两倍，当fast到达终点时，slow到达中间

代码实现：

/**
 * 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 middleNode(ListNode head) {
    if(head==null) {
        return null;
    }
    ListNode slow = head;
    ListNode fast = head;
    while(fast!=null&&fast.next!=null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
    
    }
}

4. 输入一个链表，输出该链表中倒数第k个结点。

题目链接：

链表中倒数第k个结点_牛客题霸_牛客网输入一个链表，输出该链表中倒数第k个结点。。题目来自【牛客题霸】icon-default.png?t=N7T8https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

题目描述：

输入一个链表，输出该链表中倒数第k个结点。

测试样例：

d3fff35dc6074427905eaac3bc06f2dc.png

思路：1.让fast先走k-1步

           2.fast和slow同时走，因为fast先走了k-1步，所以fast和slow永远相差k步

           3.当fast到终点时，slow和fast相差k步，所以slow就为倒数第k个结点。

代码实现：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/

public class Solution {

    public ListNode FindKthToTail(ListNode head,int k) {
        //如果k是负数或者很大，为非法情况
        //   if(k<=0||k>size())
        //    但是这里size() 已经遍历了一次
        //    所以在for循环后面 判断  如果fast为空了 直接return
       if(k <=0 || head == null ) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        for(int i = 0;i < k-1; i++) {
            fast = fast.next;
            if(fast == null) {
                return null;
            }
        }
        while(fast.next!= null ){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/merge-two-sorted-lists/description/

题目描述：

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

思路：

d619d8004d084830a1e0eccdfb9df915.jpeg

代码实现：

/**
 * 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 newHead = new ListNode();
       ListNode tHead = newHead;
       ListNode head1 = list1;
       ListNode head2 = list2; 
       while(head1!=null&&head2!=null) {
           if(head1.val<head2.val) {
               tHead.next = head1;
               head1=head1.next;
           }else{
               tHead.next = head2;
               head2 = head2.next;
           }
           tHead = tHead.next;
       }
       if(head1!=null) {
           tHead.next = head1;
       }     
       if(head2!=null) {
           tHead.next = head2;
       }
       return newHead.next;
    }
}

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。

题目链接：

链表分割_牛客题霸_牛客网现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的。题目来自【牛客题霸】icon-default.png?t=N7T8https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

题目描述：

现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

思路：这里x取20

37171e9af8f742a48790b400c7005abb.png

通过遍历整条链表，将数据分为两组，一直是在20之前的，一组在之后的

f712b6ca78244976bd7336ba23d2173b.png

特殊情况：

4693963157e54034951ac6deca06143c.png

代码实现：

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;

        ListNode cur = pHead;

        while(cur!=null) {
            if(cur.val<x) {
                //第一次插入
                if(bs==null) {
                    bs = be = cur;
                }else{
                    be.next = cur;
                    be = be.next;
                }
            }else{
                //第一次插入
                if(as==null) {
                    as = ae =cur;
                }else{
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        //前面一段没有数据的情况
        if(bs==null) {
            return as;
        }
        be.next = as;
        // 原链表最后一个数字不是最大的情况，容易造成死循环
           if(ae!=null) {
            ae.next = null;
        }
     
        return bs;
        
    }
}

7. 链表的回文结构。

题目链接：

链表的回文结构_牛客题霸_牛客网对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为。题目来自【牛客题霸】icon-default.png?t=N7T8https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId=49&&tqId=29370&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

题目描述：

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。

给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

测试样例：

0c9a7245ea4e4cfaa669bac6f3ceb6c1.png

思路：

为上面第三题和第五题的组合

1.找到链表的中间节点

2.翻转中间节点以后的链表

3.从前  从后 同时往前遍历 判断是否回文

4d2b9d9499b04097b726e1bf552fbfeb.png

代码实现：

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        ListNode slow = A;
        ListNode fast = A;
        //找到中间节点
        while(fast!=null&&fast.next!=null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        //逆转后半段节点
        
        ListNode cur = slow.next;
        while(cur!=null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //同时向中间靠拢
        ListNode Ahead = A;
        while(A!=slow) {
            if(A.val!=slow.val) {
                return false;
            }
            if(A.next == slow) {
                return true;
            }
            A = A.next;
            slow = slow.next;
        }
        return true;
    }
}

8. 输入两个链表，找出它们的第一个公共结点。

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/intersection-of-two-linked-lists/description/

题目描述：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

测试样例：

9f8c52ec7ce3426eae09158bd1fb7357.png

c6627c071dc949d588fd1f0112faa5cd.png

35ed0b4a878e49de95ff98922faca113.png

思路：

1.相交只能是Y字形

2.两个链表长度不一样主要体现在它们相交前

3.可以让最长的链表引用先走他们的差值步

88b33926674e4bc98685b05542bbf3b1.png

代码实现：

/**
 * 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;
        int lenB = 0;
        int len = 0;
        // 假定最长的是A
        ListNode pL = headA;
        ListNode pS = headB;
        //长度 
        while(pL!=null) {
            lenA++;
            pL = pL.next;
        }
        while(pS!=null) {
            lenB++;
            pS = pS.next;
        }
        len = lenA-lenB;
        pL = headA;
        pS = headB;
        //修正指向  和  len的差值
        if(len<0) {
            pL = headB;
            pS = headA;
            len = lenB - lenA;
        }
        //保证 pl指向最长的 ps指向最短的 len 是一个正数
        if(pL==null||pS==null) {
            return null;
        }
        //2.让最长的列表走差值步
         for(int i = 0;i < len ;i++) {
             pL = pL.next;
         }
         //3.相遇的点
         while(pL!=pS) {
             pL = pL.next;
             pS = pS.next;
         }
         return pL;
        
    }
}

超级无敌暴龙战士(solider)
关注
  • 16
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
10道经典链表面试题
xaiobit_hl的博客
05-18 3723
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
c语言实现链表面试题
dove1202ly的博客
11-18 2801
   以前实现过链表的简单函数，详细见http://blog.csdn.net/dove1202ly/article/details/77168657       今天我们来看看链表涉及的面试题相信大家都知道单链表面试题的重要性，既然知道，我们就应该把思路捋清楚，然后多敲几遍多敲几遍多敲几遍（重要的事情说三遍），在我身边好多编程好的把这几个函数敲了不下十遍，而我太菜，这才是第一次下定决心把这个整...
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1333
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
链表面试题总结
10-22
数据结构，链表所有综合面试题型汇总，有大神漏缺的给我留言
有关链表的面试题
08-28
链表反转是常见的面试题，可以通过迭代或递归实现。迭代法通常涉及三个指针：前驱、当前和后续，每次将当前节点的指针指向前驱，然后更新前驱和当前指针。递归法则通过递归调用函数，将当前节点的后续节点设为其...
[java版数据结构和算法系列之二]链表之一 –【单链】—手把手带你模拟链表的实现【内含BAT链表面试题实现】
12-21
【链表(Linked List)介绍】 链表是一种线性数据结构，它的元素（节点）在内存中不是连续存储的，而是通过每个节点的指针域相互连接。...在面试中，对链表的理解和操作能力也是考察开发者基础技能的重要部分。
【18】输出字符菱形
2301_78786609的博客
07-19 423
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 376
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
最新发布
qq_62571233的博客
07-23 670
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 603
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 282
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 494
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 289
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 370
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 203
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值