ARBOL

Definición:

Un Árbol Binario es un conjunto de finito de Elementos, de nombre Nodos de forma que:

El Árbol Binario es Vació si no tiene ningún elemento en el.

El Árbol Binario contiene un Nodo Raíz y los dos que parten de él, llamados Nodo Izquierdo y Nodo Derecho.

Los Árboles tiene 3 Recorridos Diferentes los cuales son:

Pre-Orden

In-Orden

Post-Orden

Pre-Orden

Definición:

El Recorrido “Pre-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en la Raíz, después viaje a través del Nodo Izquierdo y después a través del Nodo Derecho.

Detalle:

Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.

Algoritmo:

---

PreOrd(Arbol, Der, Izq, Pila, Raiz)

Temp → Raiz

Top →

Pila[Top] → Nulo

Si Raiz = Nulo

Imprimir “Árbol Vació…” y Salir

Repetir mientras Temp ≠ Nulo

Imprimir Arbol[Temp]

Si Der[Temp] ≠ Nulo

Top → Top + 1

Pila[Top] → Der[Temp]

Si Izq[Temp] ≠ Nulo

Temp → Izq[Temp]

Si no:

Temp → Pila[Top];

Top → Top - 1

Fin del ciclo

Salir

---

Diagrama:



Corrida:



In-Orden

Definición:

El Recorrido “In-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en el Nodo Izquierdo después la Raíz y finalmente viaja a través del Nodo Derecho.

Detalle:

Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.

Algoritmo:

---

PreOrd(Arbol, Der, Izq, Pila, Raiz)

Temp → Raiz

Top →

Pila[Top] → Nulo

Si Raiz = Nulo

Imprmir “Arbol Vacio…” y Salir

Etiqueta:

Mientras Temp ≠ Nulo

Top → Top + 1

Pila[Top] → Temp

Temp → Izq[Temp]

Fin del ciclo

Temp → Pila[Top]

Top → Top - 1

Mientras Temp ≠ Nulo

Imprimir Arbol[Temp]

Si Der[Temp] ≠ Nulo

Temp → Der[Temp]

Ir a Etiqueta

Temp → Pila[Top]

Top → Top - 1

Fin del ciclo

Salir

---

Diagrama:



Corrida:



In-Orden

Definición:

El Recorrido “In-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en el Nodo Izquierdo después el Nodo Derecho y finalmente viaja a través de la Raiz.

Detalle:

Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.

Algoritmo:

---

PostOrd(Arbol, Der, Izq, Pila, Raiz)

Temp → Raiz

Top →

Pila[Top] → Nulo

Si Raiz = Nulo

Imprimir “Arbol Vacio…” y Salir

Etiqueta:

Mientras Temp ≠ Nulo

Top → Top + 1

Pila[Top] → Temp

Si Der[Temp] ≠ Nulo

Top → Top + 1

Pila[Top] → - (Der[Temp])

Temp → Izq[Temp]

Temp → Pila[Top]

Top → Top - 1

Fin del ciclo

Mientras Temp ≥ 0

Imprimir Arbol[Temp]

Si Arbol[Temp] = Info[Raiz]

Salir

Temp → Pila[Top]

Top → Top - 1

Fin del ciclo

Si Temp < 0

Temp = -(Temp)

Ir a Etiqueta

Salir

---

Diagrama:



Corrida:



Búsqueda

Definición:

La Búsqueda es Similar a todas los Métodos anteriores de Búsqueda, simplemente efectúa un recorrido comparando el Elemento que deseas encontrar contra cada uno de los Elementos en los Arreglos.

Detalle:

El Algoritmo de Búsqueda compara el Elemento a buscar con cada uno de los datos de nuestro Árbol, compara si el Elemento con el Nodo Raíz, si no se encuentra en la Raíz… compara Elemento contra la Raíz para empezar a viajar por el Árbol respectivamente, usa un método similar al anterior hasta encontrar el Elemento. De otra forma la búsqueda es fallida.

Algoritmo:

---

Busqueda(Arbol, Der, Izq, Pila, Raiz, Elem)

Si Raiz = Nulo

Imprimir “Arbol Vacio”

Pos → Nulo

Pad → Nulo

Regresar Pos y Pad

Salir

Si Elem = Arbol[Raiz]

Imprimir “Elemento Encontrado”

Pos → Raiz

Pad → Nulo

Regresar Pos y Pad

Salir

Si Elem < Arbol[Raiz]

Temp → Izq[Raiz]

Temp2 → Raiz

Si no:

Temp → Der[Raiz]

Temp2 → Raiz

Mientras Temp ≠ Nulo

Si Elem = Arbol[Temp]

