牛客网常见面试题之链表操作

已于 2023-08-16 17:45:35 修改
阅读量39 收藏
点赞数
文章标签： 链表 java 面试
于 2023-08-16 15:20:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67907445/article/details/132313682
版权

目录

1. 反转链表19

2. 翻转指定区间29

3.k个一组翻转40

4.合并有序链表47

5.合并k个有序00

6.判断是否有环

7.找环的入口18

8.查找倒数第k个28

9.删除倒数第k个32

10.两个链表的第一个节点15

11.链表相加 23

12.判断链表回文33

13.链表奇偶重排51

14. 删除重复元素155

15.删除重复元素202

16.单链表的排序09

总结：

1. 反转链表19
 if(head==null || head.next==null) return head;

        ListNode now =head;
        ListNode next = head.next;

        ListNode n =null;


        while(next!=null){
            now.next=n;
            n=now;
            now=next;
            next=next.next;

        }

        now.next=n;
        return now;
2. 翻转指定区间29
public ListNode reverseBetween (ListNode head, int m, int n) {
        // write code here
        ListNode dummy=new ListNode(-1);
        dummy.next=head;

        ListNode pre=dummy,p=head;
        int index=1;
        while(index!=m){
            pre=pre.next;
            p=p.next;
            index++;
        }

        ListNode tail=p;

        while(index<=n){
            ListNode temp=p;
            p=p.next;
            temp.next=pre.next;
            pre.next=temp;
            index++;
        }

        tail.next=p;

        return dummy.next;
    }
3.k个一组翻转40
public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        int size=0;
        ListNode p=head;
        while(p!=null){
            size++;
            p=p.next;
        }
        if(size<k) return head;

        int index =1;
        ListNode n=null;
        p=head;

        ListNode temp =p;
        while(index<=k){
            temp=p;
            p=p.next;
            temp.next=n;
            n=temp;
            index++;
        }
        head.next=reverseKGroup(p,k);

        return temp;

    }
4.合并有序链表47
public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        ListNode res=new ListNode(-1),p=res;
        ListNode p1=pHead1,p2=pHead2;

        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=p2;
        }
        if(p2==null){
            p.next=p1;
        }
        return res.next;
    }
5.合并k个有序00
 public ListNode mergeKLists (ArrayList<ListNode> lists) {
        // write code here
        if(lists.size()==0) return null;

        PriorityQueue<ListNode> q=new PriorityQueue<>(lists.size(),(ListNode a,ListNode b)->a.val-b.val);

        ListNode res=new ListNode(-1);
        for(ListNode p:lists){
            if(p!=null)
                q.offer(p);
        }

        ListNode p=res;
        while(!q.isEmpty()){
            ListNode temp=q.poll();
            if(temp.next!=null){
                q.offer(temp.next);
            }
            temp.next=null;
            p.next=temp;
            p=p.next;
        }

        return res.next;
    }
6.判断是否有环
 public boolean hasCycle(ListNode head) {
        if(head==null || head.next==null){
            return false;
        }
        ListNode slow=head,fast=head;

        slow=slow.next;
        fast=fast.next.next;

        while(fast!=null && fast.next!=null){
            if(slow==fast) return true;
            slow=slow.next;
            fast=fast.next.next;
        }

        return false;
        
    }
7.找环的入口18
 public ListNode EntryNodeOfLoop(ListNode head) {
        if(head==null || head.next==null){
            return null;
        }
        ListNode slow=head,fast=head;

        slow=slow.next;
        fast=fast.next.next;

        while(fast!=null && fast.next!=null){
            if(slow==fast) {
                return getEntrance(slow,head);
            }
            slow=slow.next;
            fast=fast.next.next;
        }

        return null;
    }
    public ListNode getEntrance(ListNode p,ListNode head) {
        ListNode slow1=head,slow2=p;
        while(slow1!=slow2){
            slow1=slow1.next;
            slow2=slow2.next;
        }
        return slow1;
    }
