LeetCode-rotateRight

Given a list, rotate the list to the right by k places, where k is non-negative.

For example:
Given 1->2->3->4->5->NULL and k = 2,
return 4->5->1->2->3->NULL.

题解:

这道题主要先理解题意,就是倒着数k个node,从那开始到结尾和之前那部分对调,那个例子就是,4->5拿前面来,1->2->3拿后面去。

几个特殊:

k是可以大于整个list的长度的,所以这时要对k对len取模

如果取模之后得0,相当于不用rotate,直接返回

思路(3种方法):

1、首先分析,涉及到一块链表,就要使用faster/slower双指针,,还涉及到链表的换位,那么要注意块链表的前驱节点的指向---->那么引出要构建一个新的head节点(下面还有种方法),new 一个ListNode;

需要注意的是:双指针节点的位置。

public class RotateList {
    private class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
        }
    }

public ListNode rotateRight(ListNode head, int k) {
            if (head == null || head.next == null) {
                return head;
            }
            int len = 0;
            ListNode countlen = head;
            while (countlen != null) {
                len++;
                countlen = countlen.next;
            }
                        
            ListNode a = new ListNode(-1);
            a.next = head;
            head = a;
            
            ListNode r, p, q;
            r = head;
            p = r.next;
            q = r.next;
                        
            k = k % len;
        if(k == 0)      return head.next;
        
       for(int i= 1;i<k;i++){
               q= q.next;
           }
           
           while (q.next != null) {
                    q = q.next;
                    p = p.next;
                    r = r.next;

}
            r.next = null;
            q.next = head.next;
            head.next = p;
            return head.next;
        }

2、处理完特殊情况后,就用熟悉的faster/slower双指针解决就好(看到这种linkedlist,倒着数数的,就条件反射了)

先对faster设步长为n,然后faster和slower再一起走,知道faster.next==null,说明slower指向要倒着数的开始点的前一个位置。

所以slow.next就是要返回的newhead,保存一下。

然后把faster.next接到head上,slower.next存为null,作队尾。

这样就把list给rotate了。

(这里要注意,一个链表是用head来表示其在内存中的位置,因此,只要返回一个head,就可以找到该链表!因此,我们可以令链表的任意node为newhead,使尾节点的next为head(原来的),然后返回newhead,这就是链表常用思路

 public ListNode rotateRight(ListNode head, int k) {
        if(head==null||head.next==null)
            return head;
        k=k%length(head);
        if(k==0)
            return head;
        ListNode fast = head;
        ListNode slow = head;
        while(k-->0)
            fast=fast.next;

        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
        }
        ListNode newHead=slow.next;         //这里重置一个head
        slow.next=null;
        ListNode cur=newHead;
        while(cur.next!=null)
            cur=cur.next;
        cur.next=head;
        return newHead;
    }

    public int length(ListNode head){
        int res=0;
        while(head!=null){
            res++;
            head=head.next;
        }
        return res;
    }

3、还有一种就是把整个list连起来,变成环,找到切分点断开就行。(循环链表来做。)

public ListNode rotateRight(ListNode head, int k) {        if(head == null || head.next == null) return head;

    // Get length    int len = 1;    ListNode tail = head;    while(tail.next != null) {        tail = tail.next;        len++;    }

    // Go to position k distance to tail    k = k % len;    if(k == 0) return head;    ListNode newTail = head;    for(int i = 0; i < len - k - 1; i++) {        newTail = newTail.next;    }

    // Join two parts    ListNode newHead = newTail.next;       newTail.next = null;    tail.next = head;

    return newHead;}
时间: 2024-10-08 00:18:37

LeetCode-rotateRight的相关文章

leetcode笔记

leetcode 笔记 Linked List 2. Add Two Numbers You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a

Rotate List leetcode

