Olá pessoal,
Fiz um exercício de estrutura de dados Lista Encadeada. Onde tenho que inserir elementos, verificar posição, remover, etc.
Consegui implementar praticamente todos os itens, somente o item remover pelo indice não esta compilando... É a opção 5 do menu.
Att,
interfacepackage aula;
/**
*
* @author professor
* @version 2
*/
public interface ILista {
/**
* Verifica se lista está vazia.
* @return true, se lista vazia ou false, caso contrário.
*/
public boolean isEmpty();
/**
* Retorna a qtde de elementos da lista.
* @return qtde de elementos da lista.
*/
public int size();
/**
* Limpa a lista, ou seja, remove todos elementos.
*/
public void clear();
/**
* Adicionar o elemento na última posição da lista.
* @param elemento elemento a ser inserido
* @return true se foi inserido, ou false se elemento nulo
*/
public boolean add(Object elemento);
/**
* Adicionar o elemento na posição indicada. A primeira posição é a 0 (zero).
* @param elemento elemento a ser inserido
* @param posicao posição de inserção na lista
* @return true se foi inserido, ou false se elemento nulo ou se posição for inválida (<0 ou > tamanho)
*/
public boolean add(int posicao, Object elemento);
/**
* Verifica se o elemento está lista.
* @param elemento elemento a ser pesquisado
* @return true, elemento presente na lista, ou false, caso contrário.
*/
public boolean contains(Object elemento);
/**
* Recupera o elemento que se encontra no índice informado
* @param indice índice que contém elemento desejado
* @return elemento recuperado ou null se posição inválida
*/
public Object get(int indice);
/**
* Recupera o índice do primeiro elemento informado.
* @param elemento elemento cujo índice será recuperado.
* @return índice do elemento informado ou -1 se elemento não se encontra na lista
*/
public int indexOf(Object elemento);
/**
* Recupera o último índice do elemento informado
* @param elemento a ser pesquisado
* @return último índice do elemento
*/
public int lastIndexOf(Object elemento);
/**
* Remove o elemento informado da lista.
* @param elemento elemento a ser removido
* @return true se elemento removido ou false se elemento não se encontra na lista
*/
public boolean remove(Object elemento);
/**
* Remove o elemento que se encontra no índice informado
* @param indice indice do elemento a ser removido
* @return elemento removido ou null se índice inválido
*/
public Object remove(int indice);
/**
* Retorna os elementos da lista dentro do um vetor
* @return Retorna os elementos da lista dentro do um vetor
*/
public Object[] toArray();
}
/**
*
*/
package aula;
/**
*
* @author ALUNOS
* @version 2
*
*/
public class ListaEncadeada implements ILista {
private static class Celula {
Object elemento;
Celula proximo;
}
private Celula primeira;
private int tamanho;
public ListaEncadeada() {
clear();
}
/*
* (non-Javadoc)
*
* @see aula.ILista#add(java.lang.Object)
*/
public boolean add(Object elemento) {
if (elemento == null) {
return false;
}
Celula novaCelula = new Celula();
novaCelula.elemento = elemento;
novaCelula.proximo = null;
if (isEmpty()) {
primeira = novaCelula;
} else {
Celula ultimaCel = primeira;
// Percorre a lista até chegar na última célula
while (ultimaCel.proximo != null) {
ultimaCel = ultimaCel.proximo;
}
ultimaCel.proximo = novaCelula;
}
tamanho++;
return true;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#add(int, java.lang.Object)
*/
public boolean add(int posicao, Object elemento) {
if (posicao < 0 || posicao > tamanho) {
return false;
}
Celula novaCelula = new Celula();
novaCelula.elemento = elemento;
if (isEmpty() || posicao==0) {
novaCelula.proximo = isEmpty()? null:primeira;
primeira = novaCelula;
} else {
Celula celAnt = primeira;
// Percorre a lista até chegar na posição da
// célula a ser inserida
int cont = 1;
while (posicao > cont ) {
cont++;
celAnt = celAnt.proximo;
}
novaCelula.proximo = celAnt.proximo;
celAnt.proximo = novaCelula;
}
tamanho++;
return true;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#clear()
*/
public void clear() {
tamanho = 0;
primeira = null;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#contains(java.lang.Object)
*/
public boolean contains(Object elemento) {
// Consulta se o elemento esta na lista
Celula aux = new Celula();
aux = primeira;
while (aux != null) {
if (aux.elemento.equals(elemento)){
return true;
}
aux = aux.proximo;
}
return false;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#get(int)
*/
public Object get(int indice) {
if (indice < 0 || indice >= tamanho){
return null;
}
Celula aux = primeira;
int cont = 0;
while (cont < indice) {
cont++;
aux = aux.proximo;
}
return aux.elemento;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#indexOf(java.lang.Object)
*/
public int indexOf(Object elemento) {
int cont = 0;
Celula aux = primeira;
while (aux != null) {
if (aux.elemento.equals(elemento)){
return cont;
}
aux = aux.proximo;
cont++;
}
return -1;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#isEmpty()
*/
public boolean isEmpty() {
return tamanho == 0;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#lastIndexOf(java.lang.Object)
*/
public int lastIndexOf(Object elemento) {
int cont = 0;
int cont2 = -1;
Celula aux = primeira;
while (aux != null) {
if (aux.elemento.equals(elemento)){
cont2 = cont;
}
aux = aux.proximo;
cont++;
}
return cont2;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#remove(java.lang.Object)
*/
public boolean remove(Object elemento) {
if (isEmpty()) {
return false;
} else {
if (primeira.elemento.equals(elemento)) {
primeira = primeira.proximo;
} else {
Celula cel = primeira;
while (cel.proximo != null && !cel.proximo.elemento.equals(elemento)) {
cel = cel.proximo;
}
// Se saiu do loop é porque chegou ao final e não achou
// OU porque achou
if (cel.proximo == null) {
return false;
} else {
// Achou
cel.proximo = cel.proximo.proximo;
}
}
tamanho--;
return true;
}
}
/*
* (non-Javadoc)
*
* @see aula.ILista#remove(int)
*/
public Object remove(int indice){
String retorno = null;
String novoindice = indice + "";
if (isEmpty()) {
return retorno;
} else {
if (primeira.proximo.equals(novoindice)) {
primeira = primeira.proximo;
retorno = primeira.elemento + "";
} else {
Celula cel = primeira;
while (cel.proximo != null && !cel.proximo.elemento.equals(novoindice)) {
cel = cel.proximo;
}
// Se saiu do loop é porque chegou ao final e não achou
// OU porque achou
if (cel.proximo == null) {
return retorno;
} else {
// Achou
cel.proximo = cel.proximo.proximo;
retorno = cel.elemento + "";
}
}
tamanho--;
return retorno;
}
}
/*
* (non-Javadoc)
*
* @see aula.ILista#size()
*/
public int size() {
return tamanho;
}
/*
* (non-Javadoc)
*
* @see aula.ILista#toArray()
*/
public Object[] toArray() {
// TODO Trabalho Prático sobre Lista
return null;
}
public String toString() {
if (!isEmpty()) {
String retorno = "[ ";
Celula aux = primeira;
while (aux.proximo != null) {
retorno += aux.elemento + ", ";
aux = aux.proximo;
}
retorno += aux.elemento + " ]";
return retorno;
} else {
return "A lista esta vazia";
}
}
}
package aula;
import java.util.Scanner;
/**
*
* Classe que testa a classe ListaEncadeada rodando aplicação para gerenciamento
* de uma lista de alunos.
*
* @author ALUNOS
* @version 2
*
*/
public class TestaListaEncadeada {
private static final String MARCADOR = "\t--> ";
/**
* Imprime mensagem recebida com marcador na frente
*
* @param mensagem
* mensagem a ser impressa
*/
private static void imprimeMensagem(String mensagem) {
System.out.println(MARCADOR + mensagem);
}
/**
* Imprime na mesma linha mensagem de leitura de valor recebida com marcador
* na frente e dois pontos no final
*
* @param mensagem
* mensagem de leitura a ser impressa
*/
private static void imprimeMensagemLeitura(String mensagem) {
System.out.print(MARCADOR + mensagem + ": ");
}
/**
* Imprime mensagem de erro recebida com marcador na frente e a palavra ERRO
*
* @param mensagem
* mensagem de erro a ser impressa
*/
private static void imprimeMensagemErro(String mensagem) {
System.out.println(MARCADOR + "ERRO: " + mensagem);
}
/**
* Imprime mensagem de sucesso recebida com marcador na frente e a palavra
* SUCESSO
*
* @param mensagem
* mensagem de sucesso a ser impressa
*/
private static void imprimeMensagemSucesso(String mensagem) {
System.out.println(MARCADOR + "SUCESSO: " + mensagem);
}
/**
* Método principal que roda gerenciador de alunos
*
* @param args
*/
public static void main(String[] args) {
ListaEncadeada lista = new ListaEncadeada();
String nomeAluno;
int opcao;
Scanner sc = new Scanner(System.in);
System.out
.println("---------------------------------------------------------");
System.out
.println("SIGA - Sistema de Gestão de Alunos usando LISTA ENCADEADA");
System.out
.println("---------------------------------------------------------\n");
while (true) {
System.out.println("MENU PRINCIPAL:");
System.out.println(" 1 - Listar alunos com total\n"
+ " 2 - Adicionar aluno no final da lista\n"
+ " 3 - Adicionar aluno em determinada posição\n"
+ " 4 - Remover aluno\n"
+ " 5 - Remover aluno em determinada posição\n"
+ " 6 - Limpar lista\n"
+ " 7 - Consultar se aluno está na lista\n"
+ " 8 - Consultar aluno em determinada posição\n"
+ " 9 - Consultar posição do aluno\n"
+ " 10 - Consultar última posição do aluno\n"
+ " 0 - Sair");
System.out.print("\n\tOpção: ");
opcao = sc.nextInt();
sc.nextLine();
System.out.println();
switch (opcao) {
case 0:
// Sair
System.out.println("\n\t*** FIM ***\n");
return;
case 1:
// Listar alunos com total
imprimeMensagem(lista.size() + ": " + lista);
break;
case 2:
// Adicionar aluno no final da lista
imprimeMensagemLeitura("Nome para incluir");
nomeAluno = sc.nextLine();
if (lista.add(nomeAluno)) {
imprimeMensagemSucesso("Aluno incluído com sucesso.");
} else {
imprimeMensagemErro("Aluno NÃO FOI incluído.");
}
break;
case 3: // Adicionar aluno em determinada posição
imprimeMensagemLeitura("Indice para incluir");
int indice =sc.nextInt();
indice -= 1;
imprimeMensagemLeitura("Nome para incluir");
sc.nextLine();
nomeAluno = sc.nextLine();
if (lista.add(indice, nomeAluno)) {
imprimeMensagemSucesso("Aluno incluído com sucesso.");
} else {
imprimeMensagemErro("Aluno NÃO FOI incluído.");
}
break;
case 4:
// Remover aluno
imprimeMensagemLeitura("Nome para remover");
nomeAluno = sc.nextLine();
if (lista.remove(nomeAluno)) {
imprimeMensagemSucesso("Aluno removido com sucesso.");
} else {
imprimeMensagemErro("Aluno NÃO FOI removido, porque ele não está na lista.");
}
break;
case 5:
// Remover aluno pelo indice
imprimeMensagemLeitura("Indice para remover");
int removeIndice = sc.nextInt();
Object valor = lista.remove(removeIndice);
//if (valor != null) {
imprimeMensagemSucesso(valor + "");
//} else {
// imprimeMensagemErro("Aluno NÃO FOI incluido, porque ele não está na lista.");
//}
break;
case 6:
// Limpar lista
lista.clear();
imprimeMensagemSucesso("Lista limpa.");
break;
case 7:
// Consulta se o nome informado esta na lista.
imprimeMensagemLeitura("Nome para consultar");
nomeAluno = sc.nextLine();
if (lista.contains(nomeAluno)) {
imprimeMensagemSucesso("O Aluno esta na lista");
} else {
imprimeMensagemErro("Aluno NÃO está na lista");
}
break;
case 8:
// Consulta se o nome informado esta na lista.
imprimeMensagemLeitura("Indice para consultar");
indice = sc.nextInt();
indice -= 1;
Object nome = lista.get(indice);
if (nome == null){
imprimeMensagemErro("Aluno NÃO está na lista");
} else {
imprimeMensagemSucesso("Nome encontrado: " + nome);
}
break;
case 9:
// Consultar o indice do primeiro elemento
imprimeMensagemLeitura("Nome para consultar");
nomeAluno = sc.nextLine();
if (lista.indexOf(nomeAluno) >= 0){
imprimeMensagemSucesso("Posição: " + (1 + lista.indexOf(nomeAluno)));
} else {
imprimeMensagemErro("Aluno NÃO está na lista");
}
break;
case 10:
// Consultar o indice do último elemento
imprimeMensagemLeitura("Nome para consultar");
nomeAluno = sc.nextLine();
if (lista.lastIndexOf(nomeAluno) >= 0){
imprimeMensagemSucesso("Posição: " + (1 + lista.lastIndexOf(nomeAluno)));
} else {
imprimeMensagemErro("Aluno NÃO está na lista");
}
break;
default:
imprimeMensagemErro("Opção inválida!");
break;
}
System.out.println();
}
}
}
Agradeço quem puder ajudar.
Att,
Rodrigo
