链表——面试必刷TOP101

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量58 收藏
点赞数
分类专栏： 题目记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmm18323188267Ella/article/details/124583558
版权

链表

BM1 反转链表

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

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

}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre=null,cur=head;
        while(cur!=null){
            ListNode tmp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
}

public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode cur=ReverseList(head.next);
        head.next.next=head;
        head.next=null;
        return cur;
    }
}

BM2 链表内指定区间反转

import java.util.*;

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

public class Solution {

    public ListNode reverseBetween (ListNode head, int m, int n) {
        ListNode dum=new ListNode(0);
        dum.next=head;
        ListNode g=dum,p=head;
        for(int i=0;i<m-1;i++){
            p=p.next;
            g=g.next;
        } 
        for(int i=0;i<n-m;i++){
            ListNode removed=p.next;
            p.next=p.next.next;
            removed.next=g.next;
            g.next=removed;
        }
        return dum.next;
    }
}

BM3 链表中的节点每k个一组翻转

import java.util.*;

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

public class Solution {

    public ListNode reverseKGroup (ListNode head, int k) {
        ListNode dum=new ListNode(0);
        dum.next=head;
        ListNode pre=dum,end=dum;
        while(end.next!=null){
            for(int i=0;i<k && end!=null;i++) end=end.next;
            if(end==null) break;
            ListNode second=end.next;
            end.next=null;
            ListNode start=pre.next;
            pre.next=reverseList(start);
            start.next=second;
            pre=start;
            end=start;
        }
        return dum.next;
    }
    private ListNode reverseList(ListNode head){
        ListNode pre=null,cur=head;
        while(cur!=null){
            ListNode tmp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
}

BM4 合并两个排序的链表

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode l1,ListNode l2) {
        ListNode dum=new ListNode(0),cur=dum;
        while(l1!=null && l2!=null){
            if(l1.val<=l2.val){
                cur.next=l1;
                l1=l1.next;
            }else{
                cur.next=l2;
                l2=l2.next;
            }
            cur=cur.next;
        }
        cur.next=l1!=null?l1:l2;
        return dum.next;
    }
}

BM5 合并k个已排序的链表

import java.util.*;
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
       return merge(lists,0,lists.size()-1);
    }
    private ListNode merge(ArrayList<ListNode> lists,int l,int r){
        if(l==r)return lists.get(l);
        if(l>r) return null;
        int m=(l+r)/2;
        return mergeTwoList(merge(lists,l,m),merge(lists,m+1,r));
    }
     public ListNode mergeTwoList(ListNode l1,ListNode l2){
        ListNode dum=new ListNode(0),cur=dum;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val){
                cur.next=l1;
                l1=l1.next;
            }else{
                cur.next=l2;
                l2=l2.next;
            }
            cur=cur.next;
        }
        cur.next=l1==null?l2:l1;
        return dum.next;
    }
}

BM6 判断链表中是否有环

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

BM7 链表中环的入口结点

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

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

    public ListNode EntryNodeOfLoop(ListNode head) {
        ListNode fast=head,slow=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;
        fast=head;
        while(slow!=fast){
            slow=slow.next;
            fast=fast.next;
        }
        return fast;
    }
}

BM8 链表中倒数最后k个结点

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    public ListNode FindKthToTail (ListNode head, int k) {
        ListNode first=head,second=head;
        for(int i=0;i<k;i++){
            if(first==null) return null;
            first=first.next;
        } 
        while(first!=null){
            first=first.next;
            second=second.next;
        }
        return second;
    }
}

BM9 删除链表的倒数第n个节点

import java.util.*;

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

public class Solution {

    public ListNode removeNthFromEnd (ListNode head, int k) {
        ListNode dum=new ListNode(0);
        dum.next=head;
        ListNode first=head,second=dum;
        for(int i=0;i<k;i++){
            if(first==null) return null;
            first=first.next;
        }
        while(first!=null){
            first=first.next;
            second=second.next;
        }
        second.next=second.next.next;
        return dum.next;
    }
}

BM10 两个链表的第一个公共结点

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode p1, ListNode p2) {
        ListNode head1=p1,head2=p2;
        while(p1!=p2){
            p1=p1!=null?p1.next:head2;
            p2=p2!=null?p2.next:head1;
        }
        return p1;
    }
}

BM11 链表相加(二)

import java.util.*;

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

public class Solution {

    public ListNode addInList(ListNode l1, ListNode l2) {
        Deque<Integer> stack1 = new LinkedList<>();
        Deque<Integer> stack2 = new LinkedList<>();
        while (l1 != null) {
            stack1.push(l1.val);
            l1 = l1.next;
        }
        while (l2 != null) {
            stack2.push(l2.val);
            l2 = l2.next;
        }
        int carry = 0;
        ListNode res = null;
        while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
            int a = stack1.isEmpty() ? 0 : stack1.pop();
            int b = stack2.isEmpty() ? 0 : stack2.pop();
            int sum = a + b + carry;
            carry = sum / 10;
            ListNode curnode = new ListNode(sum%10);
            curnode.next = res;
            res = curnode;
        }
        return res;
    }
}

BM12 单链表的排序

import java.util.*;

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

public class Solution {

    public ListNode sortInList(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode fast=head,slow=head;
        while(fast.next!=null&&fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        ListNode l2=slow.next;
        slow.next=null;
        ListNode l1=sortInList(head);
        l2=sortInList(l2);

        ListNode dum=new ListNode(0),cur=dum;
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                cur.next=l1;
                l1=l1.next;
            }else{
                cur.next=l2;
                l2=l2.next;
            }
            cur=cur.next;
        }
        cur.next=l1!=null?l1:l2;
        return dum.next;
    }
}

