实现数组元素倒序的算法，写出两种实现，时间复杂度为O(n)和O(n/2)

一次在中友集团中的笔试题：实现数组元素倒序的算法，写出两种实现，时间复杂度为O(n)和O(n/2)。以下为我的实现，如下所示：

package algorithm;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * @author RockeyLu 中友的倒序算法题，不能直接用集合的倒序方法

 *         至少两种实现方式

 *         一：时间复杂度为O(n)

 *         二：时间复杂度为O(n/2)
 * 
 */
public class ReverseAlgo {

	public static void main(String[] args) {
		// 偶数个元素
		// String[] arrays = { "k", "b", "i", "s", "o", "n" };
		// 奇数个元素
		String[] arrays = { "R", "o", "c", "k", "e", "y", "L" };
		System.out.println("原来的数组:" + Arrays.asList(arrays));
		System.out.println("倒序，时间复杂度O(n):" + Arrays.asList(reverse1(arrays)));
		System.out.println("倒序，时间复杂度O(n/2):" + Arrays.asList(reverse2(arrays)));
		List temp = Arrays.asList(arrays);
		Collections.reverse(temp);
		System.out.println("倒序，集合的倒序方法:" + temp);
	}

	/**
	 * 从尾到头遍历，然后赋值给一个新的数组

	 * 时间复杂度为O(n)
	 * 
	 * @param arrays
	 * @return
	 */
	public static String[] reverse1(String[] arrays) {
		if (arrays == null || arrays.length == 0) {
			return null;
		}
		String[] reverseArray = new String[arrays.length];
		for (int i = arrays.length - 1, j = 0; i >= 0; i--, j++) {
			reverseArray[j] = arrays[i];
		}
		return reverseArray;
	}

	/**
	 * 数组的头尾元素对调，直到中间

	 * 时间复杂度为O(n/2)
	 * 
	 * @param arrays
	 * @return
	 */
	public static String[] reverse2(String[] arrays) {
		if (arrays == null || arrays.length == 0) {
			return null;
		}
		int i = 0, j = arrays.length - 1;
		while ((i < arrays.length / 2) && (j >= arrays.length / 2)) {
			swap(arrays, i, j);
			i++;
			j--;
		}
		return arrays;
	}

	/**
	 * 交换数组中的两个元素
	 * 
	 * @param arrays
	 * @param i
	 * @param j
	 */
	private static void swap(String[] arrays, int i, int j) {
		String temp = arrays[i];
		arrays[i] = arrays[j];
		arrays[j] = temp;
	}
}