jueves, 23 de febrero de 2017

CÓDIGO DE ARBOL

CÓDIGO DE ÁRBOL 
Clase Nodo
public class Nodo {
    int dato;
    Nodo hijoIzquierdo;
    Nodo hijoDerecho;
    String nombre;
    
    public Nodo(int dato,String nombre){
    this.dato=dato;
    this.nombre=nombre;
    hijoIzquierdo=hijoDerecho=null;        
}

    public int getDato() {
        return dato;
    }

    public void setDato(int dato) {
        this.dato = dato;
    }

    public Nodo getHijoIzquierdo() {
        return hijoIzquierdo;
    }

    public void setHijoIzquierdo(Nodo hijoIzquierdo) {
        this.hijoIzquierdo = hijoIzquierdo;
    }

    public Nodo getHijoDerecho() {
        return hijoDerecho;
    }

    public void setHijoDerecho(Nodo hijoDerecho) {
        this.hijoDerecho = hijoDerecho;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

   
    
}

Clase Árbol




public class Arbol {
    Nodo raiz;

  
    public Arbol(){
        
        raiz=null;
    }
    public boolean estaVacio(){
        return raiz==null;
    }
    //MEOTDO PARA INSERTAR UN NODO EN EL ARBOL
    public void agregar(int dato,String nombre){
        Nodo nuevo=new Nodo(dato,nombre);
        if(raiz==null){
            raiz=nuevo;
        }else{
            Nodo temp=raiz;
            Nodo padre;
            while(true){
                padre=temp;
                if(dato

Test Árbol

public class TestArbol {
    public static void main(String[] args) {
        Arbol a=new Arbol();
        int elemento=0;
        
        a.agregar(5, "Juan");
        a.agregar(3, "Manuel");
        a.agregar(7, "Jose");
        a.agregar(2, "Ana");
        a.agregar(4,"Luisa");
        a.agregar(8,"Miguel");
        a.preOrden(a.raiz);
        a.inOrden(a.raiz);
        a.buscarNodo(elemento);


    }
    
}

miércoles, 22 de febrero de 2017

ARBOLES

ARBOLES BINARIO

El árbol es una estructura de datos muy importante en informática y en ciencias de la computación. Los árboles son estructuras no lineales, al contrario que los arrays y las listas enlazadas, que constituyen estructuras lineales.
Un árbol consta de un conjunto finito de elementos, llamados nodos y de un conjunto finito de líneas dirigidas, llamadas ramas, que conectan los nodos.
Características:

  • Raiz.
  • Hijos.
  • Cada nodo puede tener entre 0-2 hijos.
  • Profundidad.
  • Altura.
  • Tamaño.
  • Nodo exterior Nodo interior
Arbol binario con lista doble

 A continuación una gráfica para comprender las características de un Arbol binario



Clases de arboles binario
*PreOrden(raíz, izquierdo, derecho).Para recorrer un árbol binario no vacío en preorden, hay que realizar las siguientes operaciones recursivamente en cada nodo comenzando con el nodo de raíz:
1. Visite la raíz
2. Atraviese el sub-árbol izquierdo
3. Atraviese el sub-árbol derecho

*InOrden (izquierdo, raíz, derecho). Para recorrer un árbol binario no vacío en inorden (simétrico),hay que realizar las siguientes operaciones recursivamente en cada nodo:
1. Atraviese el sub-árbol izquierdo
2. Visite la raíz
3. Atraviese el sub-árbol derecho

*PostOrden(izquierdo, derecho, raíz). Para recorrer un árbol binario no vacío en postorden, hayque realizar las siguientes operaciones recursivamente en cada nodo:
1. Atraviese el sub-árbol izquierdo
2. Atraviese el sub-árbol derecho
3. Visite la raíz

Ejemplo:




Recorrido en PreOrden
 1 2 3 4 5 6 7

Recorrido en InOrden
 2 1 4 3 6 5 7

Recorrido en PostOrden
 2 4 6 7 5 3 1

miércoles, 8 de febrero de 2017

EJEMPLO DE COMIDA CON ARRAYLIST

A continuación un ejemplo de Menú de comida usando ArrayList,que tendrá una clase Operación que tendrá como métodos mostar ,editar y eliminar los ingredientes del Menú. 


  •  Empezamos creando nuestra clase Comida

public class Comida {

    private String nombre;
   private  ArrayList Ingredientes;

    public Comida() {
        nombre = "";
        Ingredientes = new ArrayList<>();
    }

    public Comida(String nombre, ArrayList ingredientes) {
        this.nombre = nombre;
        this.Ingredientes = ingredientes;
    }

    public Comida(ArrayList Ingredientes) {
        this.Ingredientes = Ingredientes;
    }
    

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public ArrayList getIngredientes() {
        return Ingredientes;
    }

    public void setIngredientes(ArrayList Ingredientes) {
        this.Ingredientes = Ingredientes;
    }
    
}


  • Nuestra clase Operación

import java.util.ArrayList;
import javax.swing.JOptionPane;

public class operacion {

    ArrayList misComidas;

    public operacion() {
        misComidas = new ArrayList<>();
    }

    void guardar(Comida comida) {

        if (buscar(comida.getNombre())==true) {
            JOptionPane.showMessageDialog(null, "El plato ya existe");
        } else {
            misComidas.add(comida);
        }
    }

    boolean buscar(String comida) {

        boolean opcion=false;
         for (int i = 0; i < misComidas.size(); i++) {
            if (comida.equals(misComidas.get(i).getNombre())) {
              opcion=true;
            }

        }
        return opcion;
    }

    public ArrayList getMisComidas() {
        return misComidas;
    }
    public void Editar(int pos,Comida comida){

            misComidas.set(pos, comida);

    }
    public void eliminar(int pos){
      
            misComidas.remove(pos);
        
    }
}


  • Nuestra clase Frame donde crearemos el interfaz de nuestro código

import java.awt.List;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class ComidaInterface extends javax.swing.JFrame {

    operacion operacionComida = new operacion();
    ArrayList ingredientes;

    public ComidaInterface() {
        initComponents();
        this.setTitle("Menu");
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setVisible(true);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
    }

    private void btLimpiarActionPerformed(java.awt.event.ActionEvent evt) {                                          
        // TODO add your handling code here:
        this.tfNombrecomida.setText("");
        this.taIngredientes.setText("");
        tfNombrecomida.requestFocus();
        taIngredientes.setEditable(true);
        tfNombrecomida.setEditable(true);
    }                                         

    private void btGuardarActionPerformed(java.awt.event.ActionEvent evt) {                                          

        ingredientes = new ArrayList<>();
        //
        if (!taIngredientes.getText().equals("") && !tfNombrecomida.getText().equals("")) {

            String ingred[] = taIngredientes.getText().split("\n");
            for (int i = 0; i < ingred.length; i++) {
                ingredientes.add(ingred[i]);
            }

            //
            Comida comida = new Comida(tfNombrecomida.getText(), ingredientes);
            operacionComida.guardar(comida);
            mostrar(jtmostrar);
            limpiar();
        } else {
            JOptionPane.showMessageDialog(null, "Campo vacío");
            tfNombrecomida.requestFocus();
        }


    }                                         

    private void taIngredientesMouseClicked(java.awt.event.MouseEvent evt) {                                            

    }                                           

    private void jtmostrarMouseClicked(java.awt.event.MouseEvent evt) {                                       
        limpiar();
        tfNombrecomida.setEditable(false);
        taIngredientes.setEditable(false);
    }                                      

    private void btMostrarActionPerformed(java.awt.event.ActionEvent evt) {                                          
        mostrarIngredientes();

    }                                         

    private void btEditarActionPerformed(java.awt.event.ActionEvent evt) {                                         
        taIngredientes.setEditable(true);
        tfNombrecomida.setEditable(true);
        tfNombrecomida.requestFocus();
        ingredientes = new ArrayList<>();
        if (!taIngredientes.getText().equals("")) {
            String ingred[] = taIngredientes.getText().split("\n");
            for (int i = 0; i < ingred.length; i++) {
                if (!ingred[i].equals("")) {
                    ingredientes.add(ingred[i]);
                }

            }

            int posicion = jtmostrar.getSelectedRow();
            Comida comida = new Comida(tfNombrecomida.getText(), ingredientes);
            operacionComida.Editar(posicion, comida);
            mostrar(jtmostrar);
            limpiar();
        } else {
            JOptionPane.showMessageDialog(null, "Campo vacío");
            tfNombrecomida.requestFocus();
        }
    }                                        

    private void btEliminarActionPerformed(java.awt.event.ActionEvent evt) {                                           
        int posicion = jtmostrar.getSelectedRow();
        operacionComida.eliminar(posicion);
        mostrar(jtmostrar);

        taIngredientes.setText("");
        tfNombrecomida.setText("");
        taIngredientes.setEditable(true);
        tfNombrecomida.setEditable(true);
    }                                          

    private void tfNombrecomidaActionPerformed(java.awt.event.ActionEvent evt) {                                               
        taIngredientes.requestFocus();
    }                                              

    void mostrarIngredientes() {
        int posicion = jtmostrar.getSelectedRow();

        tfNombrecomida.setText(jtmostrar.getValueAt(posicion, 0).toString());
        for (int i = 0; i < operacionComida.getMisComidas().get(posicion).getIngredientes().size(); i++) {
            taIngredientes.append(operacionComida.getMisComidas().get(posicion).getIngredientes().get(i) + "\n");
        }
        taIngredientes.setEditable(true);
        tfNombrecomida.setEditable(true);
    }

    DefaultTableModel mostrar(JTable tabla) {
        DefaultTableModel modelo = (DefaultTableModel) tabla.getModel();
        modelo.setRowCount(0);
        Object[] fila = new Object[1];
        

        for (int i = 0; i < operacionComida.getMisComidas().size(); i++) {
            fila[0] = operacionComida.getMisComidas().get(i).getNombre();
            modelo.addRow(fila);
        }
        return modelo;
    }

    void limpiar() {
        tfNombrecomida.setText("");
        taIngredientes.setText("");
        tfNombrecomida.requestFocus();
    }

    public static void main(String args[]) {
  
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ComidaInterface().setVisible(true);
            }
        });
    }
    private javax.swing.JButton btEditar;
    private javax.swing.JButton btEliminar;
    private javax.swing.JButton btGuardar;
    private javax.swing.JButton btLimpiar;
    private javax.swing.JButton btMostrar;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JTable jtmostrar;
    private javax.swing.JTextArea taIngredientes;
    private javax.swing.JTextField tfNombrecomida;





EJEMPLO DE FRUTAS USANDO LISTAS ENLAZADA,PILAS Y COLAS

A continuación se mostrara un código ,que se trata crear una clase Nodo fruta la cual tendrá como métodos de procedimiento insertar frutas,sacar por Pila y Colas,imprimir y eliminar usando un interfaz. 

  •  Empezamos creando nuestra clase NodoFruta

public class NodoFruta {

    private Object fruta;
    private float precio;
    private NodoFruta nodfrut;

    public NodoFruta(Object fruta, float precio) {
        this.fruta = fruta;
        this.precio = precio;
        this.nodfrut = null;
    }

    public Object getFruta() {
        return fruta;
    }

    public void setFruta(Object fruta) {
        this.fruta = fruta;
    }

    public float getPrecio() {
        return precio;
    }

    public void setPrecio(float precio) {
        this.precio = precio;
    }

    public NodoFruta getNodfrut() {
        return nodfrut;
    }

    public void setNodfrut(NodoFruta nodfrut) {
        this.nodfrut = nodfrut;
    }

    public String toString() {

        return String.valueOf(this.fruta + "\t\t" + this.precio);
    }

}


  • Nuestra clase OperacionNodo donde se creara los métodos ya explicados


import javax.swing.JOptionPane;
import jdk.nashorn.internal.objects.NativeString;

public class OperacionNodo {

    NodoFruta inicio;
    NodoFruta fin;

    public OperacionNodo() {
        this.fin = null;
    }

// EL  METODO DE INGRESO ES IGUAL PARA AMBOS (PILAS Y COLAS).
    public void ingresarNodo(Object fruta, float precio) {

        NodoFruta nodonuevo = new NodoFruta(NativeString.toUpperCase(fruta), precio);
        if (fin == null) {
            inicio = fin = nodonuevo;
        } else {
            nodonuevo.setNodfrut(fin);
            fin = nodonuevo;
        }
    }

//METODO SACAR POR COLA
    public void sacarNodoCola() {
        NodoFruta temp = fin;
        while (temp != null) {
            if (temp.getNodfrut() == inicio) {
                inicio = temp;
                inicio.setNodfrut(null);
                break;
            }
            temp = temp.getNodfrut();
        }
    }

//METODO SACAR POR PILA
    public void sacarNodoPila() {
        fin = fin.getNodfrut();

    }

//ELIMINAR POR FRUTA.
    public void eliminar(Object nombre) {
        NodoFruta temp = fin, temp2 = fin;
        if (estaContenido(NativeString.toUpperCase(nombre))) {
            while (temp != null) {
                if (temp.getFruta().equals(NativeString.toUpperCase(nombre))) {
                    if (fin.getFruta().equals(NativeString.toUpperCase(nombre))) {
                        fin = temp2.getNodfrut();
                        break;
                    } else {
                        temp2.setNodfrut(temp.getNodfrut());
                        break;
                    }

                }
                temp2 = temp;
                temp = temp.getNodfrut();
            }
        }
    }

//METODO QUE BUSCA EN EL CONTENIDO SI ESTA O NO
    boolean estaContenido(Object fruta) {
        boolean band = false;
        NodoFruta temp = fin;
        while (temp != null) {
            if (temp.getFruta().equals(fruta)) {
                band = true;
                break;
            }
            temp = temp.getNodfrut();
        }
        JOptionPane.showMessageDialog(null, "No se encuentra en el contenido...!");

        return band;
    }

//AL IGUAL QUE EL METODO DE INGRESO, ES LO MISMO EL METO PARA MOSTRAR.    
    public String mostrar() {
        NodoFruta temp = fin;
        String cadena = "";
        while (temp != null) {
            cadena += temp.toString() + "\n";
            //System.out.println(temp.toString() + "");
            temp = temp.getNodfrut();
        }
        return cadena;
    }

}


  • Mi clase TestFruta


public class TestFruta {

    public static void main(String[] args) {
        OperacionNodo oper = new OperacionNodo();
        oper.ingresarNodo("Fresa", (float) 12.3);
        oper.ingresarNodo("Cereza", 9);
        oper.ingresarNodo("Platanos", 13);
        oper.ingresarNodo("Mora", (float) 18.30);
        oper.mostrar();
        System.out.println("\n\tSACANDO FRUTA");
        oper.sacarNodoCola();
        oper.mostrar();
        System.out.println("\n\tNUEVA  FRUTA");
        oper.ingresarNodo("Papaya", (float) 11.30);
        oper.mostrar();
        System.out.println("\n\tSACANDO FRUTA");
        oper.sacarNodoPila();
        oper.mostrar();
        oper.ingresarNodo("Melones", 9);
        oper.ingresarNodo("Uva", 13);
        System.out.println("\n\tNUEVA  FRUTA");
        oper.mostrar();
        System.out.println("\n\tELIMINAR");
        oper.eliminar("mora");//SI ESCRIBO EL NOMBRE DE LA FRUTA 
        oper.mostrar();   //EN MAYUSCULA O MINUSCULA QUE LO CONVIERTA A MAYUSCULA
    }

}


  • Ahora nuestra clase Frame donde crearemos nuestra interfaz


public class FrameFrutas extends javax.swing.JFrame {
OperacionNodo oper=new OperacionNodo();
   
    public FrameFrutas() {
        initComponents();
        setVisible(true);
        setTitle("FRUTAS");
        setResizable(false);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        
    }
 private void bcolaActionPerformed(java.awt.event.ActionEvent evt) {                                      
        // TODO add your handling code here:
        oper.sacarNodoCola();
        tamostrar.setText(oper.mostrar());
    }                                     

    private void bingresarActionPerformed(java.awt.event.ActionEvent evt) {                                          
        // TODO add your handling code here:
       
        oper.ingresarNodo(tffruta.getText(), Float.parseFloat(tfprecio.getText()));
        tffruta.setText("");
        tfprecio.setText("");
        tffruta.requestFocus();
        
    }                                         

    private void bimprimirActionPerformed(java.awt.event.ActionEvent evt) {                                          
        // TODO add your handling code here:
    tamostrar.setText(oper.mostrar());
        
    }                                         

    private void bpilaActionPerformed(java.awt.event.ActionEvent evt) {                                      
        // TODO add your handling code here:
        oper.sacarNodoPila();
        tamostrar.setText(oper.mostrar());
    }                                     

    private void beliminarActionPerformed(java.awt.event.ActionEvent evt) {                                          
        // TODO add your handling code here:
        oper.eliminar(tffruta.getText());
        tffruta.setText("");
        tamostrar.setText(oper.mostrar());
    } 
   
   public static void main(String args[]) {
   
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new FrameFrutas().setVisible(true);
            }
        });
    }

