using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LSE
{

public class Nodo

{
public Object dato;
public Nodo siguiente;
public Nodo comienzo;
-Reserva  de memoria
para el nuevo elemento.
-Introducir el nuevo public void InsertarComienzo(Object dato)
elemento en memoria. {
-El puntero hacia el
siguiente elemento
Nodo Añadir = new Nodo();
apuntará al primer
elemento. Añadir.dato = dato;
-El puntero inicio apuntará Añadir.siguiente = comienzo;
al nuevo elemento.
-El puntero fin se queda
comienzo = Añadir;
}

public void InsertarFinal(Object dato)

{ -Reserva de memoria para el
if (comienzo == null)
{
nuevo elemento.
comienzo = new Nodo(); -Introducir el nuevo
elemento en memoria.
comienzo.dato = dato;
comienzo.siguiente = null; -El puntero hacia el siguiente
} elemento apuntará al último
else elemento.
{
Nodo añadir = new Nodo(); comienzo.siguiente = null;
añadir.dato = dato; -El puntero de fin apunta
hacia el nuevo elemento
Nodo actual = comienzo;
while (actual.siguiente != null) introducido.
{ -El puntero inicio se queda
actual = actual.siguiente;
}
sin cambios.

actual.siguiente = añadir;
}
}

Para visualizar la lista completa

hay que posicionarse al inicio public class ListaEnlazada
{
(con el puntero inicio). Luego private Nodo comienzo;
con el puntero siguiente de cada
public void imprimeTodosLosNodos()
elemento se recorre la lista. {
La condición para detenerse es Nodo actual = comienzo;
while (actual != null)
proporcionada por el puntero {
siguiente del último elemento Console.WriteLine(actual.dato);
que posee el valor NULL. actual = actual.siguiente;
}
}
}

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Añade al inicio:");
ListaEnlazada miLista1 = new ListaEnlazada();
Nodo miNodo1 = new Nodo();

miNodo1.InsertarComienzo("Hola");
miNodo1.InsertarComienzo("Mundo");
miNodo1.InsertarComienzo("Dato3");
miLista1.imprimeTodosLosNodos();

Console.WriteLine();

Console.WriteLine("Añade al final:");
ListaEnlazada miLista2 = new ListaEnlazada();
Nodo miNodo2 = new Nodo();

miNodo2.InsertarFinal("Hola");
miNodo2.InsertarFinal("Mundo");
miNodo2.InsertarFinal("Dato3");
miLista1.imprimeTodosLosNodos();

Console.ReadLine();

}
}
using System;
using System.Collections.Generic;
public void Imprimir()
using System.Linq;
{
using System.Text; if (!Vacia())
{
namespace ListaCircular1 Nodo reco = raiz;
{ do
public class ListaCircular {
{ Console.Write(reco.info + "-");
reco = reco.sig;
class Nodo } while (reco != raiz);
{ Console.WriteLine();
public int info; }
public Nodo ant, sig; }
} Para InsertarPrimero(int x) :
public int Cantidad()
Creamos un nodo y guardamos la información:
{
private Nodo raiz;
int cant = 0; Si la lista está vacía luego tanto el puntero sig y ant apuntan a si mismo ya que debe ser
if (!Vacia()) circular (y raiz apunta al nodo creado).
public ListaCircular() { En caso que la lista no esté vacía disponemos un puntero al final de la lista (el puntero ant
{ Nodo reco = raiz; del primer nodo tiene dicha dirección).
raiz = null; do
{ El nodo a insertar lo enlazamos previo al nodo apuntado por raiz.
}
cant++; Finalmente hacemos que raiz apunte al nodo creado luego de haber hecho todos los
reco = reco.sig; enlaces.
public void InsertarPrimero(int x)
} while (reco != raiz);
{ } Para insertar un nodo al final de la lista
Nodo nuevo = new Nodo(); return cant; Para InsertarUltimo(int x):
nuevo.info = x; }
Al insertar en la posición anterior del primer nodo lo que estamos haciendo realmente es
if (raiz == null) insertar al final de la lista):
{ public void Borrar(int pos)
nuevo.sig = nuevo; { Para imprimir la lista ya no podemos disponer un puntero reco que apunte al primer nodo
if (pos <= Cantidad()) y que se detenga cuando encuentre un nodo que el atributo sig almacene null.
nuevo.ant = nuevo; {
raiz = nuevo; Si la lista no está vacía disponemos un puntero en el primer nodo y utilizamos un do/while
if (pos == 1) para recorrer la lista. La condición del do/while es que se repita mientras el puntero reco
} { sea distinto a raiz (es decir que no haya dado toda la vuelta a la lista):
else if (Cantidad() == 1)
{ { Para borrar el nodo de una determinada posición:
Nodo ultimo = raiz.ant; raiz = null;
} Debemos primero identificar si es el primero de la lista (ya que en este caso se modifica el
nuevo.sig = raiz; puntero externo raiz):
else
nuevo.ant = ultimo; { Si es el primero y el único de la lista hacemos que raiz apunte a null
raiz.ant = nuevo; Nodo ultimo = raiz.ant;
ultimo.sig = nuevo; raiz = raiz.sig; Si no disponemos un puntero al final de la lista, avanzamos raiz y enlazamos el último nodo
con el segundo de la lista:
raiz = nuevo; ultimo.sig = raiz;
} raiz.ant = ultimo; En caso que queremos borrar un nodo que se encuentra en medio de la lista o inclusive al
} final debemos recorrer con un for hasta el nodo que queremos borrar y luego disponemos
} un puntero en el nodo anterior y otro puntero en el nodo siguiente. Seguidamente
} procedemos a enlazar los nodos.
else
public void InsertarUltimo(int x) {
{ Nodo reco = raiz;
Nodo nuevo = new Nodo(); for (int f = 1; f <= pos - 1; f++)
nuevo.info = x; reco = reco.sig;
if (raiz == null) Nodo anterior = reco.ant;
reco = reco.sig;
{
anterior.sig = reco;
nuevo.sig = nuevo; reco.ant = anterior;
nuevo.ant = nuevo; }
raiz = nuevo; }
} }
else
{ static void Main(string[] args)
{
Nodo ultimo = raiz.ant;
ListaCircular lc=new ListaCircular();
nuevo.sig = raiz; lc.InsertarPrimero(100);
nuevo.ant = ultimo; lc.InsertarPrimero(45);
raiz.ant = nuevo; lc.InsertarPrimero(12);
ultimo.sig = nuevo; lc.InsertarPrimero(4);
} Console.WriteLine("Luego de insertar 4 nodos al principio");
} lc.Imprimir();
lc.InsertarUltimo(250);
lc.InsertarUltimo(7);
public bool Vacia() Console.WriteLine("Luego de insertar 2 nodos al final");
{ lc.Imprimir();
if (raiz == null) Console.WriteLine("Cantidad de nodos:"+lc.Cantidad());
return true; Console.WriteLine("Luego de borrar el de la primer posición:");
else lc.Borrar(1);
lc.Imprimir();
return false;
Console.WriteLine("Luego de borrar el de la cuarta posición:");
} lc.Borrar(4);
lc.Imprimir();
Console.ReadKey();
}
}
}
using System;

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
Random rnd = new Random();
ListaDoblementeEnlazada lista = new ListaDoblementeEnlazada();

