声明,此题目来自leecode61
题目:
给你一个链表的头节点 head
,旋转链表,将链表每个节点向右移动 k
个位置。
示例1:输入:head = [1,2,3,4,5], k = 2 输出:[4,5,1,2,3]
示例2:输入:head = [0,1,2], k = 4 输出:[2,0,1]
提示:
- 链表中节点的数目在范围
[0, 500]
内 -100 <= Node.val <= 100
0 <= k <= 2 * 109
链表的结构定义如下
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
思路:
首先想到的是,每一次旋转,都是将最后一个节点的next指向当前头节点,并作为新的头节点,然后倒数第二个节点的next指向空。
那能不能先获取到倒数第二个节点?
// 获得倒数第二名的节点
public ListNode getSecondLastNode(ListNode head) {
ListNode current = head;
while (current.next.next != null) {
current = current.next;
}
return current;
}
然后获取到一次旋转的新的头节点
// 获取到一次旋转的新的头节点
public ListNode getNewHead(ListNode oldHeadNode) {
ListNode secondLastNode = this.getSecondLastNode(oldHeadNode);
ListNode newHeadNode = secondLastNode.next;
secondLastNode.next = null;
newHeadNode.next = oldHeadNode;
return newHeadNode;
}
然后我们把k作为循环次数,对getNewHead进行循环
public ListNode rotateRight(ListNode head, int k) {
ListNode newHeadNode = head;
for (int i=1; i <= k; i++) {
newHeadNode = this.getNewHead(newHeadNode);
}
return newHeadNode;
}
但是这样会有一个问题
对于 输入[1,2,3] k=2000000000
这个算法的效率就太低了,循环的次数过多
这个时候,我们观察到
对于 [1,2,3] k%链表长度的结果,是 1,2,0,1,2,0
有规律的循环往复的,而且结果=0,链表是不用旋转的。
所以我们先求出链表长度,然后再跟k取模,整个算法变成下面这样
public ListNode rotateRight(ListNode head, int k) {
int round = k % this.getLength(head);
if (round == 0) return head;
ListNode newHeadNode = head;
for (int i=1; i <= round; i++) {
newHeadNode = this.getNewHead(newHeadNode);
}
return newHeadNode;
}
// 求出链表长度
public int getLength(ListNode head) {
int length = 1;
ListNode current = head;
while (current.next != null) {
current = current.next;
length ++;
}
return length;
}
到这里,算法其实是已经可以走通了,但是大家有没有观察到
整个算法循环次数过多,
求出链表长度有循环,获取倒数第二个节点有循环,k的遍历还是循环。
那有没有效率更高的算法呢?有,用环。
环
我们把旋转前最后一个节点,跟头节点相连,我们就得到一个环。
现在的问题,就变成了,在这个环里面找到k次旋转后的最后一个节点,然后将它的next设置为空。
而头节点,就是最后一个节点的next。
k=1的时候,最后一个节点是2,相当于3 next遍历2次;
k=2的时候,最后一个节点是1,相当于3 next遍历1次;
k=3的时候,最后一个节点是3,链表不用旋转。
总结规律就是,旋转k次,链表最后一个节点需要遍历链表长度length-(k%length)
完整代码如下
前面数据校验是针对 输入 [] k=1 和 输入 [1] k=1 这种特殊用例做的。
public ListNode rotateRight(ListNode head, int k) {
// 数据校验
if (k==0) return head;
if (head == null) return head;
if (head.next == null) return head;
int length = 1;
ListNode tmp = head;
// 求出链表长度和最后一个节点
while (tmp.next != null) {
tmp = tmp.next;
length ++;
}
k = k % length;
if (k == 0) return head;
// 首尾相连,形成一个环,这里的tmp就是最后一个节点
tmp.next = head;
// 找出旋转后的最后一个节点
for (int i=1; i <= length-k; i++) {
tmp = tmp.next;
}
// 新的头节点就是找到的最后一个节点的下一个节点
ListNode newHeadNode = tmp.next;
// 将找到的最后一个节点的 next 设置为空
tmp.next = null;
return newHeadNode;
}