Java中用于反转数组的快速算法[重复]

Question

我已编写代码来反转具有时间复杂度的数组：O(n)。

有更快的方法吗？

我的代码：

 void reverseArray(int arr[], int start, int end){
        int temp;
        if(start >= end)
            return;
        temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        reverseArray(arr, start+1, end-1);   
    }

Answer 1

从字面上反转内存中的元素不能比 O(n) 更快。但是，您可以创建一个包装类来对数组进行反向索引。所以，实际上你并没有反转数组，而只是反向访问元素。

您拥有的代码是 O(n)，但由于递归而很糟糕。把它弄平，你会体验到一些好处。

public static void reverseArray(int arr[], int start, int end)
{
    int len = end - start;
    if(len <= 0) return;

    int len2 = len >> 1;
    int temp;

    for (int i = 0; i < len2; ++i)
    {
        temp = arr[start + i];
        arr[start + i] = arr[end - i - 1];
        arr[end - i - 1] = temp;
    }
}

Answer 2

您使用的递归不如循环快。您仍然是 O(n) 但使用循环的时间更快。比如：

static void reverseArray(int arr[]){
   for (int start=0,end=arr.length-1;start<=end;start++,end--) {
      int temp = arr[start];
      arr[start] = arr[end];
      arr[end] = temp;
   }
}

对于这样的事情，你最好使用 Java 库中提供的方法来完成它。

Answer 3

你可以使用一些中介功能：

int rev(int i) {
    return arr.length - i - 1;
}
//...
arr[rev(i)] = 5; // reverse reference

Answer 4

如果您使用静态数组，因为您需要访问每个元素一次才能反转它，所以没有比 n 更复杂的复杂度。

但是，如果您使用双链表，那么根据定义，您可以双向访问元素。从头到尾，从尾到头，因为使用的Node类中有双指针。因此，甚至不需要反向，而是在需要时从尾部迭代到头部。

Answer 5

递归与迭代。函数调用（递归）成本周期。因此，对于这个解决方案，我会采用迭代方法。其他需要注意的事项是：偶数/奇数大小的数组、空数组、只有 1 个项目的数组。一个未经测试的解决方案是：

void reverseArray(int arr[]){

  //check input
  if(arr.length <= 1){
    return;
  }

  int arrLength = arr.length;
  int swpIndex;

  for (int i = 0; i < arrLength / 2 - 1; i++){
    swpIndex = arrLength - i - 1;

    swp = arr[i];
    arr[i] = arr[swpIndex]; 
    arr[swpIndex] = swp;
  }
}

这会存储一些值，以便真正避免重复（即额外的循环）。它还检查不需要反转的数组。