我正在尝试在Java中反转一个int数组。
该方法无法反转数组。
for(int i = 0; i < validData.length; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}
它有什么问题?
我正在尝试在Java中反转一个int数组。
该方法无法反转数组。
for(int i = 0; i < validData.length; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}
它有什么问题?
如果处理的数据比较原始(例如char,byte,int等),那么您可以执行一些有趣的XOR操作。
public static void reverseArray4(int[] array) {
int len = array.length;
for (int i = 0; i < len/2; i++) {
array[i] = array[i] ^ array[len - i - 1];
array[len - i - 1] = array[i] ^ array[len - i - 1];
array[i] = array[i] ^ array[len - i - 1];
}
}
@Test
public void reverseTest(){
Integer[] ints = { 1, 2, 3, 4 };
Integer[] reversedInts = reverse(ints);
assert ints[0].equals(reversedInts[3]);
assert ints[1].equals(reversedInts[2]);
assert ints[2].equals(reversedInts[1]);
assert ints[3].equals(reversedInts[0]);
reverseInPlace(reversedInts);
assert ints[0].equals(reversedInts[0]);
}
@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
if (array == null) {
return (T[]) new ArrayList<T>().toArray();
}
List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
Collections.reverse(copyOfArray);
return copyOfArray.toArray(array);
}
private static <T> T[] reverseInPlace(T[] array) {
if(array == null) {
// didn't want two unchecked suppressions
return reverse(array);
}
Collections.reverse(Arrays.asList(array));
return array;
}
Collections.reverse(asList(arraytoReverse)); return arrayToReverse;
。asList
只是一个数组的包装器,因此原始数组被反转。 - Radiodefreturn (T[]) new ArrayList<T>().toArray();
实际上会返回一个空的 Object[]
,而不是参数所指定的类型。 - Paŭlo Ebermann这将对你有所帮助
int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
int temp = a[k];
a[k] = a[a.length-(1+k)];
a[a.length-(1+k)] = temp;
}
这个问题有两种解决方案:
1. 原地反转数组。
步骤1:交换开头和结尾索引处的元素。
步骤2:增加起始索引,减少结束索引。
步骤3:重复执行步骤1和步骤2,直到起始索引 < 结束索引。
使用这种方法,时间复杂度为O(n),空间复杂度为O(1)。
原地反转数组的示例代码如下:
public static int[] reverseAnArrayInSpace(int[] array) {
int startIndex = 0;
int endIndex = array.length - 1;
while(startIndex < endIndex) {
int temp = array[endIndex];
array[endIndex] = array[startIndex];
array[startIndex] = temp;
startIndex++;
endIndex--;
}
return array;
}
2. 使用辅助数组来反转一个数组。
步骤1. 创建一个大小等于给定数组的新数组。
步骤2. 从给定数组的末尾索引开始,将元素插入到新数组的起始索引处。
这样做的时间复杂度为O(n),空间复杂度为O(n)。
使用辅助数组反转一个数组的示例代码如下:
public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
int[] reversedArray = new int[array.length];
for(int index = 0; index < array.length; index++) {
reversedArray[index] = array[array.length - index -1];
}
return reversedArray;
}
此外,我们可以使用Java中的Collections API来完成这个操作。
Collections API内部也使用相同的反向空间方法。
使用Collections API的示例代码如下:
public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
List<Integer> arrayList = Arrays.asList(array);
Collections.reverse(arrayList);
return arrayList.toArray(array);
}
你的程序只能处理length = 0, 1
的情况。你可以尝试:
int i = 0, j = validData.length-1 ;
while(i < j)
{
swap(validData, i++, j--); // code for swap not shown, but easy enough
}
以上有很好的答案,但这是我做的方法:
public static int[] test(int[] arr) {
int[] output = arr.clone();
for (int i = arr.length - 1; i > -1; i--) {
output[i] = arr[arr.length - i - 1];
}
return output;
}
public void getDSCSort(int[] data){
for (int left = 0, right = data.length - 1; left < right; left++, right--){
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
使用 O(n) 时间复杂度和 O(1) 空间复杂度的解决方案。
void reverse(int[] array) {
int start = 0;
int end = array.length - 1;
while (start < end) {
int temp = array[start];
array[start] = array[end];
array[end] = temp;
start++;
end--;
}
}
for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }
。 - Tim Cooke迭代数组时,最高效的方法是从后往前迭代。
我不确定Aaron的解决方案是否通过此调用实现 Collections.reverse(list);
。有人知道吗?
for(int i = 0; i < validData.length; i++){
validData[i] = validData[i] ^ validData[validData.length - i - 1];
validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1];
validData[i] = validData[i] ^ validData[validData.length - i - 1];
}