Question

我不能使用内置函数，我必须使用自己的逻辑。

我已将元素移到左侧，但右侧对我不起作用。不知道为什么。

我的左方法：

public int[] shiftLeft(int[] arr) {
    int[] demo = new int[arr.length];
    int index = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        demo[index] = arr[i + 1];
        index++;
    }
    return demo;
}

我尝试正确的转变：

public int[] shiftRight(int[] arr) {
    int[] demo = new int[arr.length];
    int index = 0;
    for (int i = arr.length - 1; i >= 0; i--) {
        demo[index] = arr[(i - 1 > 0) ? i - 1 : 0];
        index++;
    }
    return demo;
}

我做错了什么？

转移我的意思是：

你有一个数组，1 2 3 4 5 6
将它向左移动：2 3 4 5 6 1
将其向右移动一个：6 1 2 3 4 5

Answer 1

//right shift with modulus
for (int i = 0; i < arr.length; i++) {
    demo[(i+1) % demo.length] = arr[i];
}

Answer 2

最简单的方法：

public int[] shiftLeft(int[] arr) 
{
    int[] demo = new int[arr.Length];

    for (int i = 0; i < arr.Length - 1; i++) 
    {
        demo[i] = arr[i + 1];
    }

    demo[demo.Length - 1] = arr[0];

    return demo;
}

public int[] shiftRight(int[] arr) 
{
    int[] demo = new int[arr.Length];

    for (int i = 1; i < arr.Length; i++) 
    {
        demo[i] = arr[i - 1];
    }

    demo[0] = arr[demo.Length - 1];

    return demo;
}

Answer 3

LINQ解决方案，只是为了增加一些多样性。

static int[] LeftShift(int[] array)
{            
    // all elements except for the first one... and at the end, the first one. to array.
    return array.Skip(1).Concat(array.Take(1)).ToArray();
}

static int[] RightShift(int[] array)
{
    // the last element (because we're skipping all but one)... then all but the last one.
    return array.Skip(array.Length - 1).Concat(array.Take(array.Length - 1)).ToArray();
}

如果性能很重要（对于大型阵列），可能不推荐使用。

我意识到OP不应该使用“内置函数”。

Answer 4

  public static int[] shiftRight(int[] arr){

      int[] demo = new int[arr.Length];

      for (int i = 0; i <= arr.Length - 2; i++)
      {
          demo[i + 1] = arr[i];
      }

      demo[0] = arr[arr.Length - 1];
      return demo;
  }

Answer 5

这里的问题是你需要特殊情况下第一个元素的左移。对于每个元素，但第一个元素的新索引将为oldIndex - 1。这基本上就是循环正在做的事情。但是，第一个元素的新索引为oldLength - 1。这需要在代码库中的某个地方进行特殊处理。

Answer 6

你做得不对。使用标准循环缓冲逻辑。

http://en.m.wikipedia.org/wiki/Circular_buffer

Answer 7

试试这个，

public int[] ShiftRight(int[] arr) 
{
    int[] demo = new int[arr.Length];
    for (int i = 0; i < arr.Length; i++) {
        demo[i] = arr[i == 0 ? (arr.Length - 1) : (i - 1)];
    }
    return demo; 
}

Answer 8

public int[] shiftRight(int[] arr) 
{
    int[] demo = new int[arr.length];

    Array.Copy(arr,arr.Length-1,demo,0,1); // Copy last position to first
    Array.Copy(arr,0,demo,1,arr.Length-1); // Copy the rest shifted one       

    return demo;
}

Answer 9

使用Arra.Copy ...

public int[] shiftLeft(int[] arr) {
var result = new int[arr.Length];
Array.Copy(arr, 1, result, 0, arr.Length - 1);
result[arr.Length - 1] = arr[0];
return result;

}

    public int[] shiftRight(int[] arr) {
  var result = new int[arr.Length];
  Array.Copy(arr, 0, result, 1, arr.Length - 1);
  result[0] = arr[arr.Length - 1];
  return result;
}

Answer 10

通常我会使用此代码。您可以重写为数组扩展方法。

public static T[] Shift<T>(T[] array, int shiftValue)
{       
    var newArray = new T[array.Length];
    shiftValue -= array.Length;
    if(shiftValue < 0)
    {
        shiftValue*=-1;
    }


    for(var i=0; i<array.Length; i++)
    {
        var index = (i + shiftValue) % array.Length;

        newArray[i] = array[index]; 
    }
    return newArray;
}

Answer 11

也许这对任何看到此帖子的人都有效：

private int[] shiftLinear(int[] linArray, int shift){   
    int length = linArray.Length;
    int[] shifted = new int[length];
    shift = shift % length;
    if (shift >= 0) {
        for (int n = shift ; n < length; n++) shifted[n] = linArray[n-shift];   
        if (shift != 0)  for (int n = 0; n < shift; n++) shifted[n] = linArray[length-1-n]; 
    } else {
        for (int n = 0 ; n < length+shift; n++) shifted[n] = linArray[n-shift];   
        for (int n = length+shift; n < length ; n++) shifted[n] = linArray[n-length-shift]; 
    }
    return shifted;
}

Answer 12

不使用外部数组；

public static int[] right(int[] A)
{
     var tempo = A[0];
     for(var i=0; i<A.Length-1; i++)
     {
         var yolo = A[i + 1];
         A[i + 1] = tempo;
         tempo = yolo;
     }
     A[0] = tempo;
     return A;
 }

public static int[] left(int[] A)
{
    var tempo = A[A.Length - 1];
    for (var i = A.Length - 1; i >0; i--)
    {
          var yolo = A[i - 1];
          A[i -1] = tempo;
          tempo = yolo;
    }
    A[A.Length - 1] = tempo;
    return A;
}

将数组元素移到右边？

12 个答案: