Como ordenar palavras de um array pela sequencia que eu quiser,
por exemplo
não quero alfabética quero que o “z” venha após o “a” e assim por diante
1 curtida
Olhe o algorítimo bubble sort
Eu não quero ordenar alfabeticamente quero criar uma ordenação, qual é a maneira mais fácil de fazer isso?
Seja mais específico no que você quer dizer, não entendi bem.Se quer criar uma ordenação que não segue uma linha lógica como ordem alfabética ou numerica, se quer criar uma ordenação sua é isso?Tipo, se você pegar um array assim
a[] = {1,2,3,4,5,6,7,8,9}
o seu código o transforma em:
a[] = {5,4,7,8,9,6,1,3,2}
isso?
isso!
por exemplo ao invés de : a,b,c,d,e
quero ordenar: a,z,b,x,c,s
entendi
mas se quer uma coisa aleatória ou se quer sempre de um jeito
tipo a saida do array
{1,2,3,4,5,} é sempre {5,2,1,3,4}?
ou cada vez que se executa o programa ele faz uma ordenação diferente?
não quero aleatória, quero estabelecer uma sequencia de saída.
Ta, vou ver aqui o que posso fazer, e te passo.
Por que você não cria um método que recebe um array como parametro e depois dentro desse método cria outro array dentro dele e o retorna com os itens compostos dos arrays que ele recebeu como parametro?
Ou se quiser usa lista que é mais fácil.
não resolve meu problema…
eu gostaria de saber se existe algum método que eu possa passar de um lado a lista e de outro a sequencia que quero que ela seja ordenada, não digo isso apenas da primeira letra da palavra, mas todas ordenadas da forma como estabeleci.
Álgebra, implemente um Comparator próprio. Ele deve definir a ordem que você quiser:
Com ele, você pode chamar os métodos Arrays.sort para arrays primitivos ou Collections.sort para coleções.
Você falou sério? Existem diversos algorítmos muito mais eficientes, além de métodos de ordenação prontos implementados no próprio Java.
to ViniGodoy:Sim falei sério, é um algoritimo que eu ja conhecia e não sabia exatamente o que ele queria fazer.
Muito obrigado ViniGodoy, mas eu gostaria de saber como utilizo este Comparator para criar uma sequencia de ordem própria, me de apenas uma ideia.
Abraços
EU, não conheço nenhum método assim, que você possa passar a ordem que se quer, eu criaria um método como eu disse.
Você só precisa escrever uma função que, dada duas Strings, diga se uma é maior, menor ou igual a outra.
Por exemplo vamos supor que, ao invés de ordenar uma sequencia por ordem alfabética, você queira ordenar pelo tamanho das palavras. O comparador seria implementado assim:
public class TamanhoComparator implements Comparator<String> {
public int compareTo(String o1, String o2) {
if (o1.length < o2.length)
return -1; //o1 vem antes, retornamos < 0
if (o2.length < o1.length)
return 1; //o2 vem antes, retornamos > 0
return 0; //São iguais.
}
}
Então, seria fácil ordenar esse array:
String palavras[] = {"Vinícius", "Algebra", "xxmayconxx", "Beto", "Creta", "Isopropílico", "Mel"};
Arrays.sort(palavras);
Para uma ordenação lexicográfica, como vc quer, eu faria assim:
- Todo char é implementado como um número, sendo o A maiusculo o 65. Portanto ‘A’-65 = 0;
- Portanto, é possível montar um array de inteiros, contendo a posição das letras na ordem que você deseja. Vamos supor, que seu alfabeto seja A, B, C, D, e você queria na ordem B, A, D, C. Esse array seria:
ordem[0] = 2; //Posição o A no novo alfabeto
ordem[1] = 1; //Posição do B no novo alfabeto
ordem[2] = 4; //Posição do C no novo alfabeto
ordem[3] = 3; //Posição do D no novo alfabeto
- Para cada letra i, nas duas palavras:
- Obtém-se o índice da i-ésima letra através da formula:
índice = Código ascii da letra - 65 - Compara-se o valor ordem[i] de cada palavra. Se o valor da primeira palavra for < que o da segunda, retorna-se -1. Se o da segunda for maior que o da primeira, retorna-se 1. Caso contrário, adicione um ao i e prossiga para a próxima letra.
Se todas as letras forem iguais:
3. Retorna-se -1 caso a palavra 1 seja menor que a palavra 2, retorna-se 1 caso a palavra 2 seja menor que a palavra 1, ou 0 se forem iguais.
Vamos supor as palavras CADA e CACACA
1ª letra: Palavra 1: Índice de C = 67 - 65 = 2. Palavra 2: Índice de C = 67 - 65 = 2.
Como ordem[2] == ordem[2] == 4, então, continua-se o algorítmo
2ª letra: Palavra 1: Índice de A = 65 - 65 = 0. Palavra 2: Índice de A = 65 - 65 = 0.
Como ordem[0] == ordem[0] == 2, então, continua-se o algorítmo
3ª letra: Palavra 1: Índice de D = 68 - 65 = 3. Palavra 2: Índice de C = 67 - 65 = 2.
Como ordem[3] = 3 e ordem[2] = 4, logo palavra 1 < palavra 2. Portanto, o algorítmo retorna -1.
(Note que acamos que indicar que o “D” precede o “C”, como queríamos).
Isso me lembra um exercício do google que discuti com o Mark há alguns dias atrás.
PS: Caso você trabalhe com Unicode, pode ser interessante definir a tabela de ordem num Map<Character, Integer>, ao invés de um array de primitivos. Assim, o próprio char poderia ser a entrada do map:
A mesma tabela de ordem ficaria:
Map<Character, Integer> ordem = new HashMap<Character, Integer>();
ordem.put('A', 2);
ordem.put('B', 1);
ordem.put('C', 4);
ordem.put('D', 5);
E isso também evitaria calculos, por exemplo:
int o1 = ordem.get(palavra1.charAt(i));
int o2 = ordem.get(palavra2.charAt(i));
if (o1 < o2)
return -1;
if (o1 > o2)
return 1;
Com Map eu já consegui ordenando só pela primeira letra da palavra, mas como já te disse quero ordenar por todas as letras da palavra na sequencia que eu defini e não consigo enxergar isso. 
Releia o meu post. Eu descrevi detalhadamente um algorítmo que considera cada uma das letras da palavra, e ainda postei um exemplo de como vc deve fazer a comparação…
Segue um exemplo do algorítmo implementado:
[code]import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
public class OrdemAlien {
public static void main(String[] args) {
String[] palavras = {“babaca”, “bebada”, “aebeo”, “feio”, “eba”, “ebada”, “agoda”, “agoudo”, “hoda”, “foca”, “faca”, “fuca”, “facada”};
Arrays.sort(palavras, new AlienComparator());
for (String palavra : palavras)
System.out.println(palavra);
}
}
//Considera um alfabeto formado pelas letras u,i,o,e,h,b,c,d,f,g,a - nesta ordem.
class AlienComparator implements Comparator<String>
{
private Map<Character, Integer> ordem = new HashMap<Character, Integer>();
public AlienComparator() {
ordem.put('U', 1);
ordem.put('I', 2);
ordem.put('O', 3);
ordem.put('E', 4);
ordem.put('H', 5);
ordem.put('B', 6);
ordem.put('C', 7);
ordem.put('D', 8);
ordem.put('F', 9);
ordem.put('G', 10);
ordem.put('A', 11);
}
@Override
public int compare(String o1, String o2) {
String str1 = o1.toUpperCase();
String str2 = o2.toUpperCase();
for (int i = 0; i < Math.min(o1.length(), o2.length()); i++)
{
int ordem1 = ordem.get(str1.charAt(i));
int ordem2 = ordem.get(str2.charAt(i));
if (ordem1 != ordem2)
return ordem1 - ordem2;
}
return o1.length() - o2.length();
}
}[/code]
Se quiser definir uma nova ordem para as letras, simplesmente altere o map.