Já vi aqui no VOL alguns membros postarem dúvidas sobre implementação de algoritmos relacionados a estrutura de dados, tais como fila dinâmica implementada em C com uso de ponteiros. O que eu ainda não vi, posso estar enganado, foi um algoritmo desse gênero orientado a objetos. Sendo assim implementei uma uma lista duplamente encadeada, orientada a objetos em Java usando o Eclipse.

A lista possui métodos para inserir valores no inicio e fim da lista, pesquisar um valor e listar os valores da lista. Implementei o algoritmo de forma que não é possível inserir um valor que já existe na lista na mesma. Além disso o algoritmo possui duas classe para tratamento de exceção do algoritmo com herança das classes Exception e NullPointerException.

É só baixar e importar no Eclipse. Para quem for copiar, não esqueça de criar as classes, são 4 no total.

Apesar de os comentários não estarem muito didáticos, espero que seja útil a algum membro.

• Download Lista_Encadeada.rar
• Enviar nova versão

Esconder código-fonte

//Classe Nodo:

public class Nodo {
   private Nodo anterior;      
   private Nodo proximo;
   private String valor;      
   //Define valor do nó.
   public void setValor(String valor) {
      this.valor = valor;
   }
   //Retorna valor do nó.
   public String getValor() {
      return valor;
   }
   //Define nó anterior.
   public void setAnterior(Nodo anterior) {
      this.anterior = anterior;
   }
   //Retorna nó anterior
   public Nodo getAnterior() {
      return anterior;
   }
   //Define proximo nó.
   public void setProximo(Nodo proximo) {
      this.proximo = proximo;
   }
   //Retorna proximo nó
   public Nodo getProximo() {
      return proximo;
   }
}

//Classe Lista

import java.util.ArrayList;
public class Lista {
   private Nodo primeiro = null, ultimo = null;   
   //Define nó como primeiro da lista.
   public void setPrimeiro(Nodo primeiro) {
      this.primeiro = primeiro;
   }
   //Retorna o primeiro nó da lista.
   public Nodo getPrimeiro() {
      return primeiro;
   }
   //Define nó como ultimo da lista.
   public void setUltimo(Nodo ultimo) {
      this.ultimo = ultimo;
   }
   //Retorna ultimo nó da lista.
   public Nodo getUltimo() {
      return ultimo;
   }
   //Percorre os nós da lista atribuindo os valores de cada nó em um ArrayList enquanto o próximo nó não for nulo.
   public ArrayList<String> Listar() throws EmptyListException  {
      ArrayList<String> lista = new ArrayList<String>();      
      if(primeiro == null)
         throw new EmptyListException("A lista esta vazia!");      
      else{
         Nodo aux = getPrimeiro();         
         while(aux != null){
            String vl = aux.getValor(); 
            lista.add(vl);
            aux = aux.getProximo();
         }
         return lista;
      }      
   }
   //Percorre os nós da lista comparando os valores de cada nó com o valor passado por parametro enquanto o próximo nó não for nulo.
   public boolean Procura(String valor){
      Nodo aux = getPrimeiro();      
      while(aux != null){
         if(valor.equals(aux.getValor())){
            return true;
         }
         aux = aux.getProximo();
      }
      return false;
   }
   //Insere valor passado por parametro no inicio da lista, se o valor não existir na lista.
   public void Insere_Inicio(String valor) throws ExistentValueException{      
      boolean procura = false;      
      procura = Procura(valor);      
      if (procura == false){      
         Nodo novo = new Nodo();         
         if (primeiro == null){
            novo.setValor(valor);
            setPrimeiro(novo);
            setUltimo(novo);
         }         
         else{
            primeiro.setAnterior(novo);
            novo.setValor(valor);
            novo.setProximo(primeiro);
            setPrimeiro(novo);            
         }
      }
      else{
         throw new ExistentValueException("Valor já existe na lista!");
      }
   }
   //Insere valor passado por parametro no fim da lista, se o valor não existir na lista.
   public void Insere_Fim(String valor) throws ExistentValueException{
      Nodo novo = new Nodo();      
      boolean procura = false;      
      procura = Procura(valor);      
      if(procura == true)
         throw new ExistentValueException("Valor já existe na lista!");      
      else{
         if(ultimo == null){         
            novo.setValor(valor);
            primeiro = novo;
            ultimo = novo;         
         }
         else{
            ultimo.setProximo(novo);
            novo.setValor(valor);
            ultimo = novo;
         }
      }
   }   
}

//Classe EmptyListException

public class EmptyListException extends NullPointerException{
   public EmptyListException(){
      super();
   }
   public EmptyListException(String msg){
      super(msg);
   }
}

//Classe ExistentValueException

public class ExistentValueException extends Exception{   
   public ExistentValueException(){
      super();
   }   
   public ExistentValueException(String msg){
      super(msg);
   }
}

//Classe Testa_Lista

import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Testa_Lista {   
   public static void main(String[] args) {      
      Scanner sc = new Scanner(System.in);      
      Lista lista = new Lista();      
      String valor = null, resp = null;      
      do{         
         System.out.println("Escolha a opção\n1->Inserir no Início:\n2->Inserir no fim:\n3->Pesquisar um valor:\n4->Listar valores da lista:");      
         resp = sc.next();         
         if(resp.equals("1")){
            System.out.println("Digite um valor:");
            valor = sc.next();
            //Insere valore no inicio da lista.
            try {
               lista.Insere_Inicio(valor);
            } 
            catch (ExistentValueException e) {               
               e.printStackTrace();
            }
         }            
         else if(resp.equals("2")){
            System.out.println("Digite um valor:");
            valor = sc.next();
            //Insere valores no final da lista.
            try {
               lista.Insere_Fim(valor);
            } 
            catch (ExistentValueException e) {               
               e.printStackTrace();
            }         
         }            
         else if(resp.equals("3")){
            System.out.println("Digite um valor:");
            valor = sc.next();
            //Pesquisa por valores na lista.
            if(lista.Procura(valor) == true)
               System.out.println("Valor existe na lista!");
            else
               System.out.println("Valor não existe na lista!");            
         }         
         else if(resp.equals("4")){
            ArrayList<String> listar = new ArrayList<String>();
            //Recebe os valores da lista em um ArrayList e os imprime.
            try {
                listar = lista.Listar();
            } 
            catch (EmptyListException e) {
               e.printStackTrace();               
            }
            
            for(String elemento : listar){
               System.out.print(elemento + " ");
            }
            System.out.println();
         }
         else
            System.out.println("Opção inválida!");
      }
      while(resp != "9");      
   }
}

Manipulação de processos em Java

Gerando instância completa de um objeto

Ordenar um lista estática seqüencial de complexidade média (método da seleção)

Instalando java no ubuntu, fácil e rápido...

Conversor de temperatura (com gráficos)