1.基础问题:反转整个链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题?
2.问题解法
因为看到了进阶提示,所以我在开始就在思考用递归法求解:
先设置两个指针,temp=head.next,next=temp.next;
先翻转head和temp这两个节点,然后将next当成新链表的首节点进入递归翻转。即重复第一步操作,直到面临递归边界,只剩下一个或两个节点时,这个例子是最后只剩下一个节点的边界。
但面临最后一个单独节点时,不需要翻转,直接返回该节点,递归返回。
递归返回时,将这次递归的翻转节点链接到下一次递归返回来的链表末端,如上图。重复该操作,即可反转整个链表。
代码如下:
/**
* 链表节点定义
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode reverseList(ListNode head) {
//边界条件判断以及特殊情况判断
if ( head == null||head.next == null) {
return head;
}
ListNode temp = head.next, next = temp.next;
if(next==null) { //最后只剩下两个节点的边界条件判断
head.next = temp.next;
temp.next = head;
head = temp;
return head;
}
head.next = temp.next; //这次递归中的两个节点的反转
temp.next = head;
head = temp;
next = reverseList(next);//下一次递归
ListNode finallist = next; //重新链接
while (finallist.next != null) {
finallist = finallist.next;
}
head.next.next = null;
finallist.next = head;
return next;
}
}
这样的解法时间复杂度是O(n),空间复杂度也是O(n)。(我在leetcode上看了一下运行时间最短的解法,发现比起别人来的我还是差远啦)下面是leetcode的示例代码,这个代码很好的使用了链表的这种数据结构的特性,利用链表的链接和断开,精辟了很多,短短几行就解决了。
class Solution {
public ListNode reverseList(ListNode head) {
ListNode pre = null;
ListNode curr = head;
while (curr != null) {
ListNode temp = curr.next;
curr.next = pre;
pre = curr;
curr = temp;
}
return pre;
}
}
3.升级版问题:反转部分链表
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
4.对应解法
其实这个对比上面的只是需要判断m和n的位置,将这两个位置的链表截取就行翻转就可以,大致思路是一致的。截取位置可以利用n-m的差先计算两个位置间的节点个数,然后再利用两个步长不一致的指针(一个先走n-m个节点,一个呆在首节点的位置,再同时走过m个节点)就可以求出了。
代码如下:
public class Solution {
public ListNode reverseBetween(ListNode head, int m, int n) {
// 计算节点个数
int result = n - m;
ListNode dummy = new ListNode(0), flag = dummy;
ListNode pre = head, aft = head, temp = null, newlist = null;
dummy.next = head;
// 快慢指针
for (int i = 0; i < result; i++) {
aft = aft.next;
}
for (int i = 1; i < m; i++) {
flag = flag.next;
pre = pre.next;
aft = aft.next;
}
// 截取的链表与原链表断开
temp = aft.next;
aft.next = null;
// 重新链接
newlist = reverseList(pre, aft);
flag.next = newlist;
ListNode loc = newlist;
while (loc.next != null) {
loc = loc.next;
}
loc.next = temp;
return dummy.next;
}
private ListNode reverseList(ListNode pre, ListNode aft) {
if (pre == aft)
return pre;
ListNode temp = pre.next, next = temp.next;
if (temp == aft) {
pre.next = temp.next;
temp.next = pre;
pre = temp;
return pre;
}
pre.next = temp.next;
temp.next = pre;
pre = temp;
next = reverseList(next, aft);
ListNode finallist = next;
while (finallist.next != null) {
finallist = finallist.next;
}
pre.next.next = null;
finallist.next = pre;
return next;
}
}
这个解法只需要遍历一遍链表,甚至都不用遍历完整个链表,时间复杂度是O(n),因为反转是用的递归,所有空间复杂度最大是O(n),最小是O(1).
5.拓展题目:旋转链表
给定一个链表,旋转链表,将链表每个节点向右移动 k 个位置,其中 k 是非负数。
示例 :
输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
6.解法
这个虽然看起来和反转有一定的关系,但是实际解法是不一样的,我这里是先整个链表看成一个闭环,然后根据K来求出新的单向链表的首节点和尾节点。
代码如下:
public class Solution {
public ListNode rotateRight(ListNode head, int k) {
//特殊情况判断
if(head==null || head.next==null)
return head;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode pre = dummy.next;
ListNode end = dummy.next;
int len=0,num=0;
//通过K来求首节点的位置
while(end.next!=null) {
end=end.next;
len++;
}
len++;
if(k>=len) {
k=k%len;
}
num=len-k;
for (int i = 1; i < num; i++) {
pre=pre.next;
}
//重新链接
end.next=head;
dummy.next=pre.next;
pre.next=null;
return dummy.next;
}
}
这个解法的时间复杂度为O(n),空间复杂度是O(1),只用了一个常量级空间。