Java数据结构与算法——链表面试题

已于 2023-03-10 17:27:49 修改
阅读量1.4k 收藏 10
点赞数 1
分类专栏： 刷题 文章标签： java 链表 数据结构
于 2022-09-13 09:36:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baijaiyu/article/details/124849386
版权

本文为链表相关面试题，每道题均附讲解及对应链接。

一：反转一个单链表。

链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/

1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

2.解题

         我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所以需要设置一个curNext，保存下一个结点。

        每次都让当前结点指向前一结点，然后head和cur都后移一个节点。直到cur == null时，说明反转结束，直接返回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 reverseList(ListNode head) {
        if(head == null){
                    return head;
                }
                ListNode cur = head.next;
                ListNode curNext = new ListNode();
                head.next = null;
                while(cur != null){
                    curNext = cur.next;
                    cur.next = head;
                    head = cur;
                    cur = curNext;
                }
                return head;
    }
}

二：寻找链表的中间结点 

链接：

876. 链表的中间结点 - 力扣（LeetCode）https://leetcode.cn/problems/middle-of-the-linked-list/comments/

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

2.解题

        我们很容易想到先求出链表长度，再找到中间的结点，但是这种做法的时间复杂度较高。面对这类题时，比较常见的做法是使用“快慢指针”。

        设置fast和slow“指针”，slow指针走一步，fast指针走两步，这样当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) {        
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;

    }
}

三：输出链表中倒数第k个结点

链接：

链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

1.题目：输入一个链表，输出该链表中倒数第k个结点。

2.解题

        这道题任然可以沿用“快慢指针”的思路。让快指针先走k步，然后快慢指针一起走。当快指针走到链表的末尾时，慢指针所在的位置就是链表中倒数第k个结点。当然我们考虑的是最佳情况，而在解决问题时，最重要的就是要考虑到所有的情况。

        特殊情形1：k <= 0；直接返回null；

        特殊情形2：head == null；直接返回null；

        特殊情形3：在fast向后移动k个结点的过程中，fast指针为空了，说明整个链表的长度都不足k，当然不会有倒数第k个结点了，直接返回null。

具体代码如下：

public class Solution {
 public ListNode FindKthToTail(ListNode head,int k) {
         if(k <= 0){
             return null;
         }
         if(head == null){
             return head;
         }
        ListNode slow = head;
        ListNode fast = head;
        while(k-1>0){
            fast = fast.next;
            if(fast == null){
                return null;
            }
            k--;
        }
        while(fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

 四：合并两个有序链表

链接：

21. 合并两个有序链表 - 力扣（LeetCode）https://leetcode.cn/problems/merge-two-sorted-lists/description/

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

 2.解题

        两个链表的头节点分别是head1,head2。从头结点开始，依次比较两个链表结点值的大小，并将较小的那个节点加入到合并链表中，head1(head2)向后移动一位，继续比较剩下的结点。直到其中一个链表的所有节点都已加入到合并链表中，此时就将另一个链表中的剩余结点接到合并链表中，程序结束。

        本题整体思路比较简单，需要考虑的特殊情况是某个头节点为空两个头结点都为空时，无需进行合并，直接返回另一个节点的头结点即可。

具体代码如下：

public static ListNode mergeTwoLists(ListNode head1, ListNode head2) {
        if(head1 == null){
            return head2;
        }
        if(head2 == null){
            return head1;
        }
        ListNode head = new ListNode();
        ListNode cur = head;
        while (head1 != null && head2 != null){
            if(head1.val < head2.val){
                cur.next = head1;
                cur = cur.next;
                head1 = head1.next;
            }else{
                cur.next = head2;
                cur = cur.next;
                head2 = head2.next;
            }
        }
        if(head2 == null){
            cur.next = head1;
        }else{
            cur.next = head2;
        }
        return head.next;
    }

五：链表分割

链接：

链表分割_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

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

2.解题 

        使用两个链表，一个链表放小于x的结点，另一个链表放大于x的结点。遍历原链表结束后，就可以将所有小于x的结点放在第一个链表中，其余结点放在第二个链表中，且顺序不变。最后，将两个链表连接起来即可。

特殊情况及注意事项：

1.特殊情况：当链表为空时，直接返回null；

2.注意事项：连接两个链表后，一定要将第二个链表的next域置为null，否则会出现混乱。

具体代码如下：

import java.util.*;

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

    ListNode(int val) {
        this.val = val;
    }
}*/
//思路：
//1.分为两个链表,一个链表放小于x的节点，一个链表放大于等于x的节点
//2.连接两个链表
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        ListNode head1 = null;
        ListNode last1 = null;
        ListNode head2 = null;
        ListNode last2 = null;
        if(pHead == null){
            return null;
        }
        while(pHead != null){
            if(pHead.val < x){
                if(head1 == null){
                    head1 = pHead;
                    last1 = pHead;
                }else{
                    last1.next = pHead;
                    last1 = last1.next;
                }
            }
            else{
                if(head2 == null){
                    head2 = pHead;
                    last2 = pHead;
                }
                else{
                    last2.next = pHead;
                    last2 = last2.next;
                }
            }
            pHead = pHead.next;
        }
        //进行连接
        if(head2 == null){
            return head1;
        }
        if(head1 == null){
            return head2;
        }
        last1.next = head2;
        last2.next = null;//最后一个next域置为null
        return head1;
    }
}

