1. 指定区间反转
给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right。请你反转从位置 left 到位置 right 的链表节点,返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5], left = 2, right = 4
输出:[1,4,3,2,5]
1.1 头插法
在需要反转的区间里, 每遍历到一个节点, 让这个节点来到区间起始的位置。
/**
* 头插法
*
* @param head
* @param left
* @param right
* @return
*/
public static ListNode reverseBetween2(ListNode head, int left, int right) {
// 设置 dummyNode 是这一类问题的一般做法
ListNode dummyNode = new ListNode(-1);
dummyNode.next = head;
// 找到反转区间的起始位置
ListNode prev = dummyNode;
for (int i = 0; i < left - 1; i++) {
prev = prev.next;
}
// 遍历反转区间节点
ListNode cur = prev.next;
ListNode next;
for (int i = 0; i < right - left; i++) {
next = cur.next;
cur.next = next.next;
next.next = prev.next;
prev.next = next;
}
return dummyNode.next;
}
1.2 穿针引线法
第一步: 将待反转区域反转
第二步: 将前驱节点pre的next指针指向反转后的链表头节点, 将反转以后的链表尾节点的next指针指向后继节点succ
/**
* 穿针引线法
*
* @param head
* @param left
* @param right
* @return
*/
public static ListNode reverseBetween(ListNode head, int left, int right) {
// 因为头节点有可能发生变化,使用虚拟头节点可以避免复杂的分类讨论
ListNode dummyNode = new ListNode(-1);
dummyNode.next = head;
// 前驱节点
ListNode pre = dummyNode;
// 找到待反转区域的前一个节点
for (int i = 0; i < left - 1; i++) {
pre = pre.next;
}
// 找到待反转区域的结束节点
ListNode rightNode = pre;
for (int i = 0; i < right - left + 1; i++) {
rightNode = rightNode.next;
}
// 后驱节点
ListNode succ = rightNode.next;
// 截取链表
ListNode leftNode = pre.next;
rightNode.next = null;
ListNode prev = null;
// 反转待反转区域
ListNode curr = leftNode;
while (curr != null) {
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
pre.next = rightNode;
leftNode.next = succ;
return dummyNode.next;
}
2. 两两交换链表中的节点
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
解决思路:
假设当前节点为node1, 下一个节点为node2。将node1的next指针指向node2.next, node2的next指针指向node1, 遍历链表循环操作。
代码实现:
/**
* 直接根据两个指针的情况来设置
* @param head
* @return
*/
public static ListNode swapPairs(ListNode head) {
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode curr = dummyHead;
while (curr.next != null && curr.next.next != null) {
ListNode node1 = curr.next;
ListNode node2 = curr.next.next;
node1.next = node2.next;
node2.next = node1;
curr.next = node2;
curr = node1;
}
return dummyHead.next;
}
3. 链表加1
用一个非空单链表来表示一个非负整数,然后将这个整数加一。你可以假设这个整数除了 0 本身,没有任何前导的 0。这个整数的各个数位按照 高位在链表头部、低位在链表尾部 的顺序排列。
示例:
输入: [1,2,3]
输出: [1,2,4]
解决思路:
加法计算是从低位开始, 而链表是从高位开始的, 因此首先需要将链表进行反转, 这里使用栈实现。遍历链表, 并将节点依次压入栈中, 然后从栈中依次弹出元素进行计算, 需要特别处理的是进位的情况。
代码实现:
/**
* 链表加1
* @param head
* @return
*/
public static ListNode plusOne(ListNode head) {
Stack<ListNode> stack = new Stack<>();
while (head != null) {
stack.push(head);
head = head.next;
}
// 记录是否进位
int carry = 0;
// 加的数字
int addNumber = 1;
// 用来保留指向出栈元素的指针
ListNode dummyNode = new ListNode(0);
while (!stack.empty() || carry > 0) {
int digit = stack.empty() ? 0 : stack.pop().val;
int sum = digit + addNumber + carry;
carry = sum >= 10 ? 1 : 0;
sum = sum >= 10 ? sum - 10 : sum;
ListNode curr = new ListNode(sum);
curr.next = dummyNode.next;
dummyNode.next = curr;
addNumber = 0;
}
return dummyNode.next;
}
使用链表反转实现
/**
* 链表反转实现
* @param head
* @return
*/
public static ListNode plusOneByReverse(ListNode head) {
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
curr = prev;
// 记录是否进位
int carry = 0;
// 加的数字
int addNumber = 1;
// 用来保留指向出栈元素的指针
ListNode dummyNode = new ListNode(0);
while (curr != null || carry > 0) {
int digit = curr == null ? 0 : curr.val;
int sum = digit + addNumber + carry;
carry = sum >= 10 ? 1 : 0;
sum = sum >= 10 ? sum - 10 : sum;
ListNode newNode = new ListNode(sum);
newNode.next = dummyNode.next;
dummyNode.next = newNode;
addNumber = 0;
// 当原链表所有节点都进位时, 会出现 curr = null 的情况
if (curr != null) {
curr = curr.next;
}
}
return dummyNode.next;
}
4. 链表加法
给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。你可以假设除了数字 0 之外,这两个数字都不会以零开头。
示例:
输入:(6 -> 1 -> 7) + (2 -> 9 -> 5),即617 + 295
输出:9 -> 1 -> 2,即912
解题思路:
将两个链表分别压入两个栈中, 然后再一起出栈, 将两个结果分别计算。之后对计算结果取模, 模数保存到新的链表中, 进位保存到下一轮。
代码实现:
/**
* 通过栈来实现
*
* @param head1
* @param head2
* @return
*/
public static ListNode addInListByStack(ListNode head1, ListNode head2) {
Stack<ListNode> stack1 = new Stack<>();
Stack<ListNode> stack2 = new Stack<>();
while (head1 != null) {
stack1.push(head1);
head1 = head1.next;
}
while (head2 != null) {
stack2.push(head2);
head2 = head2.next;
}
int carry = 0;
ListNode dummyNode = new ListNode(-1);
while (!stack1.empty() || !stack2.empty() || carry > 0) {
int digit1 = stack1.empty() ? 0 : stack1.pop().val;
int digit2 = stack2.empty() ? 0 : stack2.pop().val;
int sum = digit1 + digit2 + carry;
carry = sum >= 10 ? 1 : 0;
sum %= 10;
ListNode curr = new ListNode(sum);
curr.next = dummyNode.next;
dummyNode.next = curr;
}
return dummyNode.next;
}
使用链表反转实现:
/**
* 通过链表反转来实现
*
* @param head1
* @param head2
* @return
*/
public static ListNode addInListByReverse(ListNode head1, ListNode head2) {
head1 = reverse(head1);
head2 = reverse(head2);
ListNode curr1 = head1;
ListNode curr2 = head2;
ListNode dummyNode = new ListNode(-1);
int carry = 0;
while (curr1 != null || curr2 != null || carry > 0) {
int digit1 = curr1 == null ? 0 : curr1.val;
int digit2 = curr2 == null ? 0 : curr2.val;
int sum = digit1 + digit2 + carry;
carry = sum >= 10 ? 1 : 0;
sum %= 10;
ListNode curr = new ListNode(sum);
curr.next = dummyNode.next;
dummyNode.next = curr;
if (curr1 != null) {
curr1 = curr1.next;
}
if (curr2 != null) {
curr2 = curr2.next;
}
}
return dummyNode.next;
}