8.查找倒数第k个28
public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(pHead==null) return null;

        ListNode p1=pHead,p2=pHead;
        while(k--!=0){
            if(p2==null){
                return null;
            }
            p2=p2.next;
            
        }
        while(p2!=null){
            p1=p1.next;
            p2=p2.next;
        }
        return p1;
    }
9.删除倒数第k个32
public ListNode removeNthFromEnd (ListNode pHead, int k) {
        // write code here
        if(pHead==null) return null;

        ListNode p1=pHead,p2=pHead,dummy=new ListNode(-1),p=dummy;
        dummy.next=pHead;
        while(k--!=0){
            if(p2==null){
                return null;
            }
            p2=p2.next;
            
        }
        while(p2!=null){
            p1=p1.next;
            p2=p2.next;
            p=p.next;
        }

        p.next=p.next.next;
        return dummy.next;
    }
10.两个链表的第一个节点15
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if (pHead1 == null || pHead2 == null ) return null;
        int m = getLen(pHead1), n = getLen(pHead2);
        ListNode p1 = pHead1, p2 = pHead2;
        if (m < n) {
            int t = m;
            m = n;
            n = t;
            p1 = pHead2;
            p2 = pHead1;
        }

        while (m != n) {
            p1 = p1.next;
            m--;
        }
        while (p1 != p2) {
            p1 = p1.next;
            p2 = p2.next;
            if (p1 == null || p2 == null) return null;
        }
        return p1;
    }

    private int getLen(ListNode pHead1) {
        // TODO
        int m = 0;
        ListNode p = pHead1;
        while (p != null) {
            m++;
            p = p.next;
        }
        return m;

    }
11.链表相加 23
 public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        ListNode p1 = reverse(head1);
        ListNode p2 = reverse(head2);

        ListNode res = new ListNode(-1);
        ListNode p = res;
        int flag = 0;
        while (p1 != null && p2 != null) {
            int t = p1.val + p2.val + flag;
            ListNode temp = new ListNode(t % 10);
            flag = t / 10;
            p.next = temp;
            p = p.next;
            p1=p1.next;
            p2=p2.next;
        }
        while (p1 != null ) {
            int t = p1.val + flag;
            ListNode temp = new ListNode(t % 10);
            flag = t / 10;
            p.next = temp;
            p = p.next;
             p1=p1.next;
        }
        while (p2 != null) {
            int t = p2.val + flag;
            ListNode temp = new ListNode(t % 10);
            flag = t / 10;
            p.next = temp;
            p = p.next;
            p2=p2.next;
        }
        if(flag!=0){
            ListNode temp = new ListNode(flag);
            p.next = temp;
            p = p.next;
        }
        res =res.next;
        return reverse(res);

    }
12.判断链表回文33
public boolean isPail (ListNode head) {
        // write code here
        if(head==null||head.next==null) return true;
        ListNode re=ReverseList(head);
        while(re!=null){
            if(re.val!=head.val) return false;
            re=re.next;
            head=head.next;
        }
        return true;
        
    }

    public ListNode ReverseList (ListNode head) {
        // write code here
      
        ListNode now =head;
        ListNode res = new ListNode(-1);

        while(now!=null){
            ListNode t = new ListNode(now.val);
            t.next=res.next;
            res.next=t;
            now=now.next;
        }

        return res.next;

    }
13.链表奇偶重排51
public ListNode oddEvenList (ListNode head) {
        // write code here

        ListNode temp=new ListNode(-1),p=head,dummy=new ListNode(-1);
        dummy.next=head;
         ListNode pre=dummy,temp_t=temp;
        int index=1;
        while(p!=null){
            if(index%2==0){
                ListNode t=p;
                pre.next=pre.next.next;
                p=p.next;
                index++;
                t.next=null;
                temp_t.next=t;
                temp_t=temp_t.next;

            }else{
                pre=pre.next;
                p=p.next;
                index++;
            }
        }
        pre.next=temp.next;

        return dummy.next;
    }
