目录
BM12 单链表的排序
描述
算法思想：归并排序（递归）
解题思路：
BM13 判断一个链表是否为回文结构
描述
方法一
思路
具体步骤
方法二
思路
BM14 链表的奇偶重排
描述
BM15 删除有序链表中重复的元素
描述
BM12 单链表的排序
- 题目
- 题解(265)
- 讨论(245)
- 排行
- 面经
new
中等 通过率：47.96% 时间限制：2秒 空间限制：256M
知识点链表排序
描述
给定一个节点数为n的无序单链表，对其按升序排序。
数据范围：0≤1000000<n≤100000，保证节点权值在[−109,109][−109,109]之内。
要求：空间复杂度 O(n)，时间复杂度 O(nlogn)
主要思想:递归
算法思想：归并排序（递归）
解题思路：
主要通过递归实现链表归并排序，有以下两个环节：
1、分割 cut 环节： 找到当前链表中点，并从中点将链表断开（以便在下次递归 cut 时，链表片段拥有正确边界）；
使用 fast,slow 快慢双指针法，奇数个节点找到中点，偶数个节点找到中心左边的节点。
找到中点 slow 后，执行 slow.next = None 将链表切断。
递归分割时，输入当前链表左端点 head 和中心节点 slow 的下一个节点 tmp(因为链表是从 slow 切断的)。
cut 递归终止条件： 当head.next == None时，说明只有一个节点了，直接返回此节点
2、合并 merge 环节： 将两个排序链表合并，转化为一个排序链表。
双指针法合并，建立辅助ListNode h 作为头部。
设置两指针 left, right 分别指向两链表头部，比较两指针处节点值大小，由小到大加入合并链表头部，指针交替前进，直至添加完两个链表。
返回辅助ListNode h 作为头部的下个节点 h.next。
时间复杂度 O(l + r)，l, r 分别代表两个链表长度。
3、特殊情况，当题目输入的 head == None 时，直接返回None。
图解：
/**
* @author Diana
* @date 2023/6/21 9:37
*/
public class SortInList {
public ListNode sortInList(ListNode head){
if(head == null || head.next == null)
return head;
ListNode fast = head.next,slow = head;
while(fast != null && fast.next != null){
slow = slow.next;
fast = fast.next.next;
}
ListNode tmp =slow.next;
slow.next = null;
ListNode left = sortInList(head);
ListNode right = sortInList(tmp);
ListNode h = new ListNode(0);
ListNode res = h;
while(left != null && right != null) {
if(left.val < right.val ){
h.next = left;
left = left.next;}else{
h.next = right;
right = right.next;
}
h = h.next;
}
h.next = left != null ? left : right;
return res.next;
}
}
BM13 判断一个链表是否为回文结构
知识点 链表双指针
描述
给定一个链表，请判断该链表是否为回文结构。
回文是指该字符串正序逆序完全一致。
方法一
思路
因为需要判断是否为回文结构，所以要比较头尾的数据，而链表无法随机查询数据，所以可以先将链表转换成list。
具体步骤
-
首先初始化一个list列表；
-
遍历链表，将链表中的值转移至list中；
-
在list中通过比较头尾的值来判断链表是否为回文结构。
-
时间复杂度：，两次遍历；
-
空间复杂度：O(n)，列表存储数据需要的size为n。
import java.util.ArrayList;
import java.util.List;
/**
* @author Diana
* @date 2023/6/21 9:57
*/
public class IsPail {
public boolean isPail(ListNode head){
if(head.next == null){
return true;
}
List<Integer> nums = new ArrayList<Integer>();
while(head != null){
nums.add(head.val);
head=head.next;
}
int i = 0;
int j = nums.size() - 1;
while(i < j){
if(!nums.get(i).equals(nums.get(j))){
return false;
}
++i;
--j;
}
return true;
}
}
方法二
思路
方法一的空间复杂度为O(n)，较大，可以使用快慢指针，快指针的速度为慢指针的两倍，当快指针到达链表尾部时，慢指针到达中间位置，将慢指针之后的部分进行反转，再与前半部分进行比较。
-
时间复杂度：O(n)，遍历链表
-
空间复杂度：常数级空间复杂度O(1)
import java.util.*;
/*
* public class ListNode {
* int val;
* ListNode next = null;
* public ListNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类 the head
* @return bool布尔型
*/
public boolean isPail (ListNode head) {
// write code here
ListNode q= head, p= head;
//通过快慢指针找到中点
while (q != null && q.next != null) {
q = q.next.next;
p = p.next;
}
//如果q不为空，说明链表的长度是奇数个
if (q != null) {
p = p.next;
}
//反转后半部分链表
p = reverse(p);
q = head;
while (p != null) {
//然后比较，判断节点值是否相等
if (q.val != p.val)
return false;
q = q.next;
p = p.next;
}
return true;
}
//反转链表
public ListNode reverse(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode next = head.next;
head.next = prev;
prev = head;
head = next;
}
return prev;
}
}
BM14 链表的奇偶重排
知识点链表排序
描述
给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。注意是节点的编号而非节点的数值。
具体做法：
- step 1：判断空链表的情况，如果链表为空，不用重排。
- step 2：使用双指针odd和even分别遍历奇数节点和偶数节点，并给偶数节点链表一个头。
- step 3：上述过程，每次遍历两个节点，且even在后面，因此每轮循环用even检查后两个元素是否为NULL，如果不为再进入循环进行上述连接过程。
- step 4：将偶数节点头接在奇数最后一个节点后，再返回头部。
要求：空间复杂度 O(n)，时间复杂度 O(n)
import java.util.*;
public class Solution {
public ListNode oddEvenList (ListNode head) {
//如果链表为空，不用重排
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;
}
}
BM15 删除有序链表中重复的元素
描述
删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次
例如：
给出的链表为1→1→21→1→2,返回1→21→2.
给出的链表为1→1→2→3→31→1→2→3→3,返回1→2→31→2→3.
进阶：空间复杂度 O(1)，时间复杂度 O(n)
import java.util.*;
/*
* public class ListNode {
* int val;
* ListNode next = null;
* }
*/
public class Solution {
/**
*
* @param head ListNode类
* @return ListNode类
*/
public ListNode deleteDuplicates (ListNode head) {
// write code here
if (head == null || head.next == null){
return head;
}
ListNode q = head;
while(q != null) {
int cache = q.val;
ListNode p = q.next;
while(p != null && p.val == cache) {
p = p.next;
}
q.next = p;
q = p;
}
return head;
}
}
