values - ¿Cómo puedo revertir una matriz int en Java?

value length java

Question

Estoy tratando de revertir una matriz int en Java.

Este método no invierte la matriz.

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;
}

¿Qué tiene de malo?

Answer 1

¿No sería mucho más improbable que se cometiera un error de esta manera?

 int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] temp = new int[intArray.length];
for(int i = intArray.length - 1; i > -1; i --){
temp[intArray.length - i -1] = intArray[i];
}
intArray = temp;

Answer 2

2 maneras de revertir una matriz.

1. Utilizando For bucle e intercambie los elementos hasta el punto medio con complejidad de tiempo de O (n / 2).

   private static void reverseArray() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   for (int i = 0; i < array.length / 2; i++) {
   int temp = array[i];
   int index = array.length - i - 1;
   array[i] = array[index];
   array[index] = temp;
   }
   System.out.println(Arrays.toString(array));

   }

2. Usando la función incorporada (Collections.reverse ())

   private static void reverseArrayUsingBuiltInFun() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   Collections.reverse(Ints.asList(array));
   System.out.println(Arrays.toString(array));

   }

   Salida: [6, 5, 4, 3, 2, 1]

Answer 3

A continuación se muestra el programa completo para ejecutar en su máquina.

public class ReverseArray {
public static void main(String[] args) {
int arr[] = new int[] { 10,20,30,50,70 };
System.out.println("reversing an array:");
for(int i = 0; i < arr.length / 2; i++){
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

Para los programas en matriz que utilizan matrices, esta será la buena fuente. Vaya a través del enlace.

Answer 4

Aquí hay una implementación simple para revertir la matriz de cualquier tipo , además de soporte total / parcial .

import java.util.logging.Logger;
public final class ArrayReverser {
private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());
private ArrayReverser () {
}
public static <T> void reverse(T[] seed) {
reverse(seed, 0, seed.length);
}
public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
if (seed == null || seed.length == 0) {
LOGGER.warning("Nothing to rotate");
}
int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
int end = Math.min(seed.length, endIndexExclusive) - 1;
while (start < end) {
swap(seed, start, end);
start++;
end--;
}
}
private static <T> void swap(T[] seed, int start, int end) {
T temp = seed[start];
seed[start] = seed[end];
seed[end] = temp;
}
}

Aquí está la prueba de unidad correspondiente

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
public class ArrayReverserTest {
private Integer[] seed;
@Before
public void doBeforeEachTestCase() {
this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}
@Test
public void wholeArrayReverse() {
ArrayReverser.<Integer>reverse(seed);
assertThat(seed[0], is(8));
}
@Test
public void partialArrayReverse() {
ArrayReverser.<Integer>reverse(seed, 1, 5);
assertThat(seed[1], is(5));
}
}

Answer 5

Así es como yo personalmente lo resolvería. La razón detrás de la creación del método parametrizado es permitir que se ordene cualquier matriz ... no solo sus enteros.

Espero que hayas recogido algo de ello.

@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;
}

Answer 6

Con Commons.Lang , simplemente puede usar

ArrayUtils.reverse(int[] array)

La mayoría de las veces, es más rápido y más seguro para los errores apegarse a las bibliotecas fácilmente disponibles que ya han sido probadas en unidades y probadas por el usuario cuando resuelven su problema.

Answer 7

Con guayaba:

Collections.reverse(Ints.asList(array));

Answer 8

Creo que es un poco más fácil seguir la lógica del algoritmo si declara variables explícitas para realizar un seguimiento de los índices que está intercambiando en cada iteración del bucle.

public static void reverse(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;
}
}

También creo que es más legible hacer esto en un bucle while.

public static void reverse(int[] data) {
int left = 0;
int right = data.length - 1;
while( left < right ) {
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
// move the left and right index pointers in toward the center
left++;
right--;
}
}

Answer 9

En el caso de Java 8 , también podemos utilizar flujos para invertir la matriz de enteros como:

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
.toArray(); //Output: [5, 4, 3, 2, 1]

Answer 10

Es más eficiente simplemente iterar la matriz hacia atrás.

No estoy seguro de si la solución de Aaron hace esto vi esta llamada Collections.reverse(list); ¿Alguien sabe?

Answer 11

Esto es lo que he encontrado:

// solution 1 - boiler plated
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];
int lastIdx = original.length -1;
int startIdx = 0;
for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
reverse[startIdx] = original[endIdx];
System.out.printf("reverse form: %s", Arrays.toString(reverse));
// solution 2 - abstracted
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

Answer 12

Esto te ayudara

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;
}

Answer 13

Hay dos formas de tener una solución para el problema:

1. Invertir una matriz en el espacio.

Paso 1. Intercambia los elementos al inicio y al índice final.

Paso 2. Incrementa el índice de inicio decrementa el índice final.