14. 删除重复元素155
public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if(head==null) return null;
        ListNode p=head,n=p.next;
        while(n!=null){
            if(n.val==p.val){
                n=n.next;
                p.next=p.next.next;
            }
            else{
                p=p.next;
                n=p.next;
            }
        }
        return head;

    }
15.删除重复元素202
public ListNode deleteDuplicates (ListNode head) {
        // write code here
        ListNode dummy=new ListNode(-1);
        dummy.next=head;

        if(head==null) return null;
        ListNode pre=dummy,p=head,n=p.next;
        while(n!=null){
            int flag=0;
            while(n!=null && n.val==p.val){
                n=n.next;
                flag=1;
            }
            if(flag==1){
                pre.next=n;
                p=n;
                if(n==null){
                    break;
                }
                n=p.next;
            }
            else{
                pre=pre.next;
                p=p.next;
                n=p.next;
            }
        }
        return dummy.next;
    }
16.单链表的排序09
 public ListNode sortInList (ListNode head) {
        // write code here
        PriorityQueue<ListNode> q=new PriorityQueue<>((ListNode a,ListNode b)->a.val-b.val);
        ListNode res=new ListNode(-1);
        while(head!=null){
            ListNode t=head;
            head=head.next;
            t.next=null;
            q.offer(t);
        }
        ListNode p=res;
        while(!q.isEmpty()){
             ListNode t=q.poll();
             p.next=t;
             p=p.next;
        }

        return res.next;
       
    }
总结：

1. 链表问题主要在于判空和指针复位；

2.判空主要出现在：

        1. 初始数据可能为空；

        2. 遍历过程中要使用p.val或者p.next的时候p不能为空；

        3.特殊一点的for each 遍历的时候也不能为空；

3.指针复位：

        下一次判断的时候所有指针要复位；

4.删除需要前指针，第一个节点有时候需要虚拟指针来方便统一操作；

5. 主要知识点：

        1.双指针；

        2.快慢指针；

        3.头插法；

        4.指针遍历；

       

题目来源于：

牛客网在线编程_算法篇_面试必刷TOP101