BM13 判断一个链表是否为回文结构

import java.util.*;

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

public class Solution {

    public boolean isPail (ListNode head) {
        ListNode fast=head,slow=head;
        while(fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        ListNode l2=slow.next;
        slow.next=null;
        l2=reverseList(l2);
        while(head!=null&&l2!=null){
            if(head.val!=l2.val) return false;
            head=head.next;
            l2=l2.next;
        }
        slow.next=reverseList(l2);
        return true;
    }
    private ListNode reverseList(ListNode head){
        ListNode pre=null,cur=head;
        while(cur!=null){
            ListNode tmp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
}

BM14 链表的奇偶重排

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {

    public ListNode oddEvenList (ListNode head) {
        if(head==null) return null;
        ListNode oddHead=head,evenHead=head.next;
        ListNode odd=head,even=head.next;
        while(even != null && even.next != null){
            odd.next=even.next;
            odd=odd.next;
            even.next=odd.next;
            even=even.next;
        }
        odd.next=evenHead;
        return oddHead;
    }
}

BM15 删除有序链表中重复的元素-I

import java.util.*;

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

public class Solution {

    public ListNode deleteDuplicates (ListNode head) {
        if(head==null) return null;
        ListNode cur=head;
        while(cur!=null && cur.next != null){
            if(cur.val==cur.next.val) cur.next=cur.next.next;
            else cur=cur.next;
        }
        return head;
    }
}

BM16 删除有序链表中重复的元素-II

import java.util.*;

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

public class Solution {

    public ListNode deleteDuplicates (ListNode head) {
        ListNode dum=new ListNode(0),cur=dum;
        dum.next=head;
        while(cur.next!=null && cur.next.next!=null){
            if(cur.next.val==cur.next.next.val){
                int x=cur.next.val;
                while(cur.next != null && cur.next.val==x)cur.next=cur.next.next;
            }else cur=cur.next;
        }
        return dum.next;
    }
}
yy的旅行日志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
应对嵌入式校招面试手撕之——链表
iamsohard的博客
09-09 835
笔者投的是嵌入式软件岗，发现手撕代码难度上比软件开发岗是要简单一些的，基本都是leetcode的medeium和easy的水平，基本难的算法不会考，集中在字符串处理和链表，现在把一些常见的链表题做一下。(以下题目均用c++，在类函数里实现) 1.leetcode 21 合并两个有序链表 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 这个题有两种算法，一种是常规算法，一种是递归算法，后者写出来感觉牛逼一点，但是容易出错。 方法一： /** *
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; ...
牛客面试必刷TOP101——链表
weixin_42486554的博客
05-01 908
反转链表 链表内指定区间反转 链表中的节点每k个一组翻转 合并两个有序链表 合并K个有序链表 判断链表中是否有环 链表中环的入口结点 链表中倒数最后k个结点 删除链表的倒数第n个节点 两个链表的第一个公共结点 链表相加(二) 单链表的排序 判断一个链表是否为回文结构 链表的奇偶重排 删除有序链表中重复的元素-I 删除有序链表中重复的元素-II 反转链表 class Solution: def ReverseList(self , head: ListNode) -> ListNode:
【牛客】面试必刷TOP101——01链表
lsz20000813的博客
04-21 673
BM1 反转链表 描述 给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 数据范围： 0≤n≤1000 要求：空间复杂度 O(1)，时间复杂度 O(n) 。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： 示例1 输入：{1,2,3} 返回值：{3,2,1} 示例2 输入：{} 返回值：{} 说明： 空链表则输出空 我的思路： 初始化：3个指针
牛客面试必刷101——链表
sun_0228的博客
04-25 93
牛客面试必刷——链表
牛客网面试必刷TOP101——链表（一）
qq_54092118的博客
09-21 143
遍历过去就可以了。i++;j
牛客面试必刷TOP101——Day1
瓜是西瓜的瓜的博客
05-10 415
前段时间比较懒散，给自己定下的刷题任务只坚持了几点就被我无限期“鸽置”了，希望使用写文章的方式记录解题过程，记录思路。方便自己倒回来看，也方便自己工作之后，晚上emo的时候倒回来看看曾经自己做过的努力和尝试。这个专栏可能会随便一点吧，主要是作为记录，然后才是笔记。大概就是这样。
牛客网面试必刷TOP101——链表（二）
qq_54092118的博客
09-24 153
【代码】牛客网面试必刷TOP101——链表（二）
牛客面试必刷101代码总结【python】
Anthony_hit的博客
04-15 1807
牛客面试题必刷101代码总结
LeetCode题目笔记——面试题 02.05. 链表求和
一个苦逼研究僧的博客
12-27 141
LeetCode面试题02.05.链表求和
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
难度：简单 一、题目描述： 二、解题分析： 1、leetcode解析 2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): ... def reverseList(self, head: ...
数组和链表——精选推荐 数组和链表.pdf
04-18
数组和链表——精选推荐 数组和链表.pdf
《剑指Offer》刷题笔记——面试题06. 从尾到头打印链表
01-21
难度：简单 一、题目描述： 二、解题分析： 1、剑指解析： 2、代码实现： I、辅助栈 from typing import List ###### 代码主体 ###### class Solution: def reversePrint(self, head: ListNode) -> List[int]: ...
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1005
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 801
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 294
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1076
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
高阶-5 链表——统计节点个数 定义函数，遍历一个不带头结点的链表，统计链表上的节点个数
06-10
好的，根据您的要求，我理解您需要一个 C++ 函数，能够统计一个不带头结点的链表上的节点个数。那么，以下是一个示例代码： ```cpp int countNodes(ListNode* head) { int count = 0; ListNode* cur = head; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值