LAS ESTRUCTURAS

Las estructuras son tipos definidos por el programador y son un conjunto de datos agrupados.
Supongamos que programamos una agenda telefónica. Desde luego, la agenda necesita guardar
mucha información, por lo que ya hemos pensado en usar arreglos. Pero también necesitamos
pensar en los datos que debe contener como:

nombre, edad, teléfono.

Esto nos lleva a tener tres arreglos. Si necesitamos más datos, entonces más arreglos serán
necesarios. Al final es posible que sea un poco complicado administrar tantos arreglos y esto
reduce la flexibilidad de nuestro software.

Lo mejor sería poder agrupar esa información, de forma tal que solamente tengamos que
administrar un solo arreglo. La forma de poder agrupar la información es por medio del uso de
las estructuras.

Cuando creamos una estructura, definimos un nuevo tipo y adentro de este tipo podremos
colocar datos. Estos datos se conocen como campos. Cada campo está representado por una
variable, que puede ser de cualquier tipo. Luego que hemos terminado de definir la estructura
podemos crear variables de esta estructura y guardar la información que necesitemos en ellas.

ESTRUCTURA DINÁMICA LISTA

Una lista está formada por una serie de elementos llamados nodos los cuales son objetos que
contiene como variable miembro un puntero asignado y variables de cualquier tipo para manejar
datos. El puntero sirve para enlazar cada nodo con el resto de nodos que conforman la lista.

De esto podemos deducir que una lista (lista) es una secuencia de nodos en el que cada nodo
esta enlazado o conectado con el siguiente (por medio del puntero mencionado anteriormente).
El primer nodo de la lista se denomina cabeza de la lista y el último nodo cola de la lista. Este
último nodo suele tener su puntero igualado a NULL Para indicar que es el fin de la lista.

En las listas de acuerdo a quién apunte su cabeza y cola y al tipo de nodo que implementa
(cuántos punteros tiene) se dividen en cuatro grandes tipos:

 Listas enlazadas (simplemente enlazadas)

 Listas doblemente enlazadas
 Listas circulares (simplemente circulares)
 Listas doblemente circulares

Las listas simplemente enlazadas, permiten recorrer la lista en un solo sentido y desde la cabeza
hasta la cola.
Las listas doblemente enlazadas, permiten el recorrido en dos direcciones, de la cabeza a la cola
y de la cola hacia la cabeza.

Las listas simplemente circulares, permiten el recorrido en una dirección, pero al llegar al
último nodo (cola) este se encuentra comunicado o enlazado a la cabeza, haciendo un anillo o
circulo si se representa gráficamente.

Las listas doblemente circulares, permiten el recorrido en ambas direcciones y la cabeza y cola
se encuentran conectadas en ambas direcciones.

LISTA SIMPLEMENTE ENLAZADA

Los nodos de la lista simplemente enlazada tienen la siguiente forma:
El dato que contenga un nodo puede ir desde un tipo de dato básico como un entero, decimal o
carácter hasta algo más complejo como una estructura completa. Los punteros son los que
enlazan al nodo con otros nodos exactamente iguales a él.

La lista enlazada es una estructura de datos dinámica cuyos nodos suelen ser normalmente
registros y que tienen un tamaño fijo. Ahora bien suelen llamarse estructuras dinámicas porque
se crean y destruyen según se vayan necesitando. De este modo se solicita o libera memoria en
tiempo de ejecución del programa.

Gráficamente una lista enlazada puede representarse de la siguiente forma:

Las operaciones típicas de la lista incluyen: Crear la lista, verificar si está vacía, insertar
elementos, eliminar elementos, mostrar elementos.

La lista no tiene ninguna restricción en cuanto a dónde puede eliminar o agregar nodos y es
precisamente esta característica lo que la hace la estructura más versátil.

Lista Doblemente Enlazada

Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o lista enlazadas de dos
vías. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL si es el
primer nodo; y otro que apunta al nodo siguiente, o apunta al valor NULL si es el último nodo.
Una lista doblemente enlazada contiene tres valores: el valor, el link al nodo siguiente, y el link
al anterior.

Las listas doblemente enlazadas no necesitan un nodo especial para acceder a ellas, pueden
recorrerse en ambos sentidos a partir de cualquier nodo, esto es porque a partir de cualquier
nodo, siempre es posible alcanzar cualquier nodo de la lista, hasta que se llega a uno de los
extremos.

Código de Ejemplo – Lista Doblemente Enlazada:

Estructura del nodo:

class Nodo //estructura que van a contener los nodos

{
private int dato;
private Nodo siguiente; //Apuntadores de la estructura al siguiente nodo
private Nodo atras; //apuntador que nos sirve para enlazar al nodo anterior

public int Dato

{
get { return dato; }
set { dato = value; }
}

public Nodo Siguiente

{
get { return siguiente; }
set { siguiente = value; }

}
public Nodo Atrás //este es el que nos permite retornar en la lista
{
get { return atras; }
set { atras = value; }
}
}

Clase Lista que aplica el encapsulamiento del Nodo

