优化阵列旋转程序答案

【问题标题】：Optimize program for array rotation优化阵列旋转程序
【发布时间】：2017-05-14 00:21:18
【问题描述】：

我的代码执行时间过长。有人可以帮我优化这个程序吗？

限制：

时间：4 秒
内存：512 mb

代码：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    private static int[] a;
    public static void swap(int i){
        int temp=a[i];
        a[i]=a[i-1];
        a[i-1]=temp;
    }
    public static void rotate(int times,int n){
        for(int j=0;j<times;j++)
            for(int i=n-1;i>0;i--)
              swap(i);
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();
        a = new int[n];
        int m[]=new int[q];
        for(int a_i=0; a_i < n; a_i++){
            a[a_i] = in.nextInt();
        }
        for(int a0 = 0; a0 < q; a0++){
            m[a0] = in.nextInt();
        }

        rotate(k%n,n);

        for(int a0 = 0; a0 < q; a0++){
           System.out.println(a[m[a0]]);
        }

    }
}

我认为必须有更好的方法来交换或旋转数组。

【问题讨论】：

n、k、q的值是多少？
您的旋转对象执行交换方法 7,282,300,000 次 - 所以是的，这将需要一些时间...旋转数组 n 次应该相当于将所有元素移动 n%length 一次，不是吗？这样会快得多。

标签： java arrays optimization rotation

【解决方案1】：

我认为不需要实际旋转数组... 您可以只打印执行旋转后预期位置的位置。

   //rotate(k%n,n);

    for(int a0 = 0; a0 < q; a0++){
       if(m[a0]+(k%n)>n)
         System.out.println((a[m[a0]+(k%n)-n]));
       else
         System.out.println((a[m[a0]+(k%n)]))
    }

【讨论】：

【解决方案2】：

使用reversal rotate algotithm 实现线性复杂度。

import java.util.*;

class Solution {
    private static int[] a;

    private static void reverse(int l, int r) {
        r--;
        while (l < r) {
            int tmp = a[l];
            a[l] = a[r];
            a[r] = tmp;
            l++;
            r--;
        }
    }

    private static void rotate(int k, int n) {
        reverse(0, n - k);
        reverse(n - k, n);
        reverse(0, n);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();
        a = new int[n];
        int m[] = new int[q];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }
        for (int i = 0; i < q; i++) {
            m[i] = in.nextInt();
        }

        rotate(k % n, n);

        for (int i = 0; i < q; i++) {
            System.out.println(a[m[i]]);
        }
    }
}

【讨论】：

【解决方案3】：

向右旋转阵列

public static int[] solve(int m[],int k){
    for(int i=0;i<k;i++){
        int last=m[m.length-1];
        for(int j=m.length-1;j>0;j--){
            m[j]=m[j-1];
        }
        m[0]=last;
    }
    return m;
}

***输入：- m[]={1,2,3,4,5}; k=2;

输出：- 4 5 1 2 3***

【讨论】：