这个题很有意思,看题目可以想到利用循环链表,将链表构成一个环后,旋转一定角度后,然后再拆开环,就可以得到新的链表 这里需要注意的就是k值和链表长度的关系,我们可以将环看做钟表,链表长度n就是这个钟表的最大刻度,k值是指针走过的刻度,k值可以比n小,也可以比n大,因为钟表环形循环的特点,指针可能已经绕了钟表好几周,这几周可以完全省略掉,只取余数k % n就是指针走过的有效刻度. 我们如何得到新的头结点呢,联想到钟表,我们假设原来头结点在0刻度上,旋转后,原来 -k%n 刻度来到了0刻度的位置上,只

LeetCode --- 61. Rotate List

题目链接:Rotate List Given a list, rotate the list to the right by k places, where k is non-negative. For example: Given 1->2->3->4->5->NULL and k = 2, return 4->5->1->2->3->NULL. 这道题的要求是向右旋转链表k步. 其实就是把链表后面l-k个节点放到前面,可以采用快慢指针处理.不

leetcode 61 Rotate List ----- java

Given a list, rotate the list to the right by k places, where k is non-negative. For example:Given 1->2->3->4->5->NULL and k = 2,return 4->5->1->2->3->NULL.题目意思不难,就是说给一个数k,然后从右向左数第k个节点,然后以这个节点为开头,重新组成一个链表. 需要注意的就是如果k大于链表长度len

LeetCode OJ Linked List: 24题、148题和61题

题外话:最近打算做一些LeetCode OJ上面的练习题了,当然很多前辈都已经写过若干解题报告了.坦白说,也正是因为前辈们的贡献,才让我们学习到了很多知识.所以,我一直都在犹豫到底要不要写解题报告多此一举呢?当然,我水平很渣啊.我觉得虽然,有很多很好的解题报告可参考了,但是自己对待这件事的态度又是另外一回事,记录下来,完全是提醒自己这段时间是有计划的,是要做题的. 24题:Swap Nodes in Pairs 题目分析:链表长度为奇数时,最后一个节点不用再调整啦.当然了,不能改变节点的值,否则

leetCode解题报告5道题(九)

题目一:Combinations Given two integers n and k, return all possible combinations of k numbers out of 1 ... n. For example,If n = 4 and k = 2, a solution is: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] 分析: 题意给我们一个数字n, 和一个数字k,让我们求出从 1~~n中取出k个数所能得到的组合数 所

Rotate List leetcode java

题目: Given a list, rotate the list to the right by k places, where k is non-negative. For example: Given 1->2->3->4->5->NULL and k = 2, return 4->5->1->2->3->NULL. 题解: 这道题主要先理解题意,就是倒着数k个node,从那开始到结尾和之前那部分对调,那个例子就是,4->5拿前面来,

Leetcode:Rotate List 链表旋转

Rotate List Given a list, rotate the list to the right by k places, where k is non-negative. For example:Given 1->2->3->4->5->NULL and k = 2,return 4->5->1->2->3->NULL. 解题分析: 不同于数组旋转,数组可以随机存取,数组的旋转可以巧妙的 分成两两部分递归旋转 对于链表的旋转,实际上

leetcode第一刷_Rotate List

我提交了好多次,错误莫名其妙的,到后来才明白过来,原来我把题目给理解错了. 这个题的意思不是说让你把最后的那k个位置的元素移到前面来,这种问题的做法就是用两个指针,先让一个走,走到一定的长度之后两个一起走,很简单.它实际的意思是整个链表循环右移,假设一个链表长度是N,那么循环右移N次之后,链表又变回了原来的样子.k的取值范围只说了是非负的,也就是它可以是大于N的,因此实际的移位次数只是(k%N)而已. 代码就不多说了,很简单. class Solution { public: ListNode

[LeetCode]题解(python):061-Rotate list

题目来源 https://leetcode.com/problems/rotate-list/ Given a list, rotate the list to the right by k places, where k is non-negative. For example:Given 1->2->3->4->5->NULL and k = 2,return 4->5->1->2->3->NULL. 题意分析 Input:a list of