class Lista // lista doble, que permite recorrerla desde el primero al ultimo nodo o viceversa
{
private Nodo primero = new Nodo(); //apuntara a la cabeza de la lista
private Nodo ultimo = new Nodo(); //apuntara a la cola de la lista

public Lista() // constructor que inicializa los nodos en nulo, mientras no este creada o no tenga ningun valor
{
primero = null;
ultimo = null;
}

// primer metodo para insentar nodo a una lista

public void insertarnodo()
{
Nodo nuevo = new Nodo();
Console.Write("\n Ingresar dato que tendra el nuevo nodo: ");
nuevo.Dato = int.Parse(Console.ReadLine()); // toma el dato que ingresa el usuario
// identifica si este nodo es el primero de la lista
if (primero == null)
 {
primero = nuevo; //primero va a apuntar al primer valor ingresado
primero.Siguiente = null; //permite apintar el nodo al siguiente nulo
primero.Atras = null; //permite apuntar a un nodo anterior, en este caso como es el primero apunta a nulo
ultimo = primero; // por ser el primer nodo, aqui le indicamos que a la vez sera tambien el ultimo nodo
}
else // condiciones que nos serviran para enlazar al siguiente dato que contendra el nuevo nodo
{
ultimo.Siguiente = nuevo;
nuevo.Siguiente = null; // nuevo nodo ingresado apuntara a null porque no tiene otro valor atras de el
nuevo.Atras = ultimo; // apuntara al ultimo nodo ingresado, osea al anterior
ultimo = nuevo; // aqui le actualizamos la referencia, y le indicamos que el ultimo es el nodo
recientemente ingresado
}
Console.Write("\n Nuevo nodo ingresado con exito");// solamente para confirmar que se ingreso un dato en el
nodo
}

/*Metodos para verificar que se este ejecutando correctamente la carga de valores en los nodos.
uno sera el que permitira recorrer la lista del primero al ultimo y la siguiente lo ejecuta al contrario*/
public void desplegarListaPU() //metodo para recorrer de Primero al Ultimo Nodo
{
Nodo actual = new Nodo();
actual = primero; //sirve para identificar al primer nodo como el actual
while(actual != null)
{
Console.WriteLine(" " + actual.Dato); //muestra en pantalla el dato que tiene el nodo actual
actual = actual.Siguiente;
}
}

public void desplegarListaUP ()//muestra la lista desde el ultimo nodo hasta el primero
{
Nodo actual = new Nodo();
actual = ultimo;
while(actual!= null)
{
Console.WriteLine(" " + actual.Dato); //muestra en pantalla el dato que tiene el nodo actual
actual = actual.Atras;
}
}
}

Menú Principal para ejecutar el código

static void Main(string[] args)

{
Lista l = new Lista();
l.insertarnodo();
l.insertarnodo();
l.insertarnodo();
l.insertarnodo();
l.insertarnodo();
Console.WriteLine("\n Primero al Ultimo");
l.desplegarListaPU();

Console.WriteLine("\n Ultimo al Primero");

l.desplegarListaUP();
Console.ReadLine(); // hace una pausa para leer la siguiente accion antes de continuar
}

Listas enlazadas circulares

Una lista circular es una lista lineal en la que el último nodo a punta al primero. Esto se puede
hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer una
lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier
dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas
enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el
más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a
partir de uno dado.

Código de Ejemplo – Listas enlazadas circulares:

Estructura del nodo:

class Nodo
{
private int dato;
private Nodo siguiente;

public int Dato

{
get { return dato; }
set { dato = value; }
}
public Nodo Siguiente
{
get { return siguiente; }
set { siguiente = value; }
}
}

Clase Lista que aplica el encapsulamiento del Nodo

