Boa noite…gostaria de ajuda para resolver o seguinte exercicio :
Implementar na classe ListSimpleLinked o método de ordenação sort() que foi adicionado à interface ListTAD. O método de ordenação
deverá utilizar o seguinte algoritmo de ordenação.
Classificação por seleção:
O algoritmo constrói a seqüência classificada com um elemento de cada vez adicionando os elementos na seqüência em ordem. A cada
passo, o elemento a ser adicionado à seqüência classificada é selecionado dos elementos restantes. Devido aos elementos serem
adicionados em ordem, eles são sempre inseridos em uma extremidade.
Para i de 0 até tamanho da lista-1 {
minPos = posição do menor elemento a partir da posição i;
troque de posição os elementos das posições minPos e i;
}
Ex.:
11,9,17,5,12 i=0
5,|9,17,11,12 i=1
5,9,|17,11,12 i=2
5,9,11,|17,12 i=3
5,9,11,12,|17 i=4
Dica I: a classe Pessoa deve implementar a interface Comparable e a classe ListSimpleLinked só pode receber elementos que
implementem esta interface.
Dica II: o método de ordenação deve utilizar o método de comparação de elementos compareTo().
Dica III: implemente um método private para retornar a posição do menor elemento a partir da posição i.
Alterar o tratamento de evento dos botões ?Listar Homens? e ?Listar Mulheres? de modo que a listagem de pessoa seja ordenada
alfabeticamente em ordem crescente.
[quote=renrutal]Sim, e cadê as classes Pessoa, SimpleLinkedList, a interface ListTAD?
E qual é a dúvida no teu código?[/quote]
PESSOA
public class Pessoa {
private String nome;
private char sexo;
public Pessoa(String umNome, boolean masculino) {
nome = umNome;
if(masculino) {
sexo = 'M';
}
else {
sexo = 'F';
}
}
public String getNome() {
return nome;
}
public char getSexo() {
return sexo;
}
public String toString() {
return "["+nome+","+sexo+"]";
}
public boolean equals(Object o) {
if(o == null)
return false;
if(getClass() != o.getClass())
return false;
Pessoa outraPess = (Pessoa) o;
if((nome.equals(outraPess.nome)))
return true;
else
return false;
}
}
ListSimpleLinked
public class ListSimpleLinked implements ListTAD
{
// Referência para o primeiro elemento da lista encadeada.
private Nodo prim;
// Referência para o último elemento da lista encadeada.
private Nodo ult;
// Contabiliza o número de elementos da lista.
private int totalElementos;
// Classe interna Nodo
private class Nodo<T> {
private T element;
private Nodo<T> next;
public Nodo(T e) {
element = e;
next = null;
}
public void setElement(T e) {
element = e;
}
public void setNext (Nodo<T> n) {
next = n;
}
public T getElement() {
return element;
}
public Nodo<T> getNext() {
return next;
}
}
public ListSimpleLinked () {
prim = null;
ult = null;
totalElementos = 0;
}
ListTAD
public interface ListTAD
{
/**
* Adiciona um elemento ao final da lista
* @param element elemento a ser adicionado ao final da lista /
public void add(E e);
/*
* Insere um elemento em uma determinada posição da lista
* @param index a posição da lista onde o elemento será inserido
* @param element elemento a ser inserido
* @throws IndexOutOfBoundsException se (index < 0 || index > size()) /
public void add (int index, E element);
/*
* Esvazia a lista /
public void clear();
/*
* Retorna true se a lista contém o elemento especificado
* @param element o elemento a ser testado
* @return true se a lista contém o elemento especificado /
public boolean contains(E e);
/*
* Retorna o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento da posição especificada
* @throws IndexOutOfBoundsException se (index < 0 || index >= size()) /
public E get(int index);
/*
* Retorna o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento
* @param element o elemento a ser buscado
* @return o índice da primeira ocorrência do elemento na lista, ou -1 se a lista não contém o elemento /
public int indexOf (E e);
/*
* Retorna true se a lista não contêm elementos
* @return true se a lista não contêm elementos /
public boolean isEmpty();
/*
* Remove a primeira ocorrência do elemento na lista, se estiver presente
* @param element o elemento a ser removido
* @return true se a lista contém o elemento especificado /
public boolean remove(E e);
/*
* Remove o elemento de uma determinada posição da lista
* @param index a posição da lista
* @return o elemento que foi removido da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size()) /
public E remove(int index);
/*
* Retorna o número de elementos da lista
* @return o número de elementos da lista /
public int size();
/*
* Substitui o elemento armanzenado em uma determinada posição da lista pelo elemento indicado
* @param index a posição da lista
* @param element o elemento a ser armazenado na lista
* @return o elemento anterior armazenado na posição da lista
* @throws IndexOutOfBoundsException se (index < 0 || index >= size()) /
public E set(int index, E element);
public void addFirst(E e);
public E getFirst();
public E getLast();
public boolean removeFirst();
public boolean removeLast();
/*
* Ordena a lista de acordo com a ordenação natural dos elementos, que devem implementar a interface Comparable
*/
public void sort();
}
***Minhas duvidas são quanto a implementação dos metodos que o exercicio pede…“sort, set E int(index, E element)…”
Primeiro, implemente a interface Comparable na classe Pessoa. Tem uma explicação sobre ele aqui (na verdade é sobre o Comparator, que é quase a mesma coisa).
Sobre o sort, é exatamente como o exercício fala, para cada elemento à frente da sua posição na lista, encontre o menor de todos(usando o tal método private) e troque de lugar com ele.
Sobre o set, você vai até a posição indicada e sobreescreve o valor lá pelo novo que foi passado por parâmetro.
PS: pelamordedeus use a as tags [code] ao redor do seu código.
Swap pega dois nós e trocam os seus elementos entre si.
O mais indicado seria deixar os elementos como estão e trocar de lugar somente os nodos, mas isso dá muito trabalho numa lista simplesmente ligada, mais fácil numa em uma duplamente ligada(que aponta para o próximo e para o anterior).