小陈要进大厂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
牛客网面试——常见编程题
FPGA/MATLAB学习教程/源码/项目合作开发
10-03 457
x,y,l,r=2,y>=2$，如$3\ 5\ 10\ 22$，在$[10,22]$区间内，$x=3,y=5$的条件下，区间内[14]是神奇数，所以最长的区间是$[15,22]$长度为$8$，如$2，3，1，10$，在$[1,10]$区间内，$x=2，y=3$的条件下，$2，3，4，5，7，9$都是神奇数，所以最长的区间只有长度$1$。请问输出a的结果是什么？• 给我一个数组［1，2，5，10，20，50，100］，可以从里面取若干个数，要求得出和为100的不同取法有多少？
【经典面试题】单链表的常见面试题
01-20
文章目录求单链表中有效节点的个数查找单链表中倒数第k个节点【新浪面试题】单链表的反转【腾讯面试题】从尾到头打印单链表【百度面试题，要求方式1：反向遍历。方式2：Stack栈】 单链表的常见面试题有如下： 1.求单链表中有效节点的个数 2.查找单链表中倒数第k个节点【新浪面试题】 3.单链表的反转【腾讯面试题】 4.从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：Stack栈】 5.合并两个有序的单链表，合并之后的链表依然有序 求单链表中有效节点的个数 思路分析： 思路很简单，直接遍历这个单链表就可以了。 代码实现： //求单链表中有效节点的个数（如若带头节点，则不统计头节点）
程序员面试金典 – 面试题 02.05. 链表求和
12-22
1. 题目 给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果。 示例： 输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295 输出：2 -> 1 -> 9，即912 进阶：假设这些数位是正向存放的，请再做一遍。 示例： 输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295 输出：9 -> 1 -> 2，即912 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/sum-list
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
Linked lists of data structures often meet questions.
面试题快慢链表和快慢指针
08-30
主要介绍了面试题快慢链表和快慢指针的相关资料,需要的朋友可以参考下
牛客小白月赛77 解题报告 | 珂学家 | 反悔堆 + 字符串hash + 二进制递推
han_xue_feng的博客
09-05 149
华子实习ing，lm约了个谈话，实习表现不错，说能免技术面，这是什么意思，往年的话就是直通主管面的意思吗？lm的话可信度如何？提前批，二面刚过，已经约三面了，但是这个状态连面试的勾都没打，好奇怪，有人遇到同样的问题吗？面之前也看了许多面经，跟想象的还是有出入，很多问题忘记了，顺序也是乱的，我努力回忆一下1.自我介绍2.测试的流程3.向页面提交图片出错，从哪几个方面查错。第三次面腾讯的实习生岗位了（HR的秋招转正实习），前两次群面直接挂了，这次进了二面，却连连着几天心态都不好了，有点紧张明明是不太想提前去。
牛客网刷题之链表（一）
k5426244的博客
07-21 542
以下题全部出自牛客网。题目题目考察的知识点链表：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表的分类有单向、双向等多种类型。其中单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。单链表中的数据是以结点来表示的，每个结点的构成：元素 (数据元素 的映象) + 指针 (指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
链表常见面试题分析
GG_Bruse的博客
11-04 6726
接下来我们会从易到难，逐步讲解有关链表的常见面试，部分题目来自Leetcode和牛客
牛客网常见面试题之二叉树操作
m0_67907445的博客
08-16 41
1. 一般的题目都能够用递归的方法解决2. 递归的时候主要进行的也是判空的操作；题目来源牛客网在线编程_编程学习|练习题_数据结构|系统设计题库。
c语言编程题之链表操作设计链表.zip
03-30
c语言 c语言编程题之链表操作设计链表
c语言编程题之链表操作回文链表.zip
03-30
c语言 c语言编程题之链表操作回文链表
c语言编程题之链表操作链表的中间节点.zip
04-02
c语言 c语言编程题之链表操作链表的中间节点
牛客网试题+答案分析+大牛面试经验（4）
WangY.H
04-27 586
（1）以下数据结构中哪一个是非线性结构？ ( ) A、队列 B、栈 C、线性表 D、二叉树 答案：D 解析： 知识点一：根据数据元素之间关系的不同特性，通常有下列 4 类基本结构： a) 集合 b) 线性结构 c) 树形结构 d) 图状结构或网状结构 知识点二：数据的逻辑结构分为线性结构和非线性结构。 ...
牛客网《剑指offer》题解--Java版
qq_40903237的博客
07-23 2516
目录 1、二维数组中的查找 1.1 知识点和限制条件 1.2题目描述 1.3 代码段 2、替换空格 2.1 知识点和限制条件 2.2 题目描述 2.3 代码段 3、从尾到头打印链表 3.1知识点和限制条件 3.2题目描述 3.3代码段 3.4 思路解析 4、重建二叉树 4.1知识点和限制条件 4.2题目描述 4.3 代码段 4.4 ...
#每日一题合集#牛客JZ34-JZ43
vircorns的博客
09-10 144
每日编程练习牛客网，2022.9.1-2022.9.10
jar包增量更新分析
junlaiyan的专栏
05-16 241
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 797
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
java实现拼图小游戏
monkey108的博客
05-16 607
本文主要提供用java实现的拼图小游戏源代码。
ArrayList常见面试题
07-28
ArrayList 是 Java 中常用的动态数组，常见的面试题有： 1. ArrayList 和普通数组的区别是什么？ 答：ArrayList 是动态数组，它可以根据需要自动调整大小，而普通数组的大小是固定的。 2. 如何创建一个 ArrayList...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值