指定区间反转
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。
示例 ： 输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5]
头插法
头插法是使用虚拟节点的办法，该思路和链表反转相同，如下。pre相当于[3，6]反转的虚拟节点，反转步骤为：
-
cur.next = next.next
-
next.next = pre.next（不能写cur，pre.next只有未反转时才是cur）
-
pre.next = next
之所以创建虚拟节点是为了防止极端情况[1，N]
整体步骤：
-
创建虚拟节点dummy，pre节点（pre=dummy）
-
循环left-1次使pre位置停在left前一位
-
创建cur节点（反转位置的首位），next节点（cur.next）
-
反转
public static Node reverseBetween(Node head, int left, int right) {
Node dummyNode = new Node(-1);
dummyNode.next = head;
Node pre = dummyNode;
for (int i = 0; i < left - 1; i++) {
pre = pre.next;
}
Node cur = pre.next;
Node next = null;
for (int i = 0; i < right - left; i++) {
next = cur.next;
cur.next = next.next;
next.next = pre.next;
pre.next = next;
}
return dummyNode.next;
}穿针引线法
先确定好反转的部分，图中left到right之间，然后将三段链表拼起来
步骤分析：
-
创建虚拟头节点，为了避免头节点变化混乱
-
从虚拟节点走lef-1步，得到left前一个节点pre
-
从pre走right-left+1步，来到right节点
-
拿到 left节点和succ节点
-
设置pre.next和right.next为null（若不断开链接，succ也会参与反转并且会造成闭环）
-
将left到right部分反转
-
链接链表 pre.next = right; left.next = succ;
public ListNode reverseBetween(ListNode head, int left, int right) {
// 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
ListNode dummyNode = new ListNode(-1);
dummyNode.next = head;
ListNode pre = dummyNode;
// 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
// 建议写在 for 循环里，语义清晰
for (int i = 0; i < left - 1; i++) {
pre = pre.next;
}
// 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
ListNode rightNode = pre;
for (int i = 0; i < right - left + 1; i++) {
rightNode = rightNode.next;
}
// 第 3 步：切出一个子链表
ListNode leftNode = pre.next;
ListNode succ = rightNode.next;
// 思考一下，如果这里不设置next为null会怎么样
pre.next = null;
rightNode.next = null;
// 第 4 步：同第 206 题，反转链表的子区间
reverseLinkedList(leftNode);
// 第 5 步：接回到原来的链表中
//想一下，这里为什么可以用rightNode
pre.next = rightNode;
leftNode.next = succ;
return dummyNode.next;
}
private void reverseLinkedList(ListNode head) {
// 也可以使用递归反转一个链表
ListNode pre = null;
ListNode cur = head;
while (cur != null) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
}两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题
示例： 输入：[1, 2, 3, 4] 输出：[2, 1, 4, 3]
思路分析
两两交换需要获取到交换节点的前一个节点才能进行反转的链接，所以要构造一个虚拟节点，然后只需要控制两个交换节点的指针不断后移 >>> 交换即可
public static Node swapPairs(Node head) {
Node dummy = new Node(-1);
dummy.next = head;
Node temp = dummy;
while (temp.next != null && temp.next.next != null) {
Node node1 = temp.next;
Node node2 = temp.next.next;
temp.next = node2;
node1.next = node2.next;
node2.next = node1;
temp = node1;
}
return dummy.next;
}单链表加一
用一个非空单链表来表示一个非负整数，然后将这个整数加一。你可以假设这个整数除了 0 本身，没有任何前导的 0。这个整数的各个数位按照 高位在链表头部、低位在链表尾部 的顺序排列。
示例： 输入：[1,9,9] 输出：[2,0,0] 需要考虑的点： 1.进位问题 2.都是9的情况，需要多加一个表头
计算思考
计算是从低位开始的，而链表是从高位开始的，所以处理 就必须从后往前来。此时可以使用栈也可以用链表反转
栈实现
public static Node plusOne(Node head) {
Stack<Integer> stack = new Stack<>();
while (head != null) {
stack.push(head.val);
head = head.next;
}
Node dummy = new Node(0);
//进位
int carry = 0;
//加1
int adder = 1;
while (!stack.isEmpty() || carry > 0 || adder != 0) {
//stack为空说明要进位了
int sum = stack.isEmpty() ? 0 : stack.pop();
//先算一下够不够10
sum = sum + carry + adder;
//够10就进位，并且将当前值变为0
carry = sum >= 10 ? 1 : 0;
sum = sum >= 10 ? 0 : sum;
//接链表
Node newNode = new Node(sum);
newNode.next = dummy.next;
dummy.next = newNode;
adder = 0;
}
return dummy.next;
}反转实现
思考分析
-
反转链表
-
操作值
-
反转回来
public static Node reverseAndPlusOne(Node head){
Node reverseNode = reverseLinkedList(head);
Node cur = reverseNode;
int carry = 0;
int adder = 1;
Node newNode = null;
while (cur != null || carry > 0 || adder != 0) {
int sum = cur == null ? 0 : cur.val;
sum = sum + carry + adder;
carry = sum >= 10 ? 1 : 0;
sum = sum >= 10 ? 0 : sum;
if (cur != null) {
cur.val = sum;
cur = cur.next;
}else {
//如果走这步说明是999的情况
newNode = new Node(sum);
}
adder = 0;
}
Node finalNode = reverseLinkedList(reverseNode);
if (newNode != null) {
newNode.next = finalNode;
return newNode;
}
return finalNode;
}
public static Node reverseLinkedList(Node head){
Node pre = null;
Node cur = head;
while (cur != null) {
Node next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}链表加法
给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。你可以假设除了数字 0 之外，这两个数字都不会以零开头
示例： 输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295 输出：9 -> 1 -> 2，即912
栈实现
思路分析
-
创建两个栈，将链表全部压栈
-
创建虚拟节点
-
同时弹栈并累加和（a + b + carry(进位)）
-
取余得到个位数ans =（sum % 10），进位carry =（sum / 10）
-
将ans放入新节点并接入链表
public static ListNode addInListByStack(ListNode head1, ListNode head2) {
Stack<ListNode> st1 = new Stack<ListNode>();
Stack<ListNode> st2 = new Stack<ListNode>();
while (head1 != null) {
st1.push(head1);
head1 = head1.next;
}
while (head2 != null) {
st2.push(head2);
head2 = head2.next;
}
ListNode newHead = new ListNode(-1);
int carry = 0;
//这里设置carry!=0,是因为当st1,st2都遍历完时，如果carry=0,就不需要进入循环了
while (!st1.empty() || !st2.empty() || carry != 0) {
ListNode a = new ListNode(0);
ListNode b = new ListNode(0);
if (!st1.empty()) {
a = st1.pop();
}
if (!st2.empty()) {
b = st2.pop();
}
//每次的和应该是对应位相加再加上进位
int get_sum = a.val + b.val + carry;
//对累加的结果取余
int ans = get_sum % 10;
//如果大于0，就进位
carry = get_sum / 10;
ListNode cur = new ListNode(ans);
cur.next = newHead.next;
//每次把最新得到的节点更新到neHead.next中
newHead.next = cur;
}
return newHead.next;
}链表反转实现
思路分析
-
反转两个链表
-
创建虚拟节点
-
遍历链表值累加和 sum =（head1 + head2 + carry(进位)）
-
对sum取余存入新节点并接入虚拟节点后
-
更新进位值（sum / 10）
-
判断进位值，若>0则接入节点
-
再次反转新链表并返回
public class Solution {
public ListNode addInList (ListNode head1, ListNode head2) {
head1 = reverse(head1);
head2 = reverse(head2);
ListNode head = new ListNode(-1);
ListNode cur = head;
int carry = 0;
while(head1 != null || head2 != null) {
int sum = carry;
if (head1 != null) {
sum += head1.val;
head1 = head1.next;
}
if (head2 != null) {
sum += head2.val;
head2 = head2.next;
}
cur.next = new ListNode(sum % 10);
carry = sum / 10;
cur = cur.next;
}
if (carry > 0) {
cur.next = new ListNode(carry);
}
return reverse(head.next);
}
private ListNode reverse(ListNode head) {
ListNode cur = head;
ListNode pre = null;
while(cur != null) {
ListNode temp = cur.next;
cur.next = pre;
pre = cur;
cur = temp;
}
return pre;
}
}
扫一扫
414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