Imprimir “Elemento Encontrado…”

Pos → Temp

Pad → Temp2

Regresar Pos y Pad

Salir

Si Elem < Arbol[Temp]

Temp2 → Temp

Temp → Izq[Temp]

Si no:

Temp2 → Temp

Temp → Der[Temp]

Fin del ciclo

Imprimir “Elemento no Encontrado…”

Pos → Nulo

Pad → Temp2

Regresar Pos y Pad

Salir

---

Diagrama:



Corrida:

trabajo

GRAFOS

DEFINICIONES FUNDAMENTALES

Bucle: Toda arista de la forma (v, v)

Vértices adyacentes: se dice que 2 vértices son adyacentes si están unidos por una arista.

Aristas adyacentes :se dice que 2 aristas son adyacentes cuando tiene un vértice en común

Se dice que un vértice es aislado si no es adyacente a ningún otro vértice.

Se dice que un grafo es simple si no tiene bucles ó aristas múltiples.

Tipos de Grafos

a)        Grafo Regular: Si G=(V,A), de grado “n”, si todos sus vértices tiene grado “n”.

b) Grafo dirigido o dígrafo: Es un par G=(V,A), consistente en un conjunto finito no vacío V, cuyos miembros se llaman vértices y una familia finita A de pares ordenados de vértices a cuyos extremos llamaremos arista ó arcos.

Las aristas de los dígrafos tienen sentido

Representación de Grafos

1. Matriz de adyacencia
2. Matriz de incidencia
3. Listas

“Sea un grafo G=(V,A), con n- vértices {v1, v2, v3, ……,vn}, su matriz de adyacencia es la matriz de orden nxn, M(G)=(a_ij), donde a_ij es el número de aristas que unen los vértices v_i y v_j”

Matriz de incidencia

“Es determinable cuando no existen vértices con aristas del tipo (v,v)”

Las matrices de incidencia   sólo contienen ceros y unos

Matriz de adyacencia-Dígrafos

“Dado un dígrafo D=(V,E), con n-vértices {v1, v2, v3, ……,vn}, su matriz de adyacencia es la matriz de orden nxn, M(D )=(a_ij), donde a_ij es el número de arcos que tienen a v_i de inicio y a vj de fin”

Matriz de incidencia-Dígrafos

“Cada fila representa a cada uno de los nodos del grafo, y las columnas las aristas, en la casilla M(i,j), aparecerá un 1 cuando el nodo de la fila i es inicial, y un -1 cuando el nodo i es final”

 

Exploración e Grafos: Recorridos

1. Recorrido en profundidad.
2. Recorrido en anchura.

Cola

Cola

QUE ES UNA COLA

Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro.

Además, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.

Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir.

Un ejemplo de la vida Real es una cola, una fila, como para comprar un boleto para el cine.
Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.

OPERACIONES:

Crear: se crea la cola vacía.
Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.
Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que entró.

  

Cola.java(Clase y Metodos de la Cola)

import java.io.*;

//Declaramos la clase calculatorTest
public class ejecutar_cola{


//Declaramos el metodo principal
public static void main (String args[])throwsIOException {

BufferedReader entrada = new BufferedReader (newInputStreamReader(System.in));
int Espacios = 0;
char Resp, op;
String aux;

//--- Imprimir Menu ---- \\

System.out.println("\n :: XROM RELOADED :: 19/07/07 \n");

System.out.print("\t Cuantos espacios quiere en la Cola (entre 3 y 30 recomendable)? :");
Espacios = Integer.parseInt(entrada.readLine());

Cola Ejecutar = new Cola(Espacios);

//--- Imprimir Menu ---- \\

System.out.println("\n\n\t ------------ //-------- Menu Cola Simple --------\\\\------------ \n ");

do {

System.out.println("\n\n1.- Imprimir Cola"); // Mostrar
System.out.println("2.- Agregar Elemento a la Cola"); // Push
System.out.println("3.- Quitar Elemento de la Cola"); // Pop


System.out.print("\n\n Elija una Opcion : ");

aux = entrada.readLine();
op = aux.charAt(0);



//---- Elegir opcion ---\\


switch (op) {

case '1':

Ejecutar.Imprimir();

break;

case '2':


Ejecutar.Push();


break;

case '3':

Ejecutar.Pop();

break;


default:

System.out.println("opcion fuera de rango !!");



} // Fin del switch


System.out.print("Desea hacer otra operacion ?? S / N ");
aux = entrada.readLine();
Resp = aux.charAt(0);


} while (Resp == 'S' Resp == 's');


} // Fin del metodo main

} // Fin de la calse

Cola Insposterior(encolar)

