大数据最新【算法合集】学习算法第一天（链表篇）_给定一个单链表头结点(1)，看完没有不懂的

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

        //断开链表，要记录后续一个
        ListNode temp = cur.next;
        //当前的next指向前一个
        cur.next = pre;
        //前一个更新为当前
        pre = cur;
        //当前更新为刚刚记录的后一个
        cur = temp;
    }
    return pre;}

}

### 


## 链表内指定区间反转


**💎描述**



> 
> 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)O(1)。  
>  例如：  
>  给出的链表为 NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,  
>  返回  NULL1→4→3→2→5→NULL.  
>   
> 
> 
> 数据范围： 链表长度 0 < size ≤ 1000，0 < size0 < m ≤ n ≤ size，链表中每个节点的值满足 ∣val∣≤1000
> 
> 
> **要求：**时间复杂度 O(n) ，空间复杂度 O(n)
> 
> 
> **进阶：**时间复杂度 O(n)，空间复杂度 O(1)
> 
> 
> 


**💎示例1**



> 
> **输入：**{1,2,3,4,5},2,4
> 
> 
> **返回值：**{1,4,3,2,5}
> 
> 
> 


**💎示例2**



> 
> **输入：**{5},1,1
> 
> 
> **返回值：**{5}
> 
> 
> 


### 


### 题解代码

import java.util.*;
public class Solution {
public ListNode reverseBetween (ListNode head, int m, int n) {
//加个表头 fast-template
ListNode res = new ListNode(-1);
res.next = head;
//前序节点
ListNode pre = res;
//当前节点
ListNode cur = head;
//找到m
for (int i = 1; i < m; i++) {
pre = cur;
cur = cur.next;
}
//从m反转到n
for (int i = m; i < n; i++) {
ListNode temp = cur.next;
cur.next = temp.next;
temp.next = pre.next;
pre.next = temp;
}
//返回去掉表头
return res.next;}
}

## 链表的奇偶重排


**💕描述**



> 
> 给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。
> 
> 
> 注意是节点的编号而非节点的数值。
> 
> 
> 数据范围：节点数量满足 0 ≤ n ≤ 10^5，节点中的值都满足 0 ≤ val ≤ 1000
> 
> 
> 要求：空间复杂度 O(n)，时间复杂度 O(n)
> 
> 
> 


**💕示例1**



> 
> **输入：**{1,2,3,4,5,6}
> 
> 
> **返回值：**{1,3,5,2,4,6}
> 
> 
> 


**💕说明：**



> 
> 1->2->3->4->5->6->NULL
> 
> 
> 重排后为
> 
> 
> 1->3->5->2->4->6->NULL
> 
> 
> 


**💕示例2**



> 
> **输入：**{1,4,6,3,7}
> 
> 
> **返回值：**{1,6,7,4,3}
> 
> 
> 


**💕说明：**



> 
> 1->4->6->3->7->NULL
> 
> 
> 重排后为
> 
> 
> 1->6->7->4->3->NULL  
>  奇数位节点有1,6,7，偶数位节点有4,3。重排后为1,6,7,4,3
> 
> 
> 


**💕备注：**



> 
> 链表长度不大于200000。每个数范围均在int内。
> 
> 
> 



### 题解代码

import java.util.*;
public class Solution {
public ListNode oddEvenList (ListNode head) {
//如果链表为空，不用重排 fast-template
if(head == null)
return head;
//even开头指向第二个节点，可能为空
ListNode even = head.next;
//odd开头指向第一个节点
ListNode odd = head;
//指向even开头
ListNode evenhead = even;
while(even != null && even.next != null){
//odd连接even的后一个，即奇数位
odd.next = even.next;
//odd进入后一个奇数位
odd = odd.next;
//even连接后一个奇数的后一位，即偶数位
even.next = odd.next;
//even进入后一个偶数位
even = even.next;
}
//even整体接在odd后面
odd.next = evenhead;
return head;}
}

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


**🎉描述**



> 
> 将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表  
>  如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样  
>  你不能更改节点中的值，只能更改节点本身。
> 
> 
> 数据范围： 0 ≤ n ≤ 2000 ， 1 ≤ k ≤ 2000 ，链表中每个元素都满足 0 ≤ val ≤ 1000  
>  要求空间复杂度 O(1)，时间复杂度 O(n)
> 
> 
> 


**🎉例如：**



> 
> 给定的链表是 1→2→3→4→5
> 
> 
> 对于 k = 2, 你应该返回 2→1→4→3→5
> 
> 
> 对于 k = 3, 你应该返回 3→2→1→4→5
> 
> 
> 


**🎉示例1**



> 
> **输入：**{1,2,3,4,5},2
> 
> 
> **返回值：**{2,1,4,3,5}
> 
> 
> 


**🎉示例2**



> 
> **输入：**{},1
> 
> 
> **复制返回值：**{}
> 
> 
> 


### 


### 

import java.util.*;
public class Solution {
public ListNode reverseKGroup (ListNode head, int k) {
//找到每次翻转的尾部 fast-template
ListNode tail = head;

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

c-1715444586018)]
[外链图片转存中…(img-JhMlSSrh-1715444586019)]
[外链图片转存中…(img-TWbiZOHy-1715444586019)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取