那些你将来面试会遇到的链表题---JAVA

最新推荐文章于 2022-06-24 00:23:56 发布
最新推荐文章于 2022-06-24 00:23:56 发布
阅读量100 收藏
点赞数
分类专栏： 笔记 面试题 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46657493/article/details/109500306
版权 
package Link;
//定义链表结点
public class ListNode {
    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}


package Link;

import java.util.List;

public class LinkTest {
    public ListNode head;
    //尾插
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(this.head == null) {
            this.head = node;
        } else {
            ListNode cur = this.head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }
    //打印
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
    public void removeAllKey(int key) {

    }

}

题目及代码：

  1. 以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前.
public ListNode  partition(int x) {
        //小于x的部分
        ListNode bs = null; //头
        ListNode be = null; //尾
        //大于x的部分
        ListNode as = null;
        ListNode ae = null;
        ListNode cur = this.head;
        while(cur != null) {
            if(cur.val < x) {
                if(bs == null) {//第一次插入--尾插
                    bs = cur;
                    be = as;
                } else {
                    bs.next = cur;
                    be = cur;
                }

            } else {
                if(as == null) {//第一次插入--尾插
                    as = cur;
                    ae = as;
                } else {
                    as.next = cur;
                    ae = cur;
                }
            }
            cur = cur.next;
        }
        if(bs == null) {//无小于x的结点
            return as;//直接返回大于x的链表的头结点 as
        }
        be.next = as;//不等于空 则将两个链表连接起来
        if(as != null) {
            ae.next = null; //最后一个结点的next域为null
        }
        return bs;
    }
  1. 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
public ListNode deleteDuplication() {
        ListNode newHead = new ListNode(-1);//傀儡节点（最后返回傀儡节点的下一个--头结点）
        ListNode cur = this.head;
        ListNode tmp = newHead;
        while(cur != null) {
            if(cur.next != null && cur.val == cur.next.val) {
                while (cur.next != null && cur.val == cur.next.val) {
                    cur = cur.next;//多个重复的结点,找完之后，cur指向最后一个相同的需要删除的结点
                }
                cur = cur.next;//找完之后，需要指向下一个结点
            }else {// 除相同值的结点
                tmp.next = cur;
                tmp = cur;
                cur = cur.next;
                }
        }

        tmp.next = null;//防止最后两个结点相等
        return newHead.next;
    }
  1. 链表的回文结构的判断
public boolean chkPalindrome() {
        if(this.head == null) {
            return false;
        }
        if(this.head.next == null) {//一个结点
            return true;
        }
        //1.找到中间结点slow
        ListNode fast = this.head;//快慢指针
        ListNode slow = this.head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        //2.反转
        ListNode cur = slow.next;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //3.判断val值是否相同
        //一个从前往后走，一个从后往前走
        while(this.head != slow) {
            if(this.head.val != slow.val) {
                return false;
            }
            if(this.head.next == slow) {//偶数结点时
                return true;
            }
            this.head = this.head.next;
            slow = slow.next;
        }
        return true;
    }
  1. 给定一个链表，判断链表中是否有环定义两个引用，一个引用走一步，一个引用走两步，如果两个引用最后相遇，则代表该链表有环
public boolean hasCycle() {
        ListNode fast = this.head;
        ListNode slow = this.head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast) {
                return true;
            }
        }
        return true;
    }
  1. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null