delFrente (decolar)

class cola extends listaSimple{

            public cola () { super ( “ COLA ” ); }

            public void encolar ( object  obj){ // INSERTAR

                        inserter posterior ( obj );

}

Public object decolar ( ) { // ELIMINAR

            Return delFrente();

}

Public void mostrar cola ( ) {

            Mostrar lista ( );

}

} //PRIMERO EN ENTAR, PRIMERO EN SALIR

Class prueba {

Public static void main ( ){

            Cola C = new cola ( “X” );

               C.encolar ( “JUANA” );

                    C.encolar ( “ANA” );

                         C.encolar( “PEPE” );

                               C.decolar (); // JUANA

                                   C.decolar (); // ANA

}

}

listaSimple lista X = new listaSimple ( “ ” );

// LLENADO DE LA LISTA SE ASUME

Pila lista 1 = new pila ( “ P ” );

Cola lista 2 = new cola ( “ C ” );

            While ( ! lista X.listaVacia() ) {

                        Object obj = lista.delFrente();

                        If (obj.estado == “BUENO” )

                                   Lista 1.push( obj ); // INSERTAR PILA

                        Else

                                   Lista 2.encolar( obj ); // INSERTAR COLA

}

Pila

                             PILA (STACK)

QUE ES UNA PILA

Una Pila es en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

Evaluación de expresiones en notación postfija (notación polaca inversa).
Reconocedores sintácticos de lenguajes independientes del contexto
Implementación de recursividad.

OPERACIONES:

Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.

Crear: se crea la pila vacía.
Apilar: se añade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
Vacía: devuelve cierto si la pila está vacía o falso en caso contrario.

 

Gráficamente a una pila la representamos así:

 

Esta pila tiene 4 elementos, para la implementación de la clase haremos uso una variable entera tope que se encargara de decirnos en que posición del Array esta el elemento de la cima, en este caso tope=3 porque en el Array donde ingresamos los datos desde la posición 0, entonces los atributos son:

