文章目录
1 LC:86. 分隔链表
原题位置:86. 分隔链表
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，
使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。
提示：
链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200
类似于快排的思路,小于x的节点拼接到一块;大于等于x的节点拼接到一块;
然后最终再把两条链表拼接;
class Solution {
public ListNode partition(ListNode head, int x) {
if(head == null) return null;
//按照题目的要求实际就像快排,大的放一堆,小的放一堆;
ListNode small = new ListNode(0);
ListNode big = new ListNode(0);
ListNode smallHead = small;
ListNode bigHead = big;
while(head!=null){
//若当前的节点较小,就往小堆拼;
if(head.val < x){
smallHead.next = head;
smallHead = smallHead.next;
}else{
bigHead.next = head;
bigHead = bigHead.next;
}
head = head.next;
}
//最终拼到一块;
bigHead.next = null;
smallHead.next = big.next;
return small.next;
}
}
2 LC:206. 反转链表 [简单]
原题位置:206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
非常简单的反转链表思路;先构建一个空节点,依次将链表的节点挂接到后面即可;
class Solution {
public ListNode reverseList(ListNode head) {
//简易反转;
ListNode preNode = null;
while(head!=null){
ListNode tempNode = head.next;
head.next = preNode;
preNode = head;
head = tempNode;
}
return preNode;
}
}
3 LC:92. 反转链表 II [中等]
原题位置:92. 反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。
请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
提示：
链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n
这里处理的话,相对于麻烦一点,因为他要对一段指定区间的节点进行反转处理;
那么就先找到待反转节点的前置节点;然后进行区间内的反转;
class Solution {
public ListNode reverseBetween(ListNode head, int left, int right) {
if(head==null||head.next==null){
return head;
}
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode preNode = dummy;
//将前置指针放到待反转节点的前一个位置;
for(int i =0;i<left-1;i++){
preNode = preNode.next;
}
//标记待反转的第一个节点;
ListNode curNode = preNode.next;
//反转时的临时节点;
ListNode tempNode;
for(int i =0;i<right-left;i++){
tempNode = curNode.next;
//当前节点接到隔着的那个节点上;
curNode.next = tempNode.next;
//临时节点接到当前节点前;
tempNode.next = preNode.next;
//将临时节点的位置确认到前置节点后;
preNode.next = tempNode;
}
return dummy.next;
}
}
4 LC:109. 有序链表转换二叉搜索树
原题位置:109. 有序链表转换二叉搜索树
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定的有序链表： [-10, -3, 0, 5, 9],
一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：
0
/ \
-3 9
/ /
-10 5
这里使用递归思路容易理解;
快慢指针找到链表的中心节点,作为根结点;
由于这份链表正好是升序排序的,那么左右分离;递归左右子树即可;
class Solution {
public TreeNode sortedListToBST(ListNode head) {
//排除特殊用例;
if(head==null) return null;
if(head.next == null) return new TreeNode(head.val);
//快慢指针做法;
ListNode fast = head;
ListNode slow = head;
//用于分隔链表;
ListNode prefix = null;
while(fast!=null && fast.next!=null){
fast = fast.next.next;
prefix = slow;
slow = slow.next;
}
//这里慢指针就是当前根结点;
TreeNode root = new TreeNode(slow.val);
//递归出右子树;
root.right = sortedListToBST(slow.next);
//此时分隔链表;
prefix.next = null;
//递归出左子树;
root.left = sortedListToBST(head);
return root;
}
}
5 LC:143. 重排链表
原题位置:143. 重排链表
给定一个单链表 L 的头节点 head ，单链表 L表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
提示:
- 链表的长度范围为 [1, 5 * 104]
- 1 <= node.val <= 1000
处理比较简单,先用快慢指针将链表分开,然后将后半部分的链表反转处理;
然后将后半部分链表逐个插入到前面的链表中;
class Solution {
public void reorderList(ListNode head) {
//排除特殊用例;
if(head == null||head.next==null){
return;
}
ListNode fast = head;
ListNode slow = head;
while(fast!=null && fast.next!=null){
fast = fast.next.next;
slow = slow.next;
}
//分隔链表;
ListNode twoHead = slow.next;
slow.next = null;
//对于第二段链表进行反转处理;
fast = reverseList(twoHead);
//慢指针重置;
slow = head;
//将第二份链表插入到前面的链表中;
while(fast!=null){
ListNode temp = fast.next;
fast.next = slow.next;
slow.next = fast;
//快慢指针向后取值;
slow = fast.next;
fast = temp;
}
}
//反转链表;
public ListNode reverseList(ListNode node){
ListNode dummy = null;
while(node!=null){
ListNode temp = node.next;
node.next = dummy;
dummy = node;
node = temp;
}
return dummy;
}
}
6 LC:147. 对链表进行插入排序
给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。
插入排序 算法的步骤:
插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。
下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。
每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。
对链表进行插入排序。
提示：
列表中的节点数在 [1, 5000]范围内
-5000 <= Node.val <= 5000
class Solution {
public ListNode insertionSortList(ListNode head) {
//排除特例;
if(head == null || head.next==null){
return head;
}
ListNode dummy = new ListNode(0);
ListNode curNode = head;
while(curNode!=null){
//先标记存储后一位节点,便于后续使用;
ListNode tempNode = curNode.next;
//前置节点,每次都重置;
ListNode preNode = dummy;
while(preNode.next!=null && preNode.next.val<curNode.val){
preNode = preNode.next;
}
//链接;
curNode.next = preNode.next;
preNode.next = curNode;
//向后移动;
curNode = tempNode;
}
return dummy.next;
}
}
7 LC:148. 排序链表
原题位置:148. 排序链表
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
提示：
链表中节点的数目在范围 [0, 5 * 104] 内
-10^5 <= Node.val <= 10^5
比较容易理解的递归思路;
分隔链表后,再归并到一份链表中;
class Solution {
public ListNode sortList(ListNode head) {
//特例排除;
if(head == null || head.next==null){
return head;
}
//使用快慢指针,找到链表的中点;
ListNode fast = head;
ListNode slow = head;
while(fast.next != null && fast.next.next != null){
slow = slow.next;
fast = fast.next.next;
}
//此时准备分隔链表;
ListNode twoHead = slow.next;
slow.next = null;
//采用递归的方式对两段链表处理;
ListNode oneList = sortList(head);
ListNode twoList = sortList(twoHead);
//合并处理;
return merge(oneList,twoList);
}
//合并两段链表;
public ListNode merge(ListNode l1,ListNode l2){
if(l1 == null){
return l2;
}
if(l2 == null){
return l1;
}
//采用第三方链表做法;
ListNode res = new ListNode(0);
ListNode curNode = res;
while(l1!=null && l2!=null){
if(l1.val<=l2.val){
curNode.next = l1;
l1 = l1.next;
}else{
curNode.next = l2;
l2 = l2.next;
}
curNode = curNode.next;
}
//注意可能有链表没结束;
if(l1!=null){
curNode.next = l1;
}
if(l2!=null){
curNode.next = l2;
}
return res.next;
}
}
8 LC:203. 移除链表元素
原题位置:203. 移除链表元素
给你一个链表的头节点 head 和一个整数 val ，
请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50
递归思路移出
class Solution {
public ListNode removeElements(ListNode head, int val) {
//排除特例;
if(head == null){
return null;
}
head.next = removeElements(head.next,val);
//若相等,则返回后一个结点即可;
if(head.val == val){
return head.next;
}else{
return head;
}
}
}
非递归方式,需要遍历链表,找到匹配的目标节点;脱离链表即可;
class Solution {
public ListNode removeElements(ListNode head, int val) {
//排除特例;
if(head == null){
return null;
}
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode curNode = dummy;
//注意,最后还要返回新的头结点,
while(curNode.next!=null){
//匹配目标值;
if(curNode.next.val == val){
ListNode delNode = curNode.next;
curNode.next = delNode.next;
delNode.next = null;
}else{
curNode = curNode.next;
}
}
return dummy.next;
}
}
9 LC:234. 回文链表
原题位置:234. 回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。
如果是，返回 true ；否则，返回 false 。
提示：
链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9
具体思路,找到链表中心点;
注意区分链表长度为奇数个时,需要将中间的一个节点分到左边;
然后主要是将右半部分链表的节点进行反转;用两个指针;
依次比较左边和右边链表的节点值是否相等;达到判断回文链表的效果;
class Solution {
public boolean isPalindrome(ListNode head) {
//使用快慢指针;找到中心;
ListNode fast = head;
ListNode slow = head;
while(fast!=null && fast.next!=null){
fast = fast.next.next;
slow = slow.next;
}
ListNode twoHead = slow;
//若为奇数长度,则将中心点放到左边的链表中,仅反转右边的链表;
if(fast!=null){
twoHead = slow.next;
}
//反转后半部分链表;
fast = reverse(twoHead);
//重置慢指针;
slow = head;
while(fast!=null){
if(fast.val!=slow.val){
return false;
}
fast = fast.next;
slow = slow.next;
}
return true;
}
//反转链表;
public ListNode reverse(ListNode node){
ListNode preNode =null;
while(node!=null){
ListNode tempNode = node.next;
node.next = preNode;
preNode = node;
node = tempNode;
}
return preNode;
}
}
附:原地删除链表的指定的节点;
注意:无法访问链表的头结点
原题位置: 237. 删除链表中的节点
找到指定删除节点的后一个结点,然后将需要删除节点的值value覆盖,那么删除后面这个结点即可;
class Solution {
public void deleteNode(ListNode node) {
//要删除当前节点,就把后一个结点的值覆盖到这里;
ListNode subNode = node.next;
node.val = subNode.val;
//把下个节点的后继节点接过来;
node.next = subNode.next;
//删除自己;
subNode.next = null;
}
}
10 LC: 328. 奇偶链表
原题位置: 328. 奇偶链表
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，
然后返回重新排序的列表。
第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。
请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。
你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。
提示:
n == 链表中的节点数
0 <= n <= 10^4
-10^6 <= Node.val <= 10^6
和86题的思路很相似;分成两部分链表进行拼接;
注意奇偶索引可以用一个标志数进行判断;
class Solution {
public ListNode oddEvenList(ListNode head) {
//采用分隔链表的思路;
ListNode oddDummy = new ListNode(0);
ListNode evenDummy = new ListNode(0);
//分别的操作节点;
ListNode oddHead = oddDummy;
ListNode evenHead = evenDummy;
//一个计数标志,简易区分奇偶索引;
int num=1;
while(head!=null){
//偶数处理;
if(num%2 == 0){
evenHead.next = head;
evenHead = evenHead.next;
}else{
oddHead.next = head;
oddHead = oddHead.next;
}
num +=1;
head = head.next;
}
//这里注意要对两段链表拼接;
oddHead.next = evenDummy.next;
evenHead.next = null;
return oddDummy.next;
}
}
11 LC:445. 两数相加 II
原题位置:445. 两数相加 II
给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。
它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
提示：
链表的长度范围为 [1, 100]
0 <= node.val <= 9
输入数据保证链表代表的数字无前导 0
和力扣第2题有区别;这里需要反转链表进行相加…
这里采用两个栈,进行处理;
import java.util.Deque;
import java.util.LinkedList;
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//特殊用例;
if(l1==null){return l2;}
if(l2==null){return l1;}
//入栈;
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 sum =0;
ListNode preNode = null;
ListNode curNode ;
//求和;
while(!stack1.isEmpty() || !stack2.isEmpty()){
if(!stack1.isEmpty()){
sum +=stack1.pop();
}
if(!stack2.isEmpty()){
sum +=stack2.pop();
}
//若可进位,则保留余值,否则全保留;
curNode = new ListNode(sum%10);
curNode.next = preNode;
preNode = curNode;
sum /=10;
}
//若最中还需进位;则加个头结点;
if(sum == 1){
ListNode newHead = new ListNode(1);
newHead.next = preNode;
return newHead;
}
return preNode;
}
}
237
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
