Если у меня есть такой массив:
1 4 9 16 9 7 4 9 11
Каков наилучший способ изменить массив таким образом, чтобы он выглядел следующим образом:
11 9 4 7 9 16 9 4 1
У меня есть код ниже, но я чувствую, что это немного утомительно:
public int[] reverse3(int[] nums) {
return new int[] { nums[8], nums[7], nums[6], nums[5], num[4],
nums[3], nums[2], nums[1], nums[0] };
}
Есть ли более простой способ?
Collections.reverse() может выполнить эту работу для вас, если вы поместите свои номера в List из Integers.
List<Integer> list = Arrays.asList(1, 4, 9, 16, 9, 7, 4, 9, 11);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
Вывод:
[1, 4, 9, 16, 9, 7, 4, 9, 11]
[11, 9, 4, 7, 9, 16, 9, 4, 1]
Если вы хотите изменить массив на месте:
Collections.reverse(Arrays.asList(array));
Работает с Arrays.asList возвращает прокси-запись для исходного массива.
Если вы не хотите использовать Collections, вы можете сделать это:
for (i = 0; i < array.length / 2; i++) {
int temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
Мне нравится сохранять исходный массив и возвращать копию. Это общая версия:
public static <T> T[] reverse(T[] array) {
T[] copy = array.clone();
Collections.reverse(Arrays.asList(copy));
return copy;
}
без сохранения исходного массива:
public static <T> void reverse(T[] array) {
Collections.reverse(Arrays.asList(array));
}
попробуйте следующее:
public int[] reverse3(int[] nums) {
int[] reversed = new int[nums.length];
for (int i=0; i<nums.length; i++) {
reversed[i] = nums[nums.length - 1 - i];
}
return reversed;
}
мой вход был:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
и вывод, который я получил:
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
Вы можете использовать org.apache.commons.lang.ArrayUtils:
ArrayUtils.reverse(array)
Если вы не хотите использовать временную переменную, вы также можете сделать следующее:
final int len = arr.length;
for (int i=0; i < (len/2); i++) {
arr[i] += arr[len - 1 - i]; // a = a+b
arr[len - 1 - i] = arr[i] - arr[len - 1 - i]; // b = a-b
arr[i] -= arr[len - 1 - i]; // a = a-b
}
Поменять местами с минимальным количеством свопов.
for (int i = 0; i < a.length / 2; i++) {
int tmp = a[i];
a[i] = a[a.length - 1 - i];
a[a.length - 1 - i] = tmp;
}
Я бы сделал что-то вроде этого:
public int[] reverse3(int[] nums) {
int[] numsReturn = new int[nums.length()];
int count = nums.length()-1;
for(int num : nums) {
numsReturn[count] = num;
count--;
}
return numsReturn;
}
Или вы могли бы прокручивать его backeards
int[] firstArray = new int[]{1,2,3,4};
int[] reversedArray = new int[firstArray.length];
int j = 0;
for (int i = firstArray.length -1; i > 0; i--){
reversedArray[j++] = firstArray[i];
}
(примечание: я не скомпилировал это, но надеюсь, что это правильно)
вы перепутали
int[] firstArray = new int[]{1,2,3,4};
int[] reversedArray = new int[firstArray.length];
int j = 0;
for (int i = firstArray.length -1; i >= 0; i--){
reversedArray[j++] = firstArray[i];
}
public void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
public int[] reverseArray(int[] arr){
int size=arr.length-1;
for(int i=0;i<size;i++){
swap(arr,i,size--);
}
return arr;
}
Ниже будет изменен массив между индексами i и j (чтобы отменить вызов всего массива reverse(a, 0, a.length - 1))
public void reverse(int[] a, int i , int j) {
int ii = i;
int jj = j;
while (ii < jj) {
swap(ii, jj);
++ii;
--jj;
}
}
Этот код поможет:
int [] a={1,2,3,4,5,6,7};
for(int i=a.length-1;i>=0;i--)
System.out.println(a[i]);
вы можете отправить исходный массив методу, например:
после этого вы создаете новый массив для хранения обратных элементов
public static void reverse(int[] a){
int[] reversedArray = new int[a.length];
for(int i = 0 ; i<a.length; i++){
reversedArray[i] = a[a.length -1 -i];
}