public ListNode detectCycle() {
        //假设起点到入口点的位置为X 圈长度为C L代表入口点到相遇点的距离 N代表圈数
        //相遇时fast所走的路程时slow所走路程的两倍
        //slow:X+L
        //fast：X+L+NC
        //2(X+L) = X+L+NC --(与N无关，取N=1)
        //X=C-L
        ListNode fast = this.head;
        ListNode slow = this.head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast) {
                break;
            }
        }
        if(fast == null || fast.next == null) {
            return null;//没有环
        }
        slow = this.head;
        while(slow != fast) { //fast在相遇点，
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
  1. 输入两个链表，找出它们的第一个公共结点
public ListNode getIntersectionNode(ListNode head1,ListNode head2) {
        //相交的链表的形状是横着的Y
        //相交 即next域指向相同
        //如果两个链表长度不一样，如果两个链表相交，那么他们的长度差，必然在相交点的前半部分
        //步骤：
        //1.分别求出两个链表的长度
        //2.让最长的链表走两个链表的差值步
        //3.两个引用同时开始走，如果相遇，说明两个链表相交
        if(head1 == null || head2 == null) {
            return null;
        }
        ListNode pl = head1; //长
        ListNode ps = head2;// 短
        int len1 = 0;
        int len2 = 0;
        while(pl != null) {//链表1的长度
            len1++;
            pl = pl.next;
        }

        while(ps != null) {//链表2的长度
            len2++;
            ps = ps.next;
        }
        //循环结束后，pl,ps指向改变（为null），需要重新指回头结点
        pl = head1;
        ps = head2;
        int len = len1 - len2;//找出长度较长的链表
        if(len < 0) {  //链表2较长
            ps = head1;
            pl = head2;//保证p1指向长链表，p2指向短链表
            len = len2 - len1;//保证len为正
        }
        while(len > 0) {//pl先走差值步
            len--;
            pl = pl.next;
        }
        while(pl != null & ps != null && pl != ps) {//在pl,ps同时一步一步走
            pl = pl.next;
            ps = ps.next;
        }

        //相交即返回pl或ps
        if(pl == ps && pl != null) {
            return pl;
        }
        //未找到
        return null;
    }
  1. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的
public ListNode mergeTwoLists(ListNode p1,ListNode p2) {

        ListNode newHead = new ListNode(-1);//定义一个傀儡结点
        ListNode tmp = newHead;
        while(p1 != null && p2 != null) {
            if(p1.val > p2.val) {
                tmp.next = p2;
                tmp = p2;
                p2 = p2.next;
            } else {
                tmp.next = p1;
                tmp = p1;
                p1 = p1.next;
            }
        }
        if(p2 == null) {//p1剩下的val值都比之前的值大
            tmp.next = p1;
        }
        if(p1 == null) {//p2剩下的val值都比之前的值大
            tmp.next = p2;
        }
        return newHead.next;
    }
  1. 删除链表中等于给定值 key 的所有节点
if(head == null){
            return  null;
        }
        ListNode cur = this.head.next;
        ListNode prev = this.head;
        while(cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                cur = cur.next;
                prev = prev.next;
            }
        }
        if(this.head.val == key) {
            this.head = this.head.next;
        }
        return  this.head;
  1. 反转一个单链表
public ListNode reveseList() {
        ListNode cur  =this.head;
        ListNode prev = null;
        while(cur != null ) {
            ListNode nextCur = cur.next;
            cur.next = prev;
            prev = cur;
            cur = nextCur;
        }
        return prev;
    }
  1. 输入一个链表，输出该链表中倒数第k个结点
