Melhor forma de resolver uma inversão de valores em um vetor

Bom... se vc tentar compilar esse negocio ae... não vai dar muito certo não... rsrsrs

Eu acho que a melhor maneira é usando um "for each":

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21}  
  int[] b = new int[a.length];  
  int posicao = 0;  

  for(int i : a){
        b[posicao] = i;  
        posicao++;  
  }

Isto ajuda?

List<Integer> l = new ArrayList<Integer>();
		l.add(10);
		l.add(11);
		l.add(12);
		
		Collections.reverse(l);
		
		for(Integer value : l) {
			System.out.println(value);
		}

12
11
10

Se quiser, podes transformar o teu vetor em um List e depois realizar esta operação.
Abraços.

hmm mas o b eu taria usando como variavel auxiliar, é eu sei que num ia compilar, mas é que hoje eu vi isso em natural aqui e fiquei na duvida como faria em java, dai como não tenho nenhum IDE aqui e muito tempo sem desenvolver em java fico um pouco perdido na sintaxe

Lembrando que para implementações de List existe o Collections.reverse();
Talvez ainda não seja a melhor solução mas:

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21}
int count = 0;
int length = (int)a.length/2+1 //só precisa ir até a metade +1 (o cast é pra converter o resultado da divisão que será double)

for(int i = length; i == o; i--){

int tmp = a[i]; //guarda o valor num campo temporário
//inverte os dados
a[i] = a[count]; 
a[count] = tmp;

count++;
}

Se preferir, podes alterar o int para um wrapper Integer e depois fazer a conversão para um List.
Assim:

Integer[] a = new Integer[]{10, 11, 12};
List<Integer> l = Arrays.asList(a);
				
Collections.reverse(l);
		
for(Integer value : l) {
    System.out.println(value);
}

Todos da classe java.util :)

A inversão é realizada sem problemas.
Abraços.

A sim, em C programa-se exatamente igual hahuauhauhauhauha
Se puder usar collections… use implementações de Lists.
Mas antes de escolher a sua implementação sugiro uma boa estudada a respeito.

mas não intendi porque precisa ir so até a metade

Por que ao inverter o primeiro elemento com o último, o último já recebe o primeiro elemento elemento também e assim por diante.
Daí não precisa continuar depois da metade por que já foi feita essa permuta.

Por que ao inverter o primeiro elemento com o último, o último já recebe o primeiro elemento elemento também e assim por diante.
Daí não precisa continuar depois da metade por que já foi feita essa permuta.

mas fui fazer aqui no papel e fiquei na duvida porque:

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21}   
int count = 0;   
int length = (int)a.length/2+1 //só precisa ir até a metade +1 (o cast é pra converter o resultado da divisão que será double)   
  
for(int i = length; i == o; i--){   
  
int tmp = a[i]; //Aqui receberia 53  
//inverte os dados   
a[i] = a[count];//aqui a posição zero ia receber 53   
a[count] = tmp; // e aqui a posição 8 iria receber 1  
  
count++;   
}

edit: inverti os dois ultimos comentarios

Ou, em Scala:

val a = Array(1, 3, 5, 7, 33, 44, 6, 61, 53, 12, 42, 76, 99, 90, 21)
val rev = a.reverse

dev.rafael:

Ou, em Scala:

val a = Array(1, 3, 5, 7, 33, 44, 6, 61, 53, 12, 42, 76, 99, 90, 21) val rev = a.reverse

mas eu queria fazer isso independente da linguagem ou seja sem metodos que eu encontraria apenas em certas linguagens.

Foi mal kra, eu ñ estava tentando ajudar, apenas puxar um pouco o saco de Scala!!!

^^
noops,=0

Marky.Vasconcelos:

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21} int lgt = a.length; int[] b = new int[lgt]; for(int i = 0; i<lgt; i++) b[i] = a[lgt - i]; a = b;

gostei dessa solução ^^ mas muito parecida com a que eu propus =x sera q não tem uma forma melhor não?

Tem:

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21}
int lgt = a.length;
for(int i = 0; i<lgt/2; i++){
a[i] += a[lgt - i];
a[lgt - i] = a[i] - a[lgt - i];
a[i] -= a[lgt - i];
}

Mais que isso só com a API collections.

Na verdade eu me equivoquei, segue a correção do algoritmo:

int[] a = {1,3,5,7,33,44,6,61,53,12,42,76,99,90,21}
for (int i = 0; i < a.length / 2; i++) {

			int tmp = a[i];

			a[i] = a[a.length - i - 1];
			a[a.length - i - 1] = tmp;

		}
}

Como eu disse lá atrás, o uso da API Collections resolveria facilmente o seu problema, mas vejo que não queres usar de nenhuma API, perfeito?
No meu humilde ponto de vista, a melhor solução é aquela que efetua a junção de legibilidade do código e perfomance, lógico, que faça corretamente a sua função.

Para tal, teria que pegar cada solução dada e efetuar testes e depois sim, tirar uma conclusão.
Já foram dadas algumas soluções, portanto, basta você escolher uma delas, seja por análise ou aleatoriamente, e aplicar a sua necessidade.

Abraços.

Se você der uma olhada na lógica de implementação do Collections.reverse(), não difere em nada de boas soluções postadas pelo Tchello e Marky.Vasconcelos.

Sim, eu sei.
Mas é igual eu e o Mark comentamos, pode-se usar a API.

Até porque, você só desenvolve algo que o Java já implementou se tiver certeza que o seu é melhor, caso contrário, porque exercer este esforço?
Só se for a título de experiência, praticar ou simplesmente “porque quis”.

Logicamente, estou falando em desenvolver algo exatamente ao que já está implementando, como é o caso citado aqui.
Abraços!

nel:

Sim, eu sei.
Mas é igual eu e o Mark comentamos, pode-se usar a API.

Até porque, você só desenvolve algo que o Java já implementou se tiver certeza que o seu é melhor, caso contrário, porque exercer este esforço?
Só se for a título de experiência, praticar ou simplesmente “porque quis”.

Logicamente, estou falando em desenvolver algo exatamente ao que já está implementando, como é o caso citado aqui.
Abraços!

Putz, foi mal. Ficou mesmo parecendo que eu tava falando diretamente com você. Na verdade foi pro autor do post. Só pra mostrar que as soluções postadas foram boas mesmo. Afinal, a mesma idéia foi usada na JRE. E de quebrar dar uma dica de uma fonte boa para procurar este tipo de algoritmo. :thumbup:

nel:

Como eu disse lá atrás, o uso da API Collections resolveria facilmente o seu problema, mas vejo que não queres usar de nenhuma API, perfeito?
No meu humilde ponto de vista, a melhor solução é aquela que efetua a junção de legibilidade do código e perfomance, lógico, que faça corretamente a sua função.

Para tal, teria que pegar cada solução dada e efetuar testes e depois sim, tirar uma conclusão.
Já foram dadas algumas soluções, portanto, basta você escolher uma delas, seja por análise ou aleatoriamente, e aplicar a sua necessidade.

Abraços.

Intendi mas é que eu tava querendo mais um portugol que tdo saca? pois eu tive que fazer essa implementação em natural, dai eu pensei bem como poderia melhorar isso ainda mais e ser utilizado em qualquer linguagem, que nem o metodo bolha.

A unica diferença entre o meu algoritmo e o do Tchello é o como fazer o swap dos dados, se isso fosse em C eu teria economizado a variavel tmp. (Isso depois que ele mudou)
Antes tinha o fato de usar (lgt - i) invés de um count.