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");      
   }
}

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

Conversor de temperatura (com gráficos)

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

Conversor de bases decente não essas bostas que tem nesse site.

Gerando instância completa de um objeto