class Lista
{
//servira para crear una lista circular simple
private Nodo primero = new Nodo(); //donde inicia la lista
private Nodo ultimo = new Nodo(); // donde termina la lista

public Lista() //constructor que inicializa los nodos en nulo

{
primero = null;
ultimo = null;
}
public void InsertarNodo()//inserta valores en los nodos
{
Nodo nuevo = new Nodo();
Console.Write("Ingrese el dato del nuevo nodo: ");
nuevo.Dato = int.Parse(Console.ReadLine()); //convierte en entero el valor que se ingrese en la consola por
parte del usuario
if (primero == null)
{
primero = nuevo;
primero.Siguiente = primero; //como es una lista circular simple, se debe quedar apuntandose a el mismo y
no a null como una lista enlazada
ultimo = primero;
}
else // en caso que ya exista un valor en el primer nodo
 {
ultimo.Siguiente = nuevo;
nuevo.Siguiente = primero;
ultimo = nuevo;
}
Console.WriteLine("\n Nodo Ingresado con exito \n\n");
}

//este es el metodo que nos va a permitir desplegar en pantalla los datos de la lista circular
public void desplegarLista()
{
Nodo actual = new Nodo();
actual = primero;
if (actual!=null)
{
do
{
Console.WriteLine(" " + actual.Dato);
actual = actual.Siguiente;
}
while (actual != primero);//esto impide que se genere un bucle al recorrer el listado, por ello se
detiene al detectar el primer nodo
}
else
{
Console.WriteLine("\n La lista esta vacia");
}
}

Menú Principal para ejecutar el código:

static void Main(string[] args)

{
Lista l = new Lista();
l.InsertarNodo();
l.InsertarNodo();
l.InsertarNodo();
l.InsertarNodo();
l.InsertarNodo();
Console.WriteLine("\n La lista ha sido ingresada \n");

l.desplegarLista();
Console.ReadLine();//solamente para que haga una pausa y ver el resultado en pantalla
}

PILAS (STACK)

Una pila (stack en inglés) es una estructura de datos 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
apliado (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.

Código de Ejemplo – Pila Simple:

Estructura del nodo:

class Nodo
{
private int dato;
private Nodo siguiente;

public int Dato

{
get { return dato; }
set { dato = value; }
 }

public Nodo Siguiente

{
get { return siguiente; }
set { siguiente = value; }
}
}

Clase Pila que aplica el encapsulamiento del Nodo

class Pila
{
private Nodo Primero = new Nodo();

public Pila() //constructor del metodo para inicializar en nulo

{
Primero = null;
}

//creacion de los metodos que utilizara pila, usando la clase nodo

public void InsertarNodo ()/* con este metodo logramos apilar los datos, siendoel primero el ultimo en salir*/
{
Nodo Nuevo = new Nodo();
Console.Write("Ingrese el dato que contendra el nuevo nodo");
Nuevo.Dato = int.Parse(Console.ReadLine()); //ingresa el valor dado por el usuario, a la variable dato
Nuevo.Siguiente = Primero; //
Primero = Nuevo;

Console.WriteLine("\n Nodo ingresado \n\n");

}

//metodo para recorrer la pila, y mostrarlos en pantalla

public void desplegarPila()

{
Nodo Actual = new Nodo();

Actual = Primero; //nos permite ubicar en donde esta el inicio de la pila o mejor dicho la cima, el nodo que
se encuentra arriba

if ( Primero != null)
{
while(Actual != null) //se ejecuta mientras actual no sea nulo, que si tenga datos
{
Console.WriteLine(" " + Actual.Dato);
Actual = Actual.Siguiente;
}
}
else
{
Console.WriteLine("\n La Pila se encuentra vacia"); //mensaje en caso no se tengan datos
}
}
}

Menú Principal para ejecutar el código:

static void Main(string[] args) //metodo principal

{
Pila p = new Pila(); //Instanciar un objeto de tipo Pila

p.InsertarNodo();
p.InsertarNodo();
p.InsertarNodo();
p.InsertarNodo();
p.InsertarNodo();

Console.WriteLine("\n La Pila de datos ha sido ingresada");

p.desplegarPila();
 Console.ReadLine();
}

COLAS

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que
la operación de inserción push se realiza por un extremo y la operación de extracción pop por el
otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer
elemento en entrar será también el primero en salir.

El tipo cola representa la idea que tenemos de cola en la vida real. La cola para subir al autobús
está compuesta de elementos (personas), que dispone de dos extremos comienzo y fin. Por el
comienzo se extraerá un elemento cuando haya comprado el billete para su viaje, y si llega una
nueva persona con intención de usar el autobús, tendrá que colocarse al final y esperar que todos
los elementos situados antes que él abandonen la cola.

Código de Ejemplo – Cola Simple:

Estructura del nodo:

namespace Cola_funcionamiento
{
class Nodo
{
private int dato;
private Nodo siguiente;

public int Dato

 {
get { return dato; }
set { dato = value; }
}

public Nodo Siguiente

{
get { return siguiente; }
set { siguiente = value; }
}
}
}

Clase Cola que aplica el encapsulamiento del Nodo

class Cola
{
private Nodo Primero = new Nodo();
private Nodo Ultimo = new Nodo();

public Cola()
{
Primero = null;
Ultimo = null;
}

public void insertarNodo() // es similar a una lista simple

{
Nodo Nuevo = new Nodo();
Console.Write("Ingrese el dato para el nuevo Nodo: ");
Nuevo.Dato = int.Parse(Console.ReadLine());

// definir cual es el primer nodo de la cola

if(Primero == null)
{
Primero = Nuevo;
Primero.Siguiente = null;
Ultimo = Nuevo;
}
else
{
Ultimo.Siguiente = Nuevo;
Nuevo.Siguiente = null;
Ultimo = Nuevo;
}
Console.WriteLine("\n Nodo ingresado\n");
}

public void desplegarCola()

{
Nodo Actual = new Nodo();
Actual = Primero;
if(Primero != null)
{
while(Actual!= null)
{
Console.WriteLine(" " + Actual.Dato);
Actual = Actual.Siguiente;
}
}
else
{
Console.WriteLine("\n La Cola se encuentra Vacia\n");
}
}
}

Menú Principal para ejecutar el código:

static void Main(string[] args)

{
Cola c = new Cola();

c.insertarNodo();
c.insertarNodo();
c.insertarNodo();
c.insertarNodo();
c.insertarNodo();

Console.WriteLine("\n Conla ingresada\n ");

c.desplegarCola();
Console.ReadLine();