Pila (insPosterior, delPosterior){

Class pila extends lista Simple{

                Public  pila() { super (“Pila”) ;

                Public void push (object obj)

                               Inserter Posterior( obj) ;

}

Public object pop() { \\ eliminar

                Return del posterior ();

}

Public void mostrarPila(){

                Mostrar Lista();

} //ultimo en entar, primero en salir

}

Class Prueba {

Main ( ) {

                Pila p = new Pila (“Pila X”);

                P.push(“Ana”);

                p.push(“Juan”);

                p.pop(); // JUAN

                p.pop(); // ANA

}

}

COLA (Queve)

estructuras dinamicas Listas. Nodo, Pila Cola

Estructuras  Dinámicas

      Dinamica    Lineales       

                          

•     Listas Enlazadas.- Simples, Dobles, Circulares
•     Pilas
•     Cola
•     Bicola

        

                Dinamica No lineales         

            

•    -Arboles.-Binarios, Binarios De Búsqueda
•   -Grafos

Una lista enlazada es una serie de nodos, conectados entre sí a través de una referencia, en donde se almacena la información de los elementos de la lista. Por lo tanto, los nodos de una lista enlazada se componen de dos partes principales:

class NodoLista

{

  Object elemento;

  NodoLista siguiente;

}

La referencia contenida en el nodo de una lista se denomina siguiente, pues indica en dónde se encuentra el siguiente elemento de la lista. El último elemento de la lista no tiene nodo siguiente, por lo que se dice que la referencia siguiente del último elemento es null (nula).

La siguiente figura muestra un ejemplo de una lista enlazada cuyos elementos son strings:

La referencia lista indica la posición del primer elemento de la lista y permite acceder a todos los elementos de ésta: basta con seguir las referencias al nodo siguiente para recorrer la lista.

NodoLista aux=lista;

aux=aux.siguiente;

 

Siguiendo con el ejemplo anterior, para insertar un nuevo nodo justo delante del nodo referenciado por aux se deben modificar las referencias siguiente del nodo aux y del nodo a insertar.

NodoLista nuevo=new NodoLista(...);

//"nuevo" es la referencia del nodo a insertar en la lista

nuevo.siguiente=aux.siguiente;

aux.siguiente=nuevo;

//Notese que no es lo mismo realizar los cambios de referencia

//en un orden distinto al presentado, puesto que en ese caso

//se "pierde" la lista desde el nodo siguiente a aux

El procedimiento presentado a continuación es un ejemplo de cómo se programa el recorrido de una lista enlazada. Se supondrá que los objetos almacenados en cada nodo son strings:

void recorrido(NodoLista lista)

{

  NodoLista aux=lista;

  while (aux!=null)

  {

    System.out.println(aux.elemento);

    aux=aux.siguiente;

  }

}

Para invertir el orden de la lista, es decir, que el último elemento de la lista ahora sea el primero, que el penúltimo elemento de la lista ahora sea el segundo, etc..., modificando sólo las referencias y no el contenido de los nodos, es necesario realizar una sola pasada por la lista, y en cada nodo visitado se modifica la referencia siguiente para que apunte al nodo anterior. Es necesario mantener referencias auxiliares para acordarse en donde se encuentra el nodo anterior y el resto de la lista que aún no ha sido modificada:

void invertir(NodoLista lista)

{

  NodoLista siguiente=lista;

  NodoLista anterior=null;

  while(lista!=null)

  {

    siguiente=lista.siguiente;

    lista.siguiente=anterior;

    anterior=lista;

    lista=siguiente;

  }

}

La implementación vista de los nodos también se conoce como lista de enlace simple, dado que sólo contiene una referencia al nodo siguiente y por lo tanto sólo puede recorrerse en un solo sentido. En una lista de doble enlace se agrega una segunda referencia al nodo previo, lo que permite recorrer la lista en ambos sentidos, y en general se implementa con una referencia al primer elemento y otra referencia al último elemento.

Lista Circular

Una lista circular es aquella en donde la referencia siguiente del último nodo en vez de ser null apunta al primer nodo de la lista. El concepto se aplica tanto a listas de enlace simple como doblemente enlazadas.

En muchas aplicaciones que utilizan listas enlazadas es útil contar con un nodo cabecera, tambien conocido como . que es un nodo "falso", ya que no contiene información relevante, y su referencia siguiente apunta al primer elemento de la lista. Al utilizar un nodo cabecera siempre es posible definir un nodo previo a cualquier nodo de la lista, definiendo que el previo al primer elemento es la cabecera.

Si se utiliza un nodo cabecera en una lista de doble enlace ya no es necesario contar con las referencias primero y último, puesto que el nodo cabecera tiene ambas referencias: su referencia siguiente es el primer elemento de la lista, y su referencia anterior es el último elemento de la lista. De esta forma la lista de doble enlace queda circular de una manera natural

.

-BUSCAR

Buscando un elemento específico en una lista enlazada, incluso si esta es ordenada, normalmente requieren tiempo O (n) (búsqueda lineal). Esta es una de las principales desventajas de listas enlazadas respecto a otras estructuras. Además algunas de las variantes expuestas en la sección anterior, hay numerosas vías simples para mejorar el tiempo de búsqueda.

-ORDENAR

OPERACIONES

Constructor

Lista vacia

CONSTRUCTOR

//Lista vacia

1…Public lista(string n){

Nombre=n;

Pri=ult=null;

}

2…Public boolean ListaVacia(){

Return (pri==null);

}

INSERCIONES.-

FRENTE

POSTERIOR

POS-N

1…Insertar al frente

La Inserción al Principio básicamente busca si existe algún lugar disponible en el arreglo Info. y lo agrega como primer Nodo si es que es posible .

Public void InsertarFrente(Object obj){

If (ListaVacia())

                Prim=ult=null(obj);

Else

Prim=new Nodo(obj, pri);

}

2…INSPOSTERIOR

La Inserción después de un Nodo Determinado básicamente hace lo mismo que la inserción al principio, la única diferencia es que este recibe la posición del nodo en la que será Insertada. Este Algoritmo se usa para Inserción Ordenada que más adelante

Public void InsPosterior(Object obj){

If (listaVacia())

                Prim=ult=new nodo(obj);

Else

                Ult=ult.sig=new nodo(obj);

}

-CONTAR NODO DE UNA LISTA

Public int contnodos(){

                Nodo Actual=Prim; int cont=0;

                While(Actual !=null){

                               Cont++;

                Actual=Actual.sig;//avanza

}

Return cant;

                }

}

3….InsPos_n

