// Método público que recibe un Nodo para buscarlo en la lista doble
public Tipo Buscar(Tipo Nodo)
{
if (!EstaVacia())
{
ClaseNodo NodoActual = new ClaseNodo();
// Empieza el recorrido en el NodoInicial
NodoActual = NodoInicial;
while (NodoActual != null)
{
if
(NodoActual.ObjetoConDatos.Equals(Nodo))
{
return
(NodoActual.ObjetoConDatos); // Devuelve los datos del nodo
}
NodoActual = NodoActual.Siguiente;
// Cambia al siguiente nodo
}
// Termina el recorrido y no localiza el nodo
return(default(Tipo));
}
else
{
return(default(Tipo)); // No se encuentra el nodo(Lista doble vacía)
}
}
public Tipo Eliminar(Tipo Nodo)
{
ClaseNodo NodoActual, NodoAnterior;
if (EstaVacia())
{
return(default(Tipo));
}
//return throw new Exception("Vacia...");
NodoActual = NodoInicial;
NodoAnterior = NodoInicial; // Guarda el NodoAnterior
do
{
if (Nodo.Equals(NodoActual.ObjetoConDatos)) // Verifica si es el Nodo que desea borrar
{
// Eliminación del primer nodo de la lista
if (Nodo.Equals(NodoInicial.ObjetoConDatos)) // ¿Es elprimer nodo de la lista ?
{
NodoInicial = NodoActual.Siguiente; // El NodoInicial ahora es al queapunta el NodoActual
NodoActual.Siguiente = null; //Se eliminael Nodo Actual
return(NodoActual.ObjetoConDatos); // Eliminación exitosa(devuelve los datos del nodo eliminado)
}
else
{
// Eliminación de un nodointermedio o el ultimo nodo de la lista
NodoAnterior.Siguiente = NodoActual.Siguiente; // El NodoAnterior apunta alsiguiente nodo del actual
NodoActual.Siguiente = null; //Se eliminael Nodo Actual
return(NodoActual.ObjetoConDatos); // Eliminación exitosa(devuelve los datos del nodo eliminado)
}
}
NodoAnterior = NodoActual; // Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente; //Cambia de NodoActual
} while (NodoActual != null);
throw new Exception("No se encuentra ...");
}
public void Insertar(Tipo Nodo)
{
ClaseNodo NuevoNodo, NodoActual, NodoAnterior;
if (EstaVacia())
{
NuevoNodo = new ClaseNodo(); //Creacióndel nuevo nodo
NuevoNodo.ObjetoConDatos = Nodo; //Asignación de los datos del Nodo
NuevoNodo.Siguiente = null; // ElNuevoNodo apunta a nulo
NodoInicial = NuevoNodo; // Ahora elNuevoNodo es el NodoInicial
return; // Inserción exitosa
}
// Recorrido de la Lista
NodoActual = NodoInicial; // Inicializa elrecorrido en el NodoInicial
NodoAnterior = NodoInicial; // Guarda elNodoAnterior
do
{
// Comparación para verificar duplicado
if (NodoActual.ObjetoConDatos.CompareTo(Nodo) == 0)
{
throw new Exception("Duplicado..."); // No se inserta el dato (duplicado)
}
if (Nodo.CompareTo(NodoActual.ObjetoConDatos) < 0)
{
// Alta al principio de la Lista
if (Nodo.CompareTo(NodoInicial.ObjetoConDatos) < 0)
{
NuevoNodo = new ClaseNodo();
//Creación del nuevo nodo
NuevoNodo.ObjetoConDatos = Nodo; // Asignación de los datos del Nodo
NuevoNodo.Siguiente = NodoInicial; // El NuevoNodo apunta al NodoInicial
NodoInicial = NuevoNodo; //Ahora el NodoInicial es el NuevoNodo
return; // Inserción exitosa
}
else
{
// Alta de un Dato intermedioen la Lista
NuevoNodo = new ClaseNodo();
//Creación del nuevo nodo
NuevoNodo.ObjetoConDatos = Nodo; // Asignación de los datos del Nodo
NuevoNodo.Siguiente = NodoAnterior.Siguiente; // El NuevoNodo apunta alNodoAnterior
NodoAnterior.Siguiente = NuevoNodo; // El NodoAnterior apunta al NuevoNodo
return; // Inserción exitosa
}
}
NodoAnterior = NodoActual; // Guardael NodoAnterior
NodoActual = NodoActual.Siguiente; //Se mueve al siguiente nodo del NodoActual
} while (NodoActual != null); // Repetir mientras no se encuentre el final de la Lista
// Alta de un Dato al final de la Lista
NuevoNodo = new ClaseNodo(); //Creación delnuevo nodo
NuevoNodo.ObjetoConDatos = Nodo; //Asignación de los datos del Nodo
NuevoNodo.Siguiente = null; // El NuevoNodo no apunta a nada(es el último de la lista)
NodoAnterior.Siguiente = NuevoNodo; // ElNodoAnterior apunta al NuevoNodo
return; // Inserción exitosa
}
public Tipo Buscar(Tipo Nodo)
{
if (!EstaVacia())
{
ClaseNodo NodoActual = NodoInicial;
while (NodoActual != null) // Mientrasno encuentra el final de la lista
{
if (Nodo.Equals(NodoActual.ObjetoConDatos)) // ¿Es el nodo deseado ?
{
return(NodoActual.ObjetoConDatos); // Búsqueda exitosa (devuelve los datos del nodo buscado)
}
NodoActual = NodoActual.Siguiente; // Cambia de NodoActual
}
return(default); // Terminó elrecorrido y no se encuentra el dato
public IEnumerator <Tipo> GetEnumerator()
{
if (EstaVacia())
{
yield break;
}
ClaseNodo NodoActual = new ClaseNodo();
// Inicia el recorrido de la lista en el NodoInicial
NodoActual = NodoInicial;
while (NodoActual != null) // Mientras haya nodos ...
{
yield return((Tipo)NodoActual.ObjetoConDatos); // Devuelve los datos del NodoActual
NodoActual = NodoActual.Siguiente; //Cambia de NodoActual
}
}
// Método para eliminar todos los nodos de la Lista Doble
public void Vaciar()
{
if (!EstaVacia())
{
// Inicializa el NodoActual al principio de la lista doble y declara el NodoAnterior
ClaseNodo NodoActual = NodoInicial,
NodoAnterior;
// Recorre la lista doble en forma ascendente
while (NodoActual != null) // Mientras no encuentra el final de la lista doble
{
NodoAnterior = NodoActual; //Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente;
// Cambia de NodoActual
NodoAnterior = null; // Elimina el NodoAnterior
}
NodoInicial = null; // Inicializa la lista doble vacía
NodoFinal = null;
}
}
// Método para eliminar todos los nodos de la Lista Enlazada Simple
public void Vaciar()
{
if (!EstaVacia()) // Si no está vacía
{
// Inicializa el NodoActual al principio de la lista y declara el NodoAnterior
ClaseNodo NodoActual = NodoInicial, NodoAnterior;
// Recorre la lista
while (NodoActual != null) // Mientras no encuentra el final de la lista
{
NodoAnterior = NodoActual; // Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente;
// Cambia de NodoActual
NodoAnterior.Siguiente = null; // Elimina el NodoAnterior
}
NodoInicial = null; // Inicializa la lista vacía
}
else
{
throw new Exception("Vacía ..."); // Error: la lista está vacía
}
}
// Método para buscar un Nodo en la Lista Enlazada Simple
public Tipo Buscar(Tipo Nodo)
{
if (!EstaVacia()) // Si no está vacía ...
{
ClaseNodo NodoActual = NodoInicial; // Inicializa el NodoActual al principio de la lista
// Recorrido de la lista
while (NodoActual != null) // Mientras no encuentra el final de la lista
{
if (Nodo.Equals(NodoActual.ObjetoConDatos)) // ¿Es el nodo deseado ?
{
return
(NodoActual.ObjetoConDatos); // Búsqueda exitosa (devuelve los datos del nodo buscado)
}
NodoActual = NodoActual.Siguiente; // Cambia de NodoActual
}
return(default(Tipo)); // Terminó el recorrido y no se encuentra el dato
}
else
{
return(default(Tipo)); // No se encuentra el dato(lista simple vacía)
}
}
//Método para eliminar un dato
public Tipo Eliminar(Tipo Nodo)
{
// Declaración de los nodos
ClaseNodo NodoActual, NodoAnterior, NodoEliminado;
if (EstaVacia()) // Si está vacía ...
{
throw new Exception("Vacía ...");
}
// Inicializa el recorrido de la lista
NodoActual = NodoInicial;
NodoAnterior = NodoInicial; // Guarda el NodoAnterior
do
{
if (Nodo.Equals(NodoActual.ObjetoConDatos)) // Verifica si es el Nodo que desea borrar
{
/*NodoEliminado = new ClaseNodo();*/ // Crea un objeto
//NodoEliminado = NodoActual; // Guarda temporalmente los datos del nodo que se desea eliminar
// Eliminación del primer nodo dela lista
if (Nodo.Equals(NodoInicial.ObjetoConDatos)) // ¿Es el primer nodo de la lista ?
{
NodoInicial = NodoActual.Siguiente; // El NodoInicial ahora es al que apunta el NodoActual
NodoActual.Siguiente = null; //Se elimina el Nodo Actual
return(NodoActual.ObjetoConDatos); // Eliminación exitosa(devuelve los datos del nodo eliminado)
}
else
{
// Eliminación de un nodo intermedio o el ultimo nodo de la lista
NodoAnterior.Siguiente = NodoActual.Siguiente; // El NodoAnterior apunta al siguiente nodo del actual
NodoActual.Siguiente = null; //Se elimina el Nodo Actual
return(NodoActual.ObjetoConDatos); // Eliminación exitosa(devuelve los datos del nodo eliminado)
}
}
NodoAnterior = NodoActual; // Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente; // Cambia de NodoActual
} while (NodoActual != null);
throw new Exception("No se encuentra ...");
// Error: no existe el nodo que se desea eliminar
}
public void Vaciar()
{
if (!EstaVacia())
{
ClaseNodo NodoActual = NodoInicial;
ClaseNodo NodoAnterior;
// Recorre la lista
while (NodoActual != null) // Mientras no encuentra el final de la lista
{
NodoAnterior = NodoActual; //Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente;
// Cambia de NodoActual
//NodoAnterior = null; // Elimina el NodoAnterior
NodoAnterior.Siguiente = null;
}
NodoInicial = null; // Inicializa la lista vacía
}
else
{
throw new Exception("Vacía ...");
}
}
// Constructor de la ClaseListaSimple
public ClaseListaSimpleOrdenada()
{
NodoInicial = null; // Inicializa la lista simple vacía
}
// Método que recibe el Nodo que se desea insertar
public void Insertar(Tipo Nodo)
{
// Declaración local de los nodos
ClaseNodo NuevoNodo, NodoActual,
NodoAnterior;
if (EstaVacia()) // Si está vacía
{
NuevoNodo = new ClaseNodo(); //Creación del NuevoNodo
NuevoNodo.ObjetoConDatos = Nodo; //Asignación del Nodo
NuevoNodo.Anterior = null;
NuevoNodo.Siguiente = null;
NodoInicial = NuevoNodo; // El NuevoNodo es el NodoInicial
NodoFinal = NuevoNodo; // El NuevoNodo también es el NodoFinal
return; // Inserción exitosa
}
NodoActual = NodoInicial;
NodoAnterior = NodoActual;
while (NodoActual != null)
{
if
(NodoActual.ObjetoConDatos.Equals(Nodo))
{
throw new Exception("Duplicado...");
}
if (Nodo.CompareTo(NodoActual.ObjetoConDatos) < 0)
{
if
(Nodo.CompareTo(NodoInicial.ObjetoConDatos) < 0) //Inserción al principio
{
NuevoNodo = new ClaseNodo();
NuevoNodo.ObjetoConDatos =
Nodo;
NuevoNodo.Anterior = null;
NuevoNodo.Siguiente =
NodoInicial;
NodoInicial.Anterior =
NuevoNodo;
NodoInicial = NuevoNodo;
return;
}
else // Inserción intermedia
{
NuevoNodo = new ClaseNodo();
NuevoNodo.ObjetoConDatos =
Nodo;
NuevoNodo.Anterior =
NodoAnterior;
NuevoNodo.Siguiente =
NodoActual;
NodoAnterior.Siguiente =
NuevoNodo;
NodoActual.Anterior =
NuevoNodo;
return;
}
}
NodoAnterior = NodoActual;
NodoActual = NodoActual.Siguiente;
}
// Inserción al final
NuevoNodo = new ClaseNodo();
NuevoNodo.ObjetoConDatos = Nodo;
NuevoNodo.Anterior = NodoFinal;
NuevoNodo.Siguiente = null;
NodoFinal.Siguiente = NuevoNodo;
NodoFinal = NuevoNodo;
return;
}
//Constructor
public ClaseListaDobleOrdenada()
{
// Inicializa la lista doble vacía
NodoInicial = null;
NodoFinal = null;
}
public Tipo Eliminar(Tipo Nodo)
{
// Declaración local de los nodos
ClaseNodo NodoActual, NodoAnterior;
if (EstaVacia()) // Si está vacía ..
{
return(default(Tipo)); // Nodo inexistente(lista doble vacía)
}
// Inicia el recorrido de la lista doble
NodoActual = NodoInicial;
NodoAnterior = NodoInicial;
while (NodoActual != null)
{
if
(NodoActual.ObjetoConDatos.Equals(Nodo)) // Si localiza el nodo...
{
ClaseNodo NodoEliminado = new
ClaseNodo();
NodoEliminado = NodoActual;
if (NodoInicial == NodoFinal) //Eliminación del único nodo
{
NodoInicial = null;
NodoFinal = null;
NodoActual = null;
return(NodoEliminado.ObjetoConDatos);
}
if (NodoActual == NodoInicial) //Eliminación al inicio
{
NodoInicial =
NodoActual.Siguiente;
NodoInicial.Anterior = null;
NodoActual = null;
return
(NodoEliminado.ObjetoConDatos);
}
if (NodoActual == NodoFinal) //Eliminación al final
{
NodoFinal =
NodoActual.Anterior;
NodoFinal.Siguiente = null;
NodoActual = null;
return
(NodoEliminado.ObjetoConDatos);
}
// Eliminación intermedia
NodoAnterior.Siguiente =
NodoActual.Siguiente;
NodoActual.Siguiente.Anterior =
NodoActual.Anterior;
NodoActual = null;
return
(NodoEliminado.ObjetoConDatos);
}
if
(Nodo.CompareTo(NodoActual.ObjetoConDatos) < 0) // Si el nodo buscado es menor,
{
return(default(Tipo));
}
// entonces no se encuentra
NodoAnterior = NodoActual; // Guarda el NodoAnterior
NodoActual = NodoActual.Siguiente; // Cambio de NodoActual
}
// Termina el recorrido de la lista doble y no se localiza el nodo(eliminación fallida)
return(default(Tipo));
}
public ListaSimple()
{
NodoInicial = null; // Inicializa la listasimple vacía
}