先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024b (备注Java)
正文
}*/
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head==null){
return null;
}
if(k<0){
return null;
}
ListNode fast = head;
ListNode slow = head;
while( k-1 != 0){
if(fast.next==null){
return null;
}
fast = fast.next;
k–;
}
while(fast.next != null) {
fast = fast.next;
slow = slow.next;
}
return slow;
}
}
第五题 : 合并两个有序链表
======================================================================================
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
解题思路:
1.这题可以引用一个傀儡节点newHead,让newHead的值为-1,指向的地址为null;
2.让headA.val与headB.val进行比较
如果headA.val<headB.val 就让cur.next指向headA的地址,让headA指向下一个节点,cur就指向cur.next;
如果headA.val>=headB.val,就让cur.next指向headB的地址,让headB指向下一个节点,cur就指向cur.next;
3.循环此步骤,当headA为空或者headB为空的时候,结束循环
4.如果循环结束还有节点没连上,所以就让cur.next连上剩余的节点,判断是哪个head为空时,循环结束.此时看题目A末尾的数据在B之前,所以让判断headA的语句放在前面,因此也解决了链表为空的情况.
画图解析:
具体代码:
/**
-
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 headA, ListNode headB) {
ListNode newHead = new ListNode(-1);
ListNode cur = newHead;
while(headA != null && headB !=null) {
if(headA.val < headB.val){
cur.next = headA;
headA = headA.next;
cur = cur.next;
}else{
cur.next = headB;
headB = headB.next;
cur = cur.next;
}
}
if(headA != null){
cur.next = headA;
}
if(headB != null){
cur.next = headB;
}
return newHead.next;
}
}
第六题 : 链表分割
========================================================================================
描述
现有一链表的头指针 ListNode* pHead,给一定值x,编写一段代码将所有小于x的结点排在其余结点之前,且不能改变原来的数据顺序,返回重新排列后的链表的头指针。
解题思路:
1.可以用两个链表分别来表示,小于x的 和 大于x的,再将2个链表连起来即可.
2. 两个链表分别用bs表示第一个链表的头,be表示第一个链表的尾,as表示第二个链表的头,ae表示第二个链表的尾.
3.引用一个cur指向head,比较cur.val与x的值,如果小于x的时候,bs,be就指向cur,如果大于x的时候,as,ae就指向cur.这一步只执行一次,可以通过判断bs是否为空,as是否为空来解决.
4.第一次的执行之后,就进入else,如果小于x的时候,be.next=cur,be=be.next;如果大于x的时候,ae.next=cur,ae=ae.next;
5.然后要连接2个链表;
有3种情况
①bs为空,返回as
②bs不为空,连接be,as,即be.next=as.next;
③当ae不为空,ae指向的地址可能不为空,所以要ae.next=null;
画图解析:
具体代码:
import java.util.*;
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Partition {
public ListNode partition(ListNode head, int x) {
// write code here
ListNode bs = null;
ListNode be = null;
ListNode as = null;
ListNode ae = null;
ListNode cur = head;
while(cur != null) {
if(cur.val<x){
if(bs==null){
bs=cur;
be=cur;
}else {
be.next = cur;
be = be.next;
}
}
else{
if(as==null){
as=cur;
ae=cur;
}else{
ae.next = cur;
ae = ae.next;
}
}
cur = cur.next;
}
if(bs==null){
return as;
}
be.next = as;
if(as!=null){
ae.next = null;
}
return bs;
}
}
第七题 : 删除链表中重复的结点
====================================================================================================
描述
在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。 例如,链表 1->2->3->3->4->4->5 处理后为 1->2->5
例如输入{1,2,3,3,4,4,5}时,对应的输出为{1,2,5},对应的输入输出链表如下图所示:
解题思路:
1.引用一个傀儡节点当作头,把去重后的节点连接到傀儡节点上;
2.引用一个tmp指向傀儡节点,引用一个cur指向head;
3.当cur.val == cur.next.val的时候,要让cur=cur.next;当跳过这个节点之后,cur.val还是需要删掉的数据,所以要再cur=cur.next一次才能指向下一个节点,
4.重复的数可能有2个3个或者多个,可以用循环来解决
5.当cur.val != cur.next.val的时候,让tmp指向cur的地址,tmp就到tmp.next节点上,cur就移到下一个节点.
6.由代码看出来,在判断cur.next.val的时候,cur.next可能为空,所以要在判断时,加上cur.next != null
7.最后tmp节点所指向的地址可能不为空,所以在最后要让tmp.next=null;
画图解析:
代码实现:
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode deleteDuplication(ListNode head) {
ListNode newHead = new ListNode(-1);
ListNode tmp = newHead;
ListNode cur = head;
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.next;
}else{
tmp.next = cur;
tmp=tmp.next;
cur = cur.next;
}
}
tmp.next = null;
return newHead.next;
}
}
第八题 : 链表的回文结构
===============================================================================================
描述
对于一个链表,请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法,判断其是否为回文结构。
给定一个链表的头指针A,请返回一个bool值,代表其是否为回文结构。保证链表长度小于等于900。
解题思路:
1.判断链表是否为空
2.找中间节点 定义两个引用fast和slow,一个走两步,一个走一步
3.反转,定义一个引用cur等于slow的下一个节点的地址,然后让cur的下一个节点地址等于slow的地址,再让slow等于cur的节点,这时cur.next被修改了,所以在前面要定义一个curNext记录cur.next的地址,最后让cur=curNext.循环直到,cur=null结束
4.判断回文
①奇数 head=slow
②偶数 head.next=slow
画图解析:
代码实现:
import java.util.*;
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class PalindromeList {
public boolean chkPalindrome(ListNode head) {
//链表为空
if(head == null) {
return true;
}
//1.找中间节点
ListNode fast = head;
ListNode slow = 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;
}
//判断回文
while(head != slow){
//偶数情况
if(head.next==slow){
return true;
}
if(head.val != slow.val){
return false;
}
head = head.next;
slow = slow.next;
}
return true;
}
}
第九题 : 相交链表
=======================================================================================
Leetcode 160:
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
图示两个链表在节点 c1 开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
解题思路:
1.首先分析两个链表相交的形状,只能为Y形状
2.再分析相交时,是val域相同还是next域相同
3.因为要保持原始结构,所以要定义两个引用pl,ps
4.pl始终指向最长的链表,ps始终指向最短的链表
5.先让pl指向headA,ps指向headB,求headA和headB链表的长度,lenA和lenB
6.求差值len=lenA-lenB,如果len<0的时候,让pl指向headB,ps指向headA,
7.如果len>=0的时候,pl和ps已经走到最后,所以要让他们重新指向开头
8.然后让pl走差值步,这样在同时走的时候next域才会相等时
8.最后让循环判断pl是否等于ps,相等时,返回pl即可
9.最开始判断链表是否为空,为空返回null;
画图解析:
代码实现:
/**
-
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 pl = headA;
ListNode ps = headB;
int lenA = 0;
int lenB = 0;
while(pl != null) {
lenA++;
pl = pl.next;
}
while(ps != null) {
lenB++;
ps = ps.next;
}
int len = lenA - lenB;//差值步
//len小于0的时候要让pl指向最长的,ps指向最短的
if(len < 0) {
pl = headB;
ps = headA;
len = lenB - lenA;
}else{
//让pl和ps重新指向头节点
pl = headA;
ps = headB;
}
//让pl走差值步
while(len != 0) {
pl = pl.next;
len–;
}
while(pl != ps) {
pl = pl.next;
ps = ps.next;
}
return pl;
}
}
第十题 : 环形链表
========================================================================
Leetcode 141:
给定一个链表,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
如果链表中存在环,则返回 true 。 否则,返回 false 。
进阶:你能用 O(1)(即,常量)内存解决此问题吗?
解题思路:
1.先判断链表是否为空,为空返回null
2.定义两个引用,一个快一个慢,让fast走两步,slow走一步,这样总会相遇.
3.相遇了fast=slow的时候,就是换装链表
画图解析:
代码实现:
/**
-
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){
return false;
}
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if(fast == slow) {
return true;
}
}
return false;
}
}
十一题 : 环形链表 II
=================================================================================
给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。
为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。
说明:不允许修改给定的链表。
进阶:你是否可以使用 O(1) 空间解决此题?
示例 1:
解题思路:
1.判断链表是否为空,为空直接返回null
2.定义两个引用fast和slow,fast速度是slow的两倍,他们相遇时,就是相遇点
3.设起始点为A,入口点为B,相遇点为C.设起始点到入口点的距离A->B为X,入口点到相遇点的距离B->C是Z,设相遇点C到入口点B的距离C->B为Y.
4.slow走的路程为X+Z,fast走的路程为X+Z+N*(Z+Y)
5.因为fast是slow速度的两倍,所以路程也是两倍所以2(X+Z)=X+Z+N*(X+Y)
6.化简X = (N-1)*(Z+Y)+Y 表示的是,从起始点到入口点的距离正好 等于 从相遇点开始走(N-1)个环的距离
7.结论:一个从头走,一个从相遇点走,每个人走一步,相遇时,就是入口点.
画图解析:
代码实现:
/**
-
Definition for singly-linked list.
-
class ListNode {
-
int val;
-
ListNode next;
-
ListNode(int x) {
最后
小编精心为大家准备了一手资料
以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术
【附】架构书籍
- BAT面试的20道高频数据库问题解析
- Java面试宝典
- Netty实战
- 算法
BATJ面试要点及Java架构师进阶资料
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
表示的是,从起始点到入口点的距离正好 等于 从相遇点开始走(N-1)个环的距离**
7.结论:一个从头走,一个从相遇点走,每个人走一步,相遇时,就是入口点.
画图解析:
代码实现:
/**
-
Definition for singly-linked list.
-
class ListNode {
-
int val;
-
ListNode next;
-
ListNode(int x) {
最后
小编精心为大家准备了一手资料
[外链图片转存中…(img-PhAoHQVN-1713473093498)]
[外链图片转存中…(img-GtmY7DoU-1713473093498)]
以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术
【附】架构书籍
- BAT面试的20道高频数据库问题解析
- Java面试宝典
- Netty实战
- 算法
[外链图片转存中…(img-Tkb5aBBC-1713473093499)]
BATJ面试要点及Java架构师进阶资料
[外链图片转存中…(img-73FStIvL-1713473093500)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
[外链图片转存中…(img-dydwzjVZ-1713473093501)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!