for (int k = 0; k < 20; k++) lista.Agregar(rnd.Next(0, 100));

Nodo sig = lista.Primero;

while (sig != null)
{
Console.Write(sig.Valor.ToString() + '\t');
sig = sig.Siguiente;
}

Console.WriteLine('\n');
Nodo ant = lista.Ultimo;
while (ant != null)
{
Console.Write(ant.Valor.ToString() + '\t');
ant = ant.Anterior;
}

Console.ReadKey();
}
}

class ListaDoblementeEnlazada
{
private Nodo m_primero;
private Nodo m_ultimo;

public Nodo Primero { get { return m_primero; } }

public Nodo Ultimo { get { return m_ultimo; } }

public ListaDoblementeEnlazada()
{
m_primero = null;
m_ultimo = null;
}

public virtual void Agregar(int valor)

{
Nodo nuevo = new Nodo();

nuevo.Valor = valor;

if (m_primero == null)
{
m_primero = nuevo;
m_ultimo = nuevo;

nuevo.Anterior = null;
nuevo.Siguiente = null;
}
else
{
Nodo aux = m_primero;

while (aux != null && aux.Valor < valor)

{
aux = aux.Siguiente;
}

if (aux == null)
{
nuevo.Anterior = m_ultimo;
Ultimo.Siguiente = nuevo;
nuevo.Siguiente = null;
m_ultimo = nuevo;
}
else
{
if (aux.Anterior == null) m_primero = nuevo;
else aux.Anterior.Siguiente = nuevo;

nuevo.Anterior = aux.Anterior;
aux.Anterior = nuevo;
nuevo.Siguiente = aux;
}
}
}
}

class Nodo
{
public Nodo Anterior { get; set; }
public Nodo Siguiente { get; set; }
public int Valor { get; set; }
}