Paso 3. Iterar el Paso 1 y el Paso 2 hasta el índice de inicio <índice final

Para esto, la complejidad del tiempo será O (n) y la complejidad del espacio será O (1)

El código de ejemplo para revertir una matriz en el espacio es como:

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. Invierta una matriz utilizando una matriz auxiliar.

Paso 1. Crea una nueva matriz de tamaño igual a la matriz dada.

Paso 2. Inserte elementos en la nueva matriz comenzando desde el índice de inicio, desde la matriz dada comenzando desde el índice final.

Para esto, la complejidad del tiempo será O (n) y la complejidad del espacio será O (n)

El código de ejemplo para revertir una matriz con una matriz auxiliar es como:

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;
}

Además, podemos usar la API de colecciones de Java para hacer esto.

La API de colecciones utiliza internamente el mismo enfoque de reversa en el espacio.

El código de ejemplo para usar la API de colecciones es como:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
List<Integer> arrayList = Arrays.asList(array);
Collections.reverse(arrayList);
return arrayList.toArray(array);
}

Answer 14

Para revertir una matriz int, intercambias elementos hasta llegar al punto medio, como esto:

for(int i = 0; i < validData.length / 2; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}

De la forma en que lo haces, intercambias cada elemento dos veces, por lo que el resultado es el mismo que el de la lista inicial.

Answer 15

Si trabaja con datos más primitivos (es decir, char, byte, int, etc.), puede realizar algunas operaciones XOR divertidas.

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];
}
}

Answer 16

Simple para bucle!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}

Answer 17

Solución con o (n) complejidad de tiempo y o (1) complejidad de espacio.

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--;
}
}

Answer 18

Tu programa funcionará solo para length = 0, 1 . Puedes probar :

int i = 0, j = validData.length-1 ;
while(i < j)
{
swap(validData, i++, j--); // code for swap not shown, but easy enough
}

Answer 19

Usando la solución XOR para evitar la variable temporal que debería tener su código

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];
}

Vea este enlace para una mejor explicación:

http://betterexplained.com/articles/swap-two-variables-using-xor/

Answer 20

Ya hay muchas respuestas aquí, principalmente enfocadas en modificar la matriz en el lugar. Pero en aras de la integridad, aquí hay otro enfoque que utiliza las secuencias de Java para conservar la matriz original y crear una nueva matriz invertida:

 int[] a = {8, 6, 7, 5, 3, 0, 9};
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

Answer 21

 public static int[] reverse(int[] array) {
int j = array.length-1;
// swap the values at the left and right indices //////
for(int i=0; i<=j; i++)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
j--;
}
return array;
}
public static void main(String []args){
int[] data = {1,2,3,4,5,6,7,8,9};
reverse(data);
}

Answer 22

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse() puede revertir java.util.List s y java.util.Arrays.asList() devuelve una lista que contiene la matriz específica que le pasas, por lo que yourArray se invierte después de la invocación de Collections.reverse() .

El costo es solo la creación de un objeto de lista y no se requieren bibliotecas adicionales.

Se ha presentado una solución similar en la respuesta de Tarik y sus comentaristas, pero creo que esta respuesta sería más concisa y más fácil de analizar.

Answer 23

for(int i=validData.length-1; i>=0; i--){
System.out.println(validData[i]);
}

Answer 24

private static int[] reverse(int[] array){
int[] reversedArray = new int[array.length];
for(int i = 0; i < array.length; i++){
reversedArray[i] = array[array.length - i - 1];
}
return reversedArray;
}

Answer 25

public class ArrayHandle {
public static Object[] reverse(Object[] arr) {
List<Object> list = Arrays.asList(arr);
Collections.reverse(list);
return list.toArray();
}
}

Answer 26

public class TryReverse {
public static void main(String[] args) {
int [] array = {2,3,4,5,6,7,8,9};
reverse(array);
for(int i=0; i<array.length; ++i)
System.out.print(array[i] + " ");
}
public static void reverse (int [] array){
for(int start=0, end=array.length-1; start<=end; start++, end--){
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
}
}

Answer 27

public static void main (String args[]){
//create array
String[] stuff ={"eggs","lasers","hats","pie","apples"};
//print out array
for(String x :stuff)
System.out.printf("%s ", x);
System.out.println();
//print out array in reverse order
for(int i=stuff.length-1; i >= 0; i--)
System.out.printf("%s ",stuff[i]);
}

Answer 28

public void display(){
String x[]=new String [5];
for(int i = 4 ; i > = 0 ; i-- ){//runs backwards
//i is the nums running backwards therefore its printing from
//highest element to the lowest(ie the back of the array to the front) as i decrements
System.out.println(x[i]);
}
}

Answer 29

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;
}
}

Answer 30

static int[] reverseArray(int[] a) {
int ret[] = new int[a.length];
for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
ret[i] = a[j];
return ret;
}