    private javax.swing.JButton bcola;
    private javax.swing.JButton beliminar;
    private javax.swing.JButton bimprimir;
    private javax.swing.JButton bingresar;
    private javax.swing.JButton bpila;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextArea tamostrar;
    private javax.swing.JTextField tffruta;
    private javax.swing.JTextField tfprecio;

Esta fue la interfaz que hice

EJEMPLO DE LISTAS ENLAZADAS CON PILAS Y COLAS


  • Clase Nodo

public class Nodo {

    private Object valor;

    private Nodo siguiente;
    

    public Nodo(Object val,Nodo sig){
        this.valor = val;
        this.siguiente = sig;
    }
    
 
    public Object getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }
}

  • Clase ListaEnlazada

public class ListaEnlazada {
    //Creamos dos Nodos, que seran el primero y el ultimo nodo de nuestra lista
    private Nodo primero,ultimo;
    //Variable que llevara el tamaño de la lista
    private int tamaño;
    
    //Constructor. Inicializacion de las variables
    public ListaEnlazada(){
        ultimo = primero = null;
        tamaño = 0;
    }
    
    //Funcion que inserta un dato al principio de la lista, recibe como parametro el dato a insertar
    public void insertarPrimero(Object valor){
        if(tamaño == 0){
            primero = new Nodo(valor,null);
            ultimo = primero;
            tamaño++;
        }
        else{
            Nodo temporal = primero;
            primero = new Nodo(valor,temporal);
            tamaño++;
        }
    }
    
    //Funcion que inserta un dato al final de la lista, recibe como parametro el dato a insertar
    public void insertarUltimo(Object valor){
        if(tamaño == 0){
            primero = new Nodo(valor,null);
            ultimo = primero;
            tamaño++;
        }
        else{
            Nodo temporal = ultimo;
            ultimo = new Nodo(valor, null);
            temporal.setSiguiente(ultimo);
            tamaño++;
        }
    }
    
    //Funcion que elimina el primer nodo de la lista
    public void eliminarPrimero(){
        if(tamaño == 0)return;
        Nodo temporal = primero;
        temporal = primero.getSiguiente();
        primero = null;
        primero = temporal;
        tamaño--;
    }
    
    //Funcion que elimmina el ultimo nodo de la lista
    public void eliminarUltimo(){
        if(tamaño == 0)return;
        if(tamaño == 1){
            ultimo = primero = null;
            tamaño = 0;
            return;
        }
        Nodo temporal = primero;
        while(temporal.getSiguiente() != ultimo){
            temporal = temporal.getSiguiente();
        }
        temporal.setSiguiente(null);
        ultimo = temporal;
        tamaño--;
    }
    
    //Funcion que regresa el tamaño de la lista... es decir el numero de elementos que contiene
    public int getTamaño(){
        return tamaño;
    }
    
    //Funcion que devuelve un array con los elementos de la lista
    public Object[] getElementos(){
        if(tamaño == 0)return new Object[0];
        Object[] elementos = new Object[tamaño];
        int i = 0;
        Nodo temporal = primero;
        while(temporal != null){
            System.out.print(temporal.getValor().toString()+"  ");
            elementos[i++] = temporal.getValor();
            temporal = temporal.getSiguiente();
        }
        System.out.println("");
        return elementos;
    }
    
    public static void main(String[] args) {
        ListaEnlazada lista = new ListaEnlazada();
        lista.insertarPrimero(1);
    }
    
}

  • Clase Pila

public class Pila {
 
    private ListaEnlazada pila;

    public Pila(){
        pila = new ListaEnlazada();
    }

    public void push(Object dato){
        pila.insertarPrimero(dato);
    }
    
    //Funcion que elimina un elemento de la pila
    public Object pop(){
        Object Dato = pila.getElementos()[0];
        pila.eliminarPrimero();
        return Dato;
    }
    
    //Funcion que devuelve el tope de la pila
    public Object peek(){
        return pila.getElementos()[0];
    }
    
    //Funcion que devueleve el tamaño de la pila
    public int size(){
        return pila.getTamaño();
    }
    
    //Funcion que devuelve los elementos de la pila
    public Object[] getElementos(){
        return pila.getElementos();
    }
}


  • Clase Cola

public class Cola {
    private ListaEnlazada cola;
    
    public Cola(){
        cola = new ListaEnlazada();
    }
    
    public void encolar(Object dato){
        cola.insertarUltimo(dato);
    }
    
    public Object desencolar(){
        Object dato = cola.getElementos()[0];
        cola.eliminarPrimero();
        return dato;
    }
    
    public Object frente(){
        return cola.getElementos()[0];
    }
    
    public int size(){
        return cola.getTamaño();
    }
    
    public Object[] getElementos(){
        return cola.getElementos();
    }
    
}

LISTAS DOBLES


Ahora es el turno de las listas doblemente enlazadas. 
Este tipo de listas se diferencian de las simples en que, ahora cada nodo ademas de contener la un enlace a la dirección siguiente, tendrá una con la dirección del nodo anterior al actual. 
La ventaja que nos proporciona este tipo de lista es que podemos recorrer la lista desde el nodo inicial al final y desde el final a el inicial. Otra ventaja de las listas doblemente enlazadas es que podemos usar un puntero a la celda que contiene el i-ésimo elemento de una lista para representar la posición i, mejor que usar el puntero a la celda anterior aunque lógicamente, también es posible la implementación similar a la expuesta en las listas simples haciendo uso de la cabecera.


A continuación voy a dejar un cogido en Java Netbeans donde inserto y creo mi nodo de tipo Persona que tiene de dato un nombre.
  •  Primero creo mi clase Persona

public class Persona {
    String nombre;
    public Persona(String nombre){
        this.nombre=nombre;
    }

    public Object getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    
}
  • Luego mi clase Nodo
public class Nodo {
    Persona dato;
    Nodo siguiente;
    Nodo anterior;
    public Nodo(Persona dato){
        this.dato=dato;
        siguiente=anterior=null;    
    }
       
}


  • Mi clase Procedimiento


public class Procedimiento {
   Nodo fin;
   public Procedimiento(){
       fin=null;
   }
       public boolean esVacia(){
        return (this.fin == null);
    }
           public void insertarCabecera(String dato){
               Persona p=new Persona(dato);
       Nodo nuevo=new Nodo(p);
        if(esVacia()){
            fin = nuevo;
        }
    }
           public void Mostrar(){
               Nodo temp = fin;
        if(! esVacia()){
            while (temp!= null){
                System.out.println("["+temp.dato.nombre+"]" );
                temp=temp.siguiente;
            }
        
        }else{
            System.out.println("La lista esta vacia");
        }
        
        
    }

           
}


  • Y mi clase Test


public class TestListaDoble {
    public static void main(String[] args) {
        Procedimiento p=new Procedimiento();
        p.insertarCabecera("andrea");
        p.Mostrar();
        
    }
    
}

domingo, 5 de febrero de 2017

LISTAS CIRCULARES


Las listas circulares son estructuras de datos en la que el último nodo apunta al primero lo cual la convierte en una lista sin fin, cada nodo siempre tiene uno anterior y uno siguiente, su estructura es muy similar a las listas simples por lo cual comparten características tanto en su implementación como en su manejo aunque requiere un mayor entendimiento del manejo de los punteros.



  • No existe ningún nodo que apunte a null. 
  • La lista no tiene fin ya que al llegar al último nodo empieza de nuevo la lista.
  •  Se accede a la lista mediante el primer nodo o también llamado inicio de la lista. 
  • Si no se tiene cuidado al manejar la lista circular se pueden crear bucles infinitos.
  •  No tiene acceso aleatorio es decir para acceder a un valor se debe recorrer toda la lista. 

Características Operaciones básicas:

  •  agregar (valor): agrega el valor al final de la lista. 
  • insertar (referencia, valor): inserta el valor después del valor de referencia en la lista.
  • remover(referencia): elimina el nodo con el valor que coincida con la referencia.
  • editarreferencia): actualiza el valor de nodo con el valor que coincida con la referencia. 
  • esVacia (): retorna true si la lista está vacía, false en caso contrario.
  •  buscar (valor): retorna la true si el elemento existe en la lista, false caso contrario.
  • eliminar(): elimina la lista.
  •  listar (): imprime en pantalla los elementos de la lista. A continuación el código de lista circular

public class Nodo {
  
    private int valor;
   
    private Nodo siguiente;
   
    
  
    public void Nodo(){
        this.valor = 0;
        this.siguiente = null;
    }
    

    
    public int getValor() {
        return valor;
    }

    public void setValor(int valor) {
        this.valor = valor;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }   
}


public class ListaCircular {

    private Nodo inicio;
    private Nodo ultimo;
    private int tamanio;

    public void Lista() {
        inicio = null;
        ultimo = null;
        tamanio = 0;
    }

    public boolean esVacia() {
        return inicio == null;
    }

    public int getTamanio() {
        return tamanio;
    }

    public void agregarAlFinal(int valor) {

        Nodo nuevo = new Nodo();

        nuevo.setValor(valor);

        if (esVacia()) {

            inicio = nuevo;

            ultimo = nuevo;

            ultimo.setSiguiente(inicio);

        } else {
            ultimo.setSiguiente(nuevo);

            nuevo.setSiguiente(inicio);

            ultimo = nuevo;
        }

        tamanio++;
    }

    public void agregarAlInicio(int valor) {

        Nodo nuevo = new Nodo();

        nuevo.setValor(valor);

        if (esVacia()) {

            inicio = nuevo;

            ultimo = nuevo;

            ultimo.setSiguiente(inicio);

        } else {

            nuevo.setSiguiente(inicio);

            inicio = nuevo;

            ultimo.setSiguiente(inicio);
        }

        tamanio++;
    
}