Public void insPos_n(object obj, int pos){

                               If (ListaVacia())

                               InsertaFrente();

                               Else{

                                               If(pos==1){insertaFrente();}

                                               If (pos==ContElem()){insertaPosterior;

Else{

                Nodo Actual=Prim;

                For(int i=0; i<=pos_n; i++){

                               Actual=Actual.sig;

                Nodo Nuevo=new Nodo(obj, Actual.sig)

                               Actual sig=nuevo;

}

}

Public class lista simple{

Private nodo prim;

Private nodo ult;

Private string nombre;

}

Public lista Simple (){

Prim=ult=null;

Nombre=””;

}

Public lista simple(string n){

                               Prim=ult=null;

                               Nombre=n;

}

Public Boolean ListaVacia(){

                               Return prim==null;

}

Public void InsFrente( Object obj){}

Public void Insposterior(Object obj){}

Public void insposicion(Object obj, int pos){}

-ELIMINACIONES

Public object DelFrente(){

                               If (Listavacia()) trows excepcion

                               Object datoARemover=prim.dato;

                               If(prim.equals cult)

                                               Prim=ult=null;

                               Else{

Nodo Actual=prim;

Prim=prim.sig;

Actual.sig=null;

}

Return datoARemover;

}

DELPOSTERIOR

                1

If(listaVacia())

Object DatoARemover=ult.dato;

                2

                               If(prim.equals(null))

                               Prim=ult=null;

                3

                               Else{

                                               Nodo Actual=pri;

                                               While(Actual.sig !=ult)

                                                               Actual=Actual.sig;

}

DELPOS_N

                Public void ElemPos_n(Object , int Pos)

                               If(listaVacia()) {ElimFrente();}

                               Else{

                               If(pos==1){ElimFrente();}

                               If(pos==cantElem());{elemPost();}

                Else{

Nodo=Actual=prim;

For(int i=1; i<=Pos_n; i++){

Actual=Actual.sig;

datoARemover=Pos.Dato;

}

Return DatoaRemover;

}

}

//PARA ELIMINAR ENTRE MEDIO Y ENLAZAR AL SIGUIENTE

Public object DelPos ( int Pos) {

                If ( ListaVacia)

                If (Pos == 1)DelFrente(){

                If (Pos == numElemen)DelPosterior();

                Else {

                Object DatoARemoer

                If (prim.equals(ult)){

                               Prim = ult = null;

                Return DatoARemover;

}

Else{

Nodo actual = prim;

For (int i = 1; i <= pos; i++){

                Actual = actual.sig;

                DatoARemover = (actual.sig).Dato

                (aBorrar.Dato)

                Actual.sig = (actual.sig).sig;

                (aBorrar.sig) ;

                aBorrar.sig = null;

                return DatoARemover;

}

}

}

}

//MODIFICACIONES AL FRENTE

Algoritmo completo

Public void update frente (object obj new )

If( listaVacia())

Else

Prim.Dato = obj new;

//MODIFICACIONES POSTERIOR

Algoritmo completo

Public void update post (object obj )

If( listaVacia())

Else

ult.Dato = obj;

//MODIFICA LA POSICION

 Algoritmo completo

Public void update pos (object obj new, int pos ){

If( listaVacia()) //ERROR

If(pos == 1) updateFrente(obj new) ;

If(pos == numElemen) update post (object new) ;

Else{

nodo.actual = prim;

for( int i = 1; I <= pos; i++)

                actual = actual.sig;

                actual.dato = obj new;

}

}

//MOSTRAR LISTA

Public void mostrarLista(){

                Nodo.actual = prim;

                While( actual != null)

                Joptionpane (actual.dato)

                Actual = actual.sig;

LISTA DOBLE CIRCULAR

                            

Realizar el siguiente recorrido

1;  1-2-3-2            = (actual.sig.sig).ant

2;  2-3-4-1-4        = (((actual.sig).sig).sig).ant

3;  1-2-1-4            = (((actual.sig).ant).sig)

Recorrido optimo

4;  1-4                   = actual.ant

5;  3-1                   = (actual.ant).ant

6;  2-4                   = (actual.sig ).sig

Class nodoDoble{

                Object  Dato ;

                Nodo sig;

                Nodo ant;

                Public nodoDato() { }

}

Class listaDobleCircular{

                String Nombre;

                Nodo ultimo;

                Nodo actual; // OPCIONAL

}

INSERCIONES

insUltimo

                Nuevo.sig = ultimo.sig;

                Nuevo.ant = ultimo;

                Ultimo.sig.ant = Nuevo;

                Ultimo.sig = Nuevo;

                Ultimo = Nuevo;

InsPos_n

                Nuevo.sig = actual.sig;

                Nuevo.ant = actual;

                Actual.sig.ant = Nuevo;

                Actual.sig = Nuevo;

Eliminaciones

*DeleteUltimo

1 actual.sig = ultimo.sig;

2 actual.sig.ant = actual;

3 ultimo = null;

Ultimo.ant = ultimo.sig = null;

deletePrimero

                1 actual sig.ant = ultimo;

                2 ultimo.sig = actual.sig;

                3 actual.sig = actual.ant =null;

Del Pos_n

                Aux.sig = actual.sig;

                Actual.sig.ant = aux;

                Actual.sig = actual.ant = null;