public ListNode FindKthToTail(int k) {
        if(k <= 0 || this.head == null) {
            return null;
        }
        //快慢指针
        ListNode fast = this.head;
        ListNode slow = this.head;
        while(k - 1 > 0) {//先让fast指针走k - 1次
            if(fast.next != null) {//链表长度大于等于k值时
                fast = fast.next;
                k--;
            } else {//k值过大
                return null;
            }
        }
        while(fast.next != null ) {
        //快慢指针一起走（每次走一步）
        //即得到倒数第k个结点处
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
  1. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结
    点
  public ListNode middleNode() {
        //快慢指针
        ListNode fast = this.head;
        ListNode slow = this.head;
        if(head == null) {
            return null;
        }
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
柠七99
关注
专栏目录
Java面试题八股文(进阶)--完结
AntdonYu的博客
04-29 3721
Java面试题参考350道性能优化专题tomcat性能优化1、怎么给你的tomcat调优2、如何加大tomcat连接数3、怎样加大tomcat的内存4、tomcat如何禁止列目录下的文件5、tomcat有几种部署方式5、tomcat的优化经验 性能优化专题 tomcat性能优化 1、怎么给你的tomcat调优 1、JVM的调优参数：-Xms表示初始化堆的大小，-Xmx表示JVM堆的最大值。这两个值的大小一般是根据需要设置的，当程序需要的内存超出堆内存的最大值的时候就会提示内存溢出（OOM）。并且导致服务崩溃
面试心得与总结---BAT、网易、蘑菇街
m0_67698950的博客
03-16 275
之前实习的时候就想着写一篇面经，后来忙就给忘了，现在找完工作了，也是该静下心总结一下走过的路程了，我全盘托出，奉上这篇诚意之作，希望能给未来找工作的人一点指引和总结， 也希望能使大家少走点弯路 ， 如果能耐心读完，相信对你会找到你需要的东西。 先说一下LZ的基本情况，LZ是四川某985学校通信专业的研究生（非计算机），大学阶段也就学了C语言，根本没想过最后要成为码农。大四才开始学java，研一下开始学android，所以LZ觉得自己开始就是一个小白，慢慢成长起来的。 一、心态 心态很重要！ ..
package-linker:npm软件包的链接实用程序
05-02
包链接器 npm软件包的链接实用程序。 安装： npm i -g package-linker 用法： 当同时使用多个相互依赖的程序包时，在同一级别检出所有存储库，然后根据需要使用“ npm link”命令将它们链接起来很有用。 该实用程序从配置文件中读取要相互链接的软件包，从当前子文件夹中找到匹配的项目，然后执行不同的命令（如下所示）。 在包含要链接的软件包的文件夹中创建一个配置文件： .npmpl.json: { "packages": ["foo-*", "bar"] } 链接所有程序包，然后链接其所有依赖项： 查找与给定模式或名称匹配的所有现有文件夹，首先进入每个目录并执行“ npm链接”，然后第二次进入每个目录，找出哪些依赖项是“可链接的”并执行“ npm链接'。 npmpl link 取消链接所有程序包，然后取消链接其所有依赖项： 查找与给定模式或名称匹配的所有
Java数据结构之链表——头插法逆置双链表
weixin_45700507的博客
04-25 350
定义双链表基本操作 package Link; class DoubleNode{ public int value; // 该结点所保存的值 public DoubleNode next; // da该结点下一个结点指针 public DoubleNode last; // da该结点上一个结点指针 public DoubleNode(int data){ value = data; next = null; la.
package.json常用配置 npm install原理 npm link
又一个四季在轮回
12-19 2504
package.json常用配置： name（必填）项目的名称 version: （必填）当前项目的版本号 main：入口文件（前端因为有webpack的存在基本上用不到，只是作为发布的时候别人下载下来用的时候的入口文件） description: 描述信息 author：作者信息（发布时用到） license：开源协议（发布时用到） private：是否为私密（设置为true不可以发布） script：脚本执行 我们都知道执行某个js文件的时候我们通过：node index.js来执行index.j
Java学习笔记五
guoyunyuhou的专栏
04-13 652
67. Object 类是所有类的父类，所以如果某个方法要调用或者返回一个Object类型的数据，那么这个数据可以是全类型，int boolean 、String、   68. 但是要特别注意的一点是，以前也说过，子类转换成父类向上类型转换是可以的， 比如上面说的如果一个方法定义成 method（Object a）,要求传入一个Ob
剑指Offer 面试题25：合并两个排序的链表（递归+非递归） Java代码实现
hh_zheng的博客
12-07 1326
题目：输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 不断比较两个链表中的节点，将小的添加到新的链表中，直到有一个链表全部添加完后，直接把另一个链表剩下的拼接到新链表后。要注意空链表的处理。 非递归的代码： //采用不带头结点的链表 非递归实现 public static ListNode merge(ListNode list1,ListNode list2
2022届校招Java面试题汇总(含题解)
热门推荐
JE_9664的博客
08-30 1万+
本文将笔者在面试中遇到的真实题目汇总成集，初衷是为了每次面试完能够及时复盘，以便查漏补缺。此外，如果能给他人以参考也是好的。
2020最新Java工程师面试题-Memcached 面试篇（附答案）
it小旭博客
04-23 891
1、Memcached 是什么，有什么作用？ Memcached 是一个开源的，高性能的内存绶存软件，从名称上看 Mem 就是内存 的意思，而 Cache 就是缓存的意思. Memcached 的作用：通过在事先规划好的内存空间中临时绶存数据库中的各类数据， 以达到减少业务对数据库的直接高并发访问. 从而达到提升数据库的访问性能，加速网站集群动态应用服务的能力。 memcached 服务在企业集...
Java面试常见问题总结
m0_67265464的博客
06-24 638
Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别就能让你直接进入第二轮面试，但是现在问题变得越来越高级，面试官问的问题也更深入。 在我初入职场的时候，类似于 Vector 与 Array 的区别、HashMap 与 Hashtable 的区别是最流行的问题，只需要记住它们，就能在面试中获得更好的机会，但这种情形已经不复存在。如今，你将会被问到许多 Java 程序员都没有看过的领域，如 NIO，设计模式，成熟的单元测试，或者那些很难掌握的知识，
简单聊一下数组和链表
程序员的时光
02-29 933
写在前面 数组和链表是数据结构中最基础的两种结构,其他的都是由这两者转化而来； 因此，掌握这两种结构至关重要！下面，时光就带大家来学习一下数组和链表； 思维导图： 1，什么是线性表？ 线性表是具有相同类型的n（>=0）个数据元素的有限序列（a0,a1,a2,…,an），ai是表项，n是表长度； 那么为什么要提到线性表呢？ 因为数组和链表都是线性表的结构，只不过它们的存储方式不一样； 根...
关于链表问题的面试题目 【微软面试100题 第七十七题】
weixin_33725515的博客
11-23 92
题目要求： 　　1.给定一个单链表，检测是否有环； 　　2.判断两个无环单链表是否有交点； 　　3.给定两个单链表，检测两个链表是否有交点； 　　4.给定单链表，如果有环的话请返回从头结点进入环的第一个结点； 　　5.只给定单链表中某个结点p（并非最后一个结点，即p->next!=NULL）指针，删除该结点； 　　6.只给定单链表中某个结点p（非空结点），在p前面插入一个结点。 ...
java中的ListNode链表
qq_43842093的博客
06-28 2924
ListNode 刷LeetCode碰到一个简单链表题，题目已经定义了链表节点ListNode struct ListNode { int val; //定义val变量值，存储节点值 struct ListNode *next; //定义next指针，指向下一个节点，维持节点连接 } 在节点ListNode定义中，定义节点为结构变量。 节点存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，当 next 为空指针
Java实现链表
tangtj的专栏
11-30 437
class Link{private Node head;public Link(Node head){this.head=head;}public void addNode(Node node){Node p=head;while(true){if(!p.hasNext()){p.setNext(node);break;}p=p.getNext();}}//插入节public void in
通俗易懂说单链表（3）合并两个有序链表
哈尼的博客
05-05 397
通俗易懂说单链表（3）合并两个有序链表1. 递归实现2. 非递归实现 1. 递归实现 typedef struct node{ int value; struct node *next; }Node, *pNode; //采用递归的方法实现 Node *SingleListMerge(Node *head1,Node *head2) { if(head1==NULL) return h...
O(1)时间复杂度删除链表元素
TalonG的专栏
10-19 2742
package lineartable; /**  * 链表节点类  */ class Node{     public String value;     public Node next;     public Node(String value){         this.value=value;         this.next=null;     } } /*
变量与类型转换
m0_46657493的博客
07-17 917
final修饰常量 在c中我们用const修饰常量，但是在Java中我们是用关键字final来修饰常量。变量在运行期间是可以改变的，而且变量的值在运行的时候才能知晓，但是常量是在编译期间就能确定的知道它的值（直接被替换），而且在运行期间不能被改变。 以下代码中，可以看到a被重新赋值为20，但是只能初始化，所以c=40; 但是当常量b被赋值的时候，程序将会报错，如下： 也可以先定义一个常量，再进行初始化，但是只能初始化一次 该反汇编中，是可以直接看到d的值（50），但是却不能直接看到c的值。所以可以印证变
基于比较的七种排序算法的总结
m0_46657493的博客
11-09 857
1.冒泡排序 最好时间复杂度：O(n) 最坏时间复杂度：O(n^2) 平均时间复杂度：O(n^2) 空间复杂度:O(1) 稳定性：稳定 2.插入排序 最好时间复杂度：O(n) （数据有序） 最坏时间复杂度：O(n^2) （数据逆序） 平均时间复杂度：O(n^2) 空间复杂度:O(1) 稳定性：稳定 思想： 1.[有序区间，无序区间]，每次从无序区间中的数中选出一个，依次与有序区间的数进行比较，xuan 代码： 3.选择排序 最好时间复杂度：O(n^2) 最坏时间复杂度：O(n^2) 平均时间复杂度：O
二进制向其他进制的转换
m0_46657493的博客
07-16 715
方法：整数部分基数连除取余(从下到上)，小数部分基数连乘取整（从上到下） 对于给定的一个十进制整数，将其转为二进制形式 方法：整数部分基数连除2取余(从下到上)，小数部分基数连乘2取整（从上到下） 例如对于：35.85 对于一个给定的十进制整数，将其转为十六进制形式 方法：整数部分基数连除16取余(从下到上)，小数部分基数连乘16取整（从上到下） 例如对于：93.85 ...
《Java程序员面试笔试真题库》- 深入解析大数据面试
"链式存储结构-滴滴快的大数据架构演进-胡亚新 | Java程序员面试笔试真题库-猿媛之家" 本文主要探讨了链式存储结构在大数据架构中的应用，并结合二叉树和快速排序算法的知识点进行了分析。在大数据处理中，高效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值