六：链表的回文结构

链接：

链表的回文结构_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId=49&&tqId=29370&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

1.题目：

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

2.解题

        回文链表类似于这样的结构：1-3-4-4-3-1，显然从中间分开，两边对称。结合之前讲到的链表反转和寻找中间结点，我们考虑先找到中间结点，然后从中间结点开始，将其后的链表反转；然后遍历两个链表，依次比较每一个结点的值。如果其中两个结点的值不同，说明这不是一个回文串，返回false即可。图解如下：

         显然结点个数不同，判断结束的标志也有所差异，我们只需将这两种情况都添加到我们的判断语句中即可，当head == slow || head.next == slow时，表明每个节点都已经判断完毕，该链表是回文的，返回true。

具体代码如下：

import java.util.*;


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class PalindromeList {
public boolean chkPalindrome(ListNode A) {
        //1.找到中间结点
        ListNode head = A;
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //此时，slow已经指向中间的结点
        //2.从中间结点开始进行反转
     ListNode cur = slow.next;
            ListNode curNext = new ListNode(1);
            while(cur != null) {
                curNext = cur.next;
                cur.next = slow;
                slow = cur;
                cur = curNext;
            }
        //反转成功，最开始有个head，最后面有个slow
        //3.从两边，向中间走
        while(head.val == slow.val){
            head = head.next;
            slow = slow.next;
            if(head == slow || head.next == slow){
                return true;
            }
        }
        return false;

    }
}

七：判断链表中是否有环

链接：

141. 环形链表 - 力扣（LeetCode）https://leetcode.cn/problems/linked-list-cycle/description/

1.题目：给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 

2.解题

        快慢指针。慢指针一次走一步，快指针一次走两步，如果链表中有环，快慢指针一定会相遇。

        具体代码如下：

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

八：环形链表

链接：

142. 环形链表 II - 力扣（LeetCode）https://leetcode.cn/problems/linked-list-cycle-ii/description/

1.题目：给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

2.解题：

        这是一个简单的数学问题。

 

 具体代码如下：

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

        以上就是关于链表的一些习题。“快慢指针”在解决链表问题时经常出现，我们一定要掌握好这种方法；其次，在解决题目六：链表的回文结构时，我们用到了“快慢指针”和“反转链表”的相关知识，很容易就解决了这个题目，这说明再解决一些较为复杂的问题时，可以将其拆分为一个个简单问题加以解决。

九 : 相交链表

链接:160. 相交链表 - 力扣（LeetCode）https://leetcode.cn/problems/intersection-of-two-linked-lists/

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

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) {
    if (headA == null || headB == null) return null;
    ListNode pA = headA, pB = headB;
    while (pA != pB) {
        pA = (pA == null) ? headB : pA.next;
        pB = (pB == null) ? headA : pB.next;
    }
    return pA;
}
}

注意 : 运算符优先级问题 : == 高于 ?= 高于 = .

优先级运算符结合性
1()、[]、{}从左向右
2!、+、-、~、++、--从右向左
3*、/、%从左向右
4+、-从左向右
5«、»、>>>从左向右
6<、<=、>、>=、instanceof从左向右
7==、!=从左向右
8&从左向右
9^从左向右
10|从左向右
11&&从左向右
12||从左向右
13?:从右向左
14=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=从右向左

        链表题目浩如烟海，以上所展示的不过是沧海一粟罢了。笔者将力扣及牛客网上链表部分的链接放在下面，感兴趣的朋友可以自行选择练习。

链接：

链表知识点题库 - 力扣（LeetCode）https://leetcode.cn/tag/linked-list/problemset/链表知识点题库 - 牛客网（nowCoder）https://www.nowcoder.com/exam/oj

本课内容结束！

知行&
关注
专栏目录
Java单链表面试题
weixin_47219685的博客
10-09 177
单链表面试题 获取单链表长度 查找单链表倒数第k个元素 单链表反转 反向打印单链表（不破坏原有单链表） 合并两个有序的单链表，合并后依然有序
【数据结构与算法_java】面试题及答案汇总
weixin_42208959的博客
09-05 4193
文章目录一、剑指offer：50道金典面试题题目1：赋值运算符函数面试题2：实现单例模式面试题3：二维数组中的查找二、LeetCode上经典题目三、其他金典面试题 前    言 本文将收录《剑指offer：50道金典面试题》、LeetCode上部分经典题目以及其他【据结构和算法】数面试题。 PS：持续更新中，敬请期待~~ 正    文 一、剑指offer：50道金典面试题 题目
JAVA实现链表面试题
bin的主栏
07-08 6024
这篇文章主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。 本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中
数据结构练习题（java版）考前必备！
最新发布
2301_79083481的博客
09-06 896
思路：反过来，用栈实现队列也一样我们使用一个栈肯定是不够的，我们创建两个栈一个用来入栈，一个用来出栈，push操作我们只把元素存到inStack，pop操作我们把push的元素都拿过来之后出栈第一个元素，再把所有的元素放回inStack。让head当做头，rear往后走，留一个零我们不放数据，让head和rear的移动作为队列元素的移动，当head==rear时，队列为空，当rear的下一个元素是head时，队列为满，rear的移动为入栈，head的移动为出栈，1，我们每次入栈列都把元素放到空的队列中。
链表面试题java实现
weixin_30463341的博客
05-25 153
https://www.cnblogs.com/smyhvae/p/4782595.html 转载于:https://www.cnblogs.com/haojiesky/p/10922231.html
【JAVA】链表面试题
Xian meng在努力呐-的博客
08-09 599
链表面试题
java 链表面试题_链表 面试题（Java）
weixin_30711615的博客
02-16 234
链表的逆置给定一个单链表，实现链表的逆置功能思路：在前面的单链表练习中，讲到了头插，头插的链表和正常的序列是刚好相反的，利用这点来进行链表的逆置代码讲解：使用cur指针指向第一个数据域，把head单独拿出来，重新对head头插一次，在头插中，cur的next域要先把head的next域接过来，然后把head的next置为cur，这样做的话会丢失cur后面的所有未插入节点，就要使用一个指针next来...
数据结构与算法分析（java语言描述）中文第二版以及习题答案
06-21
本资源包含两本书——《数据结构与算法分析（Java语言描述）》的中文第二版以及对应的习题答案，无论是英文还是中文版本，都是Java开发者深入理解这一领域的宝贵资料。 《数据结构与算法分析》一书，作者通常会详细...
poj与leetcode-AlgorithmComplete:数据结构、算法及常见面试题：java实现
06-30
《poj与LeetCode——数据结构、算法及常见面试题：Java实现》是针对程序员提升算法能力和解决实际问题的一份宝贵资源。这个项目主要涵盖了在编程竞赛如POJ（Programming Online Judge）和在线编程平台LeetCode上的...
Java实现：百度、新浪、盛大面试算法题——链表操作解析
这篇资料的重点是Java编程语言在解决数据结构与算法问题中的应用，特别是针对链表这种基本数据结构的操作。以下是这些知识点的详细说明： 1. **单链表**：单链表是一种线性数据结构，每个节点包含一个数据元素和一...
Java 程序员必须掌握的 8 道数据结构面试题，你会几道？
java_spring6的博客
06-18 4798
今天带大家看下面试中你可能会遇到的8道数据结构题—↓↓↓瑞士计算机科学家Niklaus Wirth在1976年写了一本书，名为《算法+数据结构=编程》。40多年后，这个等式仍被奉为真理。这就是为什么在面试过程中，需要考察软件工程师对数据结构的理解。几乎所有的问题都需要面试者对数据结构有深刻的理解。无论你是初入职场的新兵（刚从大学或者编程培训班毕业），还是拥有几十年经验的职场老鸟。有些面试题会明确提及某种数据结构，例如，“给定一个二叉树。”而另一些则隐含在面试题中，例如，“我们希望记录每个作者相关的书籍数量。
常见链表面试题 （java语言版）
weixin_41445507的博客
04-07 1243
一、逆置反转单链表 例如：操作前：1 2 3 4 null 操作后： 4 3 2 1 null 方法一： public ListNode reverseList_01(ListNode head) { ListNode result = null; ListNode cur = head; ...
Java链表常见面试题
qq_45852612的博客
05-05 626
链表常见题型
给Java程序员的20个链表面试题
读芯术的博客
09-03 1250
全文共4258字，预计学习时长8分钟图片来源：unsplash.com/@d_mccullough今天，本文将详细介绍编程面试中常见的链表问题。什么是链表？数据结构在程序...
Java面试题（八）链表常见算法题
岁月不饶人，我亦未曾饶过岁月
12-27 1099
链表常见算法
java实现单链表常见操作
weixin_30344795的博客
01-23 254
一、概述： 　　本文主要总结单链表常见操作的实现，包括链表结点添加、删除；链表正向遍历和反向遍历、链表排序、判断链表是否有环、是否相交、获取某一结点等。 二、概念： 链表： 　　一种重要的数据结构，HashMap等集合的底层结构都是链表结构。链表以结点作为存储单元，这些存储单元可以是不连续的。每个结点由两部分组成：存储的数值+前序结点和后序结点的指针。即有前序结点的指针又有后序结点的指针的...
Java实现单链表面试题
Leetp
04-07 617
Java链表面试题
链表 面试题（Java）
博客
09-25 802
链表的逆置 给定一个单链表，实现链表的逆置功能 思路：在前面的单链表练习中，讲到了头插，头插的链表和正常的序列是刚好相反的，利用这点来进行链表的逆置 代码讲解：使用cur指针指向第一个数据域，把head单独拿出来，重新对head头插一次，在头插中，cur的next域要先把head的next域接过来，然后把head的next置为cur，这样做的话会丢失cur后面的所有未插入节点，就要使用一个指针ne...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值