ESTRUCTURA DE DATOS, pilas, colas, listas enlazadas

5353
53
53

INSTITUTO TECNOLÓGICO SUPERIOR DE LA REGIÓN SIERRAMATERIA: ESTRUCTURA DE DATOSDOCENTE: JOSÉ DE JESÚS LENIN VALENCIA CRUZALUMNO: JOSÉ EMMANUEL PÉREZ ALVARADONUMERO DE CONTROL: 14E30366INGENIERÍA: INFORMÁTICAFECHA DE ENTREGA: 27/NOV/2015JEPA[Escriba el nombre de la compañía][Seleccione la fecha]INSTITUTO TECNOLÓGICO SUPERIOR DE LA REGIÓN SIERRAMATERIA: ESTRUCTURA DE DATOSDOCENTE: JOSÉ DE JESÚS LENIN VALENCIA CRUZALUMNO: JOSÉ EMMANUEL PÉREZ ALVARADONUMERO DE CONTROL: 14E30366INGENIERÍA: INFORMÁTICAFECHA DE ENTREGA: 27/NOV/2015JEPA[Escriba el nombre de la compañía][Seleccione la fecha]
INSTITUTO TECNOLÓGICO SUPERIOR DE LA REGIÓN SIERRA

MATERIA: ESTRUCTURA DE DATOS

DOCENTE: JOSÉ DE JESÚS LENIN VALENCIA CRUZ

ALUMNO: JOSÉ EMMANUEL PÉREZ ALVARADO

NUMERO DE CONTROL: 14E30366

INGENIERÍA: INFORMÁTICA

FECHA DE ENTREGA: 27/NOV/2015

JEPA
[Escriba el nombre de la compañía]
[Seleccione la fecha]
INSTITUTO TECNOLÓGICO SUPERIOR DE LA REGIÓN SIERRA

MATERIA: ESTRUCTURA DE DATOS

DOCENTE: JOSÉ DE JESÚS LENIN VALENCIA CRUZ

ALUMNO: JOSÉ EMMANUEL PÉREZ ALVARADO

NUMERO DE CONTROL: 14E30366

INGENIERÍA: INFORMÁTICA

FECHA DE ENTREGA: 27/NOV/2015

JEPA
[Escriba el nombre de la compañía]
[Seleccione la fecha]

ÍNDICE

INTRODUCCIÓN……………………………………………………… pág.2
PILAS………………………………………………………………………. Pág.3
COLAS…………………………………………………………………….. pág.12
LISTAS ENLAZADAS…………………………………………………. Pág.26
CONCLUSIÓN………………………………………………………….. pág.52
BIBLIOGRAFÍA…………………………………………………………. Pág.53

Introducción

Como ya sabemos, las computadoras fueron diseñadas o ideadas como una herramienta mediante la cual podemos realizar operaciones de cálculo complicadas en un lapso de mínimo tiempo. Pero la mayoría de las aplicaciones de este fantástico invento del hombre, son las de almacenamiento y acceso de grandes cantidades de información.
La información que se procesa en la computadora es un conjunto de datos, que pueden ser simples o estructurados. Los datos simples son aquellos que ocupan sólo una localidad de memoria, mientras que los estructurados son un conjunto de casillas de memoria a las cuales hacemos referencia mediante un identificador único.
Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples (enteros, reales, booleanos, etc.) que por sí solos no nos dicen nada, ni nos sirven de mucho, es necesario tratar con estructuras de datos adecuadas a cada necesidad.
Las estructuras de datos son una colección de datos cuya organización se caracteriza por las funciones de acceso que se usan para almacenar y acceder a elementos individuales de datos.
Una estructura de datos se caracteriza por lo siguiente:
Pueden descomponerse en los elementos que la forman.
La manera en que se colocan los elementos dentro de la estructura afectará la forma en que se realicen los accesos a cada elemento.
La colocación de los elementos y la manera en que se accede a ellos puede ser encapsulada.

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. Representación gráfica de una pila
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.
Ejemplo 1.
Forma principal

Procedimiento: Inserción de un elemento en Pila
AlgoritmoInserción (Pila, Cima, Elemento)
1. [¿Pila llena?]
Si Cima = MaxPila, entonces:
- Escribir: Desbordamiento (Overflow) y Volver
Cima = Cima + 1;
Pila [Cima] = ElementoCódigo
Void CmdInsercionClick(object sender, EventArgs e)
{
String elemento = txtElemento.Text;
txtElemento.Text = "";
txtElemento.Focus();

if (frmPrincipal.Cima == frmPrincipal.MaxPila)
{
MessageBox.Show("Pila llena (Overflow)");
return;
}
frmPrincipal.Cima = frmPrincipal.Cima + 1;
frmPrincipal.Pila[frmPrincipal.Cima] = elemento; // Inserta elemento en Pila
}
Corrida

Procedimiento: Recorrido de elementos en Pila
AlgoritmoRECORRIDO (Pila, Top)
1. Apuntador = Top
2. repetir paso 3 mientras Apuntador != nulo
3. imprimir Pila(Apunatdor)
4. Apuntador = Apuntador - 1.
Fin del ciclo.
5. Salir.

Código
Void CmdRecorrerClick(object sender, EventArgs e)
{
// Verifica si la Pila esta vacia
if (frmPrincipal.Cima == -1)
{
MessageBox.Show("Pila Vacia (Underflow)");
return;
}
int i = 0;
do
{
lsRecorrer.Items.Add(frmPrincipal.Pila[i]);
i = i + 1;
}
while (i <= frmPrincipal.Cima);
}
Corrida

Procedimiento: Búsqueda de un elemento en Pila
AlgoritmoBUSQUEDA (Pila, Top, Elemento)
1. Si Top != Nulo
Apuntador = Top
2. Repetir mientras Apuntador != Nulo
3. Si Pila[Apuntador] = Elemento
Imprimir "El Dato fue encontrado" y Salir
Apuntador = Apuntador - 1
Fin del ciclo
Si no:
Imprimir "El Dato no se encontró"
4. Salir.Código
Void CmdBuscarClick(object sender, EventArgs e)
{
string elemento = txtElemento.Text;
txtElemento.Text = "";
txtElemento.Focus();
// Verifica si la pila esta vacia
if (frmPrincipal.Cima == -1)
{
MessageBox.Show("Pila vacia (Underflow)");
return;
}
int i = 0;
do
{
int res = string.Compare(elemento,frmPrincipal.Pila[i]);
if (res == 0)
{
lsRes.Items.Add(frmPrincipal.Pila[i]);
return;
}
i = i + 1;
}
while (i <= frmPrincipal.Cima);
MessageBox.Show("Elemento no encontrado en Pila");
}
Corrida

Procedimiento: Eliminación de elemento en Pila
AlgoritmoEliminar (Pila, Cima, Elemento)
1. [¿Pila Vacía?]
Si Cima = -1, entonces:
Escribe: Subdesbordamiento (Underflow)
2. Elemento = Pila [Cima]
3. Cima = Cima - 1código
Void CmdEliminarClick(object sender, EventArgs e)
{
if (frmPrincipal.Cima == -1) {
MessageBox.Show("Pila Vacia (Underflow)");
return;
}
string Elemento = frmPrincipal.Pila[frmPrincipal.Cima];
frmPrincipal.Cima = frmPrincipal.Cima - 1;
lsEliminados.Items.Add(Elemento);
}
Corrida

Ejemplo 2.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;// necesario para poder declarar un "STACK"

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Stack pila = new Stack();//instancio un nuevo objeto stack(pila)

pila.Push(1);//agrego un elemento a la pila
pila.Push(4);
pila.Push(1);
pila.Push(6);
pila.Push(3);
pila.Push(5);
pila.Push(9);

for (int i = 0; i < 3; i++)//itera 3 veces para ir retirando elementos de la pila
{
//pila.pop saca elementos de la pila
Console.WriteLine("Elemento retirado de la pila: " + pila.Pop());//imprime los elementos que va retirando el .pop
Console.WriteLine("el próximo elemento que queda en la pila es: " + pila.Peek());//muestra el elemento siguiente en la pila sin eliminarlo
Console.WriteLine("");
}
Console.ReadKey();
}
}
}

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.
Ejemplo 1.
Código principal.
public partial class frmPrincipal
{
// Variables globales
public static string[] Cola;
public static int Frente;
public static int Final;
public static int N;

[STAThread]
public static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmPrincipal());
}

public frmPrincipal() // Constructor
{

InitializeComponent();

Cola = new string[5]; // Arreglo lineal de 5
N = 4;
Frente = -1;
Final = -1;
}

void CmdInsercionClick(object sender, System.EventArgs e)
{
frmInsercion Insercion = new frmInsercion();
Insercion.Show();
}

void CmdRecorridoClick(object sender, System.EventArgs e)
{
frmRecorrido Recorrido = new frmRecorrido();
Recorrido.Show();
}

void CmdBusquedaClick(object sender, EventArgs e)
{
frmBusqueda Busqueda = new frmBusqueda();
Busqueda.Show();
}

void CmdEliminacionClick(object sender, EventArgs e)
{
frmEliminacion Eliminar = new frmEliminacion();
Eliminar.Show();
}
}
Corrida

Procedimiento 1: Inserción de elemento en Cola
Algoritmo Insertar (Cola, N, Frente, Final, Elemento)1. [¿La Cola está llena?]
Si Frente = 0 y Final = N
Escribir: Desbordamiento y Volver
Si Frente = Final + 1
Escribir: Desbordamiento y Volver
2. [Encontrar el nuevo valor de Final]
Si Frente = -1, entonces: [La cola está vacía]
Hacer Frente = 0 y Final = 0
Si no, Si Final = N, entonces:
Hacer Final = 0
Si no
Hacer Final = Final + 1
[Fin del condicional]
3. Hacer Cola [Final] = ElementoCODIGO
void CmdInsertarClick(object sender, System.EventArgs e)
{
elemento = txtInsercion.Text;
// Se verifica que haya espacio en la Cola
If (frmPrincipal.Frente == 0 && frmPrincipal.Final == frmPrincipal.N)
{
MessageBox.Show("La Cola está llena"); // Desbordamiento (Overflow)
return;
}
if (frmPrincipal.Frente == frmPrincipal.Final + 1)
{
MessageBox.Show("La Cola está llena"); // Desbordamiento (Overflow)
return;
}

// Si la cola esta vacia se inicializan punteros
If (frmPrincipal.Frente == -1)
{
frmPrincipal.Frente = 0;
frmPrincipal.Final = 0;
}
else if (frmPrincipal.Final == frmPrincipal.N)
{
frmPrincipal.Final = 0;
}
else
{
frmPrincipal.Final = frmPrincipal.Final + 1;
}
// Se agrega elemento a la Cola
frmPrincipal.Cola[frmPrincipal.Final] = elemento;
txtInsercion.Text = "";
}
Corrida

Procedimiento 2: Recorrido de elementos en Cola
Algoritmo Recorrido (Cola, Frente, Final, N)1. [¿Cola Vacía?]
Si Frente = -1 y Final = -1, entonces
Escribir: Cola Vacía (Underflow)
2. Si no, si Frente = Final, entonces:
Escribir: Cola [Frente]
3. Si no, si Final < Frente
Hacer i = Frente
Repetir Mientras i <= N
Escribir: Cola[i]
Hacer i = i + 1
Hacer j = 0
Repetir Mientras j <= Final
Escribir: Cola[j]
Hacer j = j + 1
4. Si no
Hacer i = Frente
Repetir Mientras i <= Final
Escribir: Cola[i]
Hacer i = i + 1

CODIGO
void CmdRecorridoClick(object sender, System.EventArgs e)
{
if (frmPrincipal.Frente == -1 && frmPrincipal.Final == -1)
{
MessageBox.Show("Cola Vacia");
return;
}
else if (frmPrincipal.Frente == frmPrincipal.Final)
{
lsElemCola.Items.Add(frmPrincipal.Cola[frmPrincipal.Frente]);
}

else if (frmPrincipal.Final < frmPrincipal.Frente)
{
int i = frmPrincipal.Frente;
do
{
lsElemCola.Items.Add(frmPrincipal.Cola[i]);
i = i + 1;
} while (i <= frmPrincipal.N);

int j = 0;
do
{
lsElemCola.Items.Add(frmPrincipal.Cola[j]);
j = j + 1;
} while (j <= frmPrincipal.Final);
}

else
{
do
{
lsElemCola.Items.Add(frmPrincipal.Cola[i]);
i = i + 1;
} while (i <= frmPrincipal.Final);
}

Procedimiento 3: Busqueda de elemento en cola
Algoritmo Búsqueda (Elemento, Cola, N, Frente, Final)1. [¿Cola Vacía?]
Si Frente = -1 y Final = -1, entonces
Escribir: Cola Vacía (Underflow)
2. Si no, si Frente = Final, entonces:
Si Elemento = Cola[Frente]
Escribir: Cola[Frente] y Volver
3. Si no, si Final < Frente
Hacer i = Frente
Repetir Mientras i <= N
Si Elemento = Cola[i]
Escribir: Cola[i] y Volver
Si no
Hacer i = i + 1
Hacer j = 0
Repetir Mientras j <= Final
Si Elemento = Cola[j]
Escribir: Cola[j] y Volver
Si no
Hacer j = j + 1
4. Si no
Hacer i = Frente
Repetir Mientras i <= Final
Si Elemento = Cola[i]
Escribir: Cola[i] y Volver
Si no
Hacer i = i + 1
5. Escribir: "No se encuentra elemento en cola"CODIGO
void CmdBuscarClick(object sender, EventArgs e)
{
string elemento = txtBuscar.Text;
txtBuscar.Text = "";
txtBuscar.Focus();

if (frmPrincipal.Frente == -1)
{
MessageBox.Show("Cola Vacía");
return;
}
if (frmPrincipal.Frente == frmPrincipal.Final)
{
int res = string.Compare(elemento,frmPrincipal.Cola[frmPrincipal.Frente]);
if (res == 0)
{
lsBusqueda.Items.Add(frmPrincipal.Cola[frmPrincipal.Frente]);
return;
}

}

else if (frmPrincipal.Final < frmPrincipal.Frente)
{
do
{
int res = string.Compare(elemento,frmPrincipal.Cola[i]);
if (res == 0)
{
lsBusqueda.Items.Add(frmPrincipal.Cola[i]);
return;
}
else i = i + 1;
} while (i <= frmPrincipal.N);

int j = 0;
do
{
int res = string.Compare(elemento,frmPrincipal.Cola[j]);
if (res == 0)
{
lsBusqueda.Items.Add(frmPrincipal.Cola[j]);
return;
}
else j = j + 1;
} while (j <= frmPrincipal.Final);
}
else
{
do
{
int res = string.Compare(elemento,frmPrincipal.Cola[i]);
if (res == 0)
{
lsBusqueda.Items.Add(frmPrincipal.Cola[i]);
return;
}
else i = i + 1;
} while (i <= frmPrincipal.Final);
}
MessageBox.Show("No se encuentra elemento en cola");

Procedimiento 4: Eliminación de elemento en cola
Algoritmo Eliminación (Cola, Frente, Final, N)1. [¿Cola Vacía?]
Si Frente = -1 entonces
Escribir: "Cola Vacía" (Underflow) y Volver
2. Hacer Elemento = Cola[Frente] 3. [Encontrar el nuevo valor de Frente]
Si Frente = Final, entonces [La cola solo tenía un elemento]
Hacer Frente = -1 y Final = -1
Si no, si Frente = N, entonces
Hacer Frente = 0
Si no
Hacer Frente = Frente + 1
[Fin de la condición]
4. Escribir: "Elemento eliminado (Elemento)" 5. VolverCódigo
void CmdEliminarClick(object sender, EventArgs e)
{
if (frmPrincipal.Frente == -1)
{
MessageBox.Show("Cola Vacia");
return;
}
string elemento = frmPrincipal.Cola[frmPrincipal.Frente];

// si la cola tiene un solo elemento
if (frmPrincipal.Frente == frmPrincipal.Final)
{
frmPrincipal.Frente = -1;
frmPrincipal.Final = -1;
}
else if (frmPrincipal.Frente == frmPrincipal.N)
{
frmPrincipal.Frente = 0;
}
else
{
frmPrincipal.Frente = frmPrincipal.Frente + 1;
}
lsEliminado.Items.Add(elemento);
}

Ejemplo 2.
using System;
using System.Linq;
using System.Text;
using System.Collections;// necesario para poder declarar un "Queue"

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Queue cola = new Queue();//instancio un nuevo objeto Queue(Cola)

cola.Enqueue("Perro");//agrego un elemento a la cola
cola.Enqueue("Gato");
cola.Enqueue("Loro");
cola.Enqueue("Tigre");
cola.Enqueue("Leon");
cola.Enqueue("Lobo");
cola.Enqueue("Zorro");
cola.Enqueue("Conejo");

for (int i = 0; i < 3; i++)//itera 3 veces para ir retirando elementos de la cola
{
Console.WriteLine("Elementos totales que se encuentran en la cola: " + cola.Count);//.count cuenta la cantidad de elementos en la cola

Console.WriteLine("Elemento retirado de la cola: " +cola.Dequeue());//.dequeue() retira un elemento de la cola
Console.WriteLine("el proximo elemento que queda en la cola es: " +cola.Peek());//.peek() muestra el proximo elemento de la cola, sin retirarlo
}
Console.WriteLine("Elementos totales que se encuentran en la cola: " + cola.Count);
Console.ReadKey();
}
}
}

LISTAS ENLAZADAS
Una lista enlazada la constituye una colección lineal de elementos, llamados nodos, donde el orden de los mismos se establece mediante punteros. Cada nodo se divide en dos partes: una primera que contiene la información asociada al elemento, y una segunda parte, llamada campo de enlace o campo al siguiente puntero, que contiene la dirección del siguiente nodo de la lista.
Una lista enlazada es una colección lineal de elementos donde el orden de los mismos se establece mediante punteros. La idea básica es que cada componente de la lista incluya un puntero que indique donde puede encontrarse el siguiente componente por lo que el orden relativo de estos puede ser fácilmente alterado modificando los punteros lo que permite, a su vez, añadir o suprimir elementos de la lista.
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:
Ventajas de usar listas: Las listas son dinámicas, es decir, podemos almacenar en ellas tantos elementos como necesitemos, siempre y cuando haya espacio suficiente espacio en memoria. Al insertar un elemento en la lista, la operación tiene un tiempo constante independientemente de la posición en la que se inserte, solo se debe crear el nodo y modificar los enlaces. Esto no es así en los arreglos, ya que si el elemento lo insertamos al inicio o en medio, tenemos un tiempo lineal debido a que se tienen que mover todos los elementos que se encuentran a la derecha de la posición donde lo vamos a insertar y después insertar el elemento en dicha posición; solo al insertar al final del arreglo se obtienen tiempos constantes. Al eliminar un elemento paso lo mismo que se mencionó en el punto anterior.
Desventajas de usar listas:
El acceso a un elemento es más lento, debido a que la información no está en posiciones contiguas de memoria, por lo que no podemos acceder a un elemento con base en su posición como se hace en los arreglos.
REPRESENTACION DE LISTAS ENLAZADAS EN MEMORIA
Sea LISTA una lista enlazada, salvo que se indique lo contrario. Almacenaremos LISTA en memoria de la forma siguiente. Como mínimo, LISTA estará compuesta por dos arrays lineales, a los que llamaremos INFO y ENLACE, tales que INFO [K] y ENLACE [K] contienen la parte de información y el campo de puntero de cada nodo de LISTA respectivamente. Necesitamos también una variable especial llamada COMIENZO que contiene la posición ocupada por el primer elemento de la lista, y una marca especial NULO que indica el final de la misma. Puesto que los índices de los arrays INFO y ENLACE serán habitualmente positivos, el valor NULO será el -999, salvo que digamos lo contrario.
El siguiente ejemplo muestra la representación memoria de una lista enlazada en la que cada nodo de la lista contiene un único carácter. Podemos obtener la lista de caracteres o, en otras palabras, la cadena de la forma siguiente:
COMIENZO = 9, luego INFO [9] = N primer carácter.
ENLACE [9] = 3, luego INFO [3] = 0 segundo carácter.
ENLACE [3] = 6, luego INFO [6] = (carácter blanco) tercer carácter.
ENLACE [6] = 11, luego INFO [11] = E cuarto carácter.
ENLACE [11] = 7, luego INFO [7] = X quinto carácter.
ENLACE [7] = 10, luego INFO [10] = I sexto carácter.
ENLACE [10] = 4, luego INFO [4] = T séptimo carácter.
ENLACE [4] = -999 valor nulo, luego termina la lista.
FORMA PRINCIPAL DE LA LISTA ENLAZADA
Código
using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace WindowsApplication1
{
public partial class Listas : Form
{
public Listas()
{
}
public static int[] enlace = new int[10] { 2, 3, 4, 0, -999, 6, 7, 8, 9, -999 };
public static string[] alumno = new string[10] { "Jose", "Ana", "Rosa", "Beto", "zeta", "", "", "", "", "" };
public static int comienzo = 1;
public static int disponible = 5;
private void cmdInsercion_Click(object sender, EventArgs e)
{
Insercion ins = new Insercion();
ins.Show();
}

private void cmdRecorrido_Click(object sender, EventArgs e)
{
Recorrer rec = new Recorrer();
rec.Show();
}

private void cmdBusqueda_Click(object sender, EventArgs e)
{
Busqueda bus = new Busqueda();
bus.Show();
}

private void cmdEliminacion_Click(object sender, EventArgs e)
{
Eliminacion eli = new Eliminacion();
eli.Show();
}
}
}
Corrida

RECORRIDO DE UNA LISTA ENLAZADA
Sea la lista enlazada, almacenada en memoria mediante dos arrays INFO y ENLACE. Adicionalmente definimos la variable COMIENZO que apunta al primer elemento de la lista y suponemos que el último nodo de la lista contiene en su campo ENLACE el valor NULO. Supongamos que queremos recorrer LISTA para procesar cada uno de sus nodos exactamente una vez. A continuación te mostrare el algoritmo que realiza esta tarea y que utilizaremos en otras aplicaciones.
Nuestro algoritmo utiliza una variable puntero PTR que apunta siempre al nodo procesado en cada momento. Por ello ENLACE [PTR] indica el siguiente nodo a ser procesado. De esta forma la asignación PTR:= ENLACE [PTR] Tiene el efecto de mover el puntero al siguiente nodo de la lista.
La descripción del algoritmo es la siguiente. Inicializamos PTR a COMIENZO. A continuación procesamos INFO [PTR], es decir, la información del primer nodo. En el paso siguiente actualizamos PTR mediante la asignación PRT: = ENLACE [PTR], lo que hace que PTR apunte ahora al segundo nodo. Nuevamente tratamos de la información contenida en INFO [PTR] (segundo nodo) y tras esto volvemos a actualizar PTR y procesamos INFO [PTR], y así sucesivamente. Este proceso de actualización y procesamiento continuara hasta que en una de las actualizaciones de PTR obtengamos que PTR = NULO, que marca el final de la lista.
Una representación formal de algoritmo es la siguiente.
Algoritmo: Recorrido de una lista enlazada.

Sea LISTA una lista enlazada que almacenamos en memoria. El algoritmo recorre LISTA realizando la operación PROCESO a cada elemento de LISTA. La variable PTR, apunta en cada momento al nodo que se está tratando.
PTR: = COMIENZO. [inicializa el puntero].
repetir pasos 3 y 4 mientras PTR!= 0.
aplicar PROCESO a INFO [PTR].
PTR: = ENLACE [PTR]. [PTR apunta ahora al siguiente nodo]. [fin del ciclo paso 2].
salir.
Codigo:

using System;
using System.Data;
using System.Text;

{
public partial class Recorrer : Form
{
public Recorrer()
{
Recorrido();
}
private void cmdRecorrer_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
Recorrido();
}

private void Recorrido()
{
int ptr = Listas.comienzo;
while (ptr != -999)
{
listBox1.Items.Add(Listas.alumno[ptr]);
ptr = Listas.enlace[ptr];
}
}
private void button1_Click(object sender, EventArgs e)
{
this.Close();
}
}
}
Corrida

BUSQUEDA EN UNA LISTA ENLAZADA
Sea LISTA una lista enlazada, almacenada en memoria. En esta sección discutimos dos algoritmos de búsqueda que localizan la posición del nodo (LUG) en el cual un elemento dado (ELEMENTO) aparece por primera vez en la lista. El primer algoritmo no necesita que la lista este ordenada, mientras que el segundo si lo exige.
Si ELEMENTO es un valor de clave y buscamos en el archivo para encontrar el registro que lo contiene, este solo puede aparecer una vez en la lista.
Lista no ordenadas
Supongamos que los datos de lista no están ordenados (necesariamente). En este caso podremos localizar ELEMENTO sin más que recorrer LISTA utilizando el puntero PTR y comparando ELEMENTO con el contenido INFO [PTR] de cada nodo. Cada vez que actualicemos PTR mediante la asignación PTR: = ENLACE [PTR], necesitamos dos comprobaciones. Primero necesitamos ver si hemos alcanzado el final de la lista, es decir comprobamos si PTR = NULO, si no, entonces comprobamos si INFO [PTR] = ELEMENTO.
Las dos comprobaciones no podemos realizarlas simultáneamente, puesto que si PTR = NULO no existirá INFO [PTR]. De acuerdo con esto utilizamos la primera comparación para controlar la ejecución de un ciclo y realizamos la segunda comparación dentro de este.
Algoritmo: BUSQ(INFO, ENLACE, COMIENZO, ELEMENTO, LUG)
LISTA es una lista enlazada almacenada en memoria. el algoritmo encuentra la posición LUG del nodo donde ELEMENTO aparece por primera vez en lista y devuelve LUG = NULO.
PTR: = COMIENZO.
repetir paso 3 mientras PTR != NULO:
si ELEMENTO = INFO[PTR], entonces: LUG: = PTR y salir.
si no: PTR: = ENLACE [PTR]. [PTR apunta ahora al nodo siguiente].
[final de la estructura condicional].
[final del ciclo del paso 2].
[la búsqueda es fallida]. LUG: = NULO.
salirLista ordenada
Supongamos que los datos de LISTA están ordenados. De nuevo buscamos ELEMENTO en la lista recorriendo la misma utilizando una variable puntero y comparando ELEMENTO con el contenido de INFO [PTR] nodo a nodo. en este caso, sin embargo, podremos finalizar la búsqueda una vez que ELEMENTO sea mayor que INFO[PTR].
Algoritmo: BUSQ(INFO, ENLACE, COMIENZO, ELEMENTO, LUG)

LISTA es una lista ordenada que se encuentra en memoria. El algoritmo encuentra la posición LUG del nodo donde se encuentra por primera vez ELEMENTO o bien devuelve LUG = NULO.
PTR:= COMIENZO.
repetir paso 3 mientras PTR != NULO:
si ELEMENTO < INFO[PTR], entonces:
PTR: = ENLACE [PTR]. [PTR apunta al siguiente nodo].
si no, si ELEMENTO = INFO[PTR], entonces:
LUG = PTR y salir. [la busqueda es satisfactoria].
si no: LUG: = NULO y salir. [ELEMENTO es mayor que INFO[PTR.
[final de la estructura condicional]
[final del ciclo del paso 2]
LUG: = NULO.
salir.

Codigo:
using System;
using System.Data;
using System.Text;

{
public partial class Busqueda : Form
{
public Busqueda()
{
}

private void cmdBuscar_Click(object sender, EventArgs e)
{
string elemento = txtbuscador.Text.ToString();
int lug = -999;
int ptr = Listas.comienzo;
if (ptr == -999) MessageBox.Show("Lista vacia", "Error");
while (ptr != -999)
{
if (Listas.alumno[ptr] == elemento)
{
lug = ptr;
MessageBox.Show("Elemento encontrado en \nposicion: " + lug.ToString(), "Elemento Encontrado");
txtbuscador.Clear();
}
else ptr = Listas.enlace[ptr];
}
if (lug == -999) MessageBox.Show("Elemento no encontrado", "Error");
}

private void button1_Click(object sender, EventArgs e)
{
this.Hide();
}
}
}
Corrida

INSERCION EN UNA LISTA ENLAZADA
Sea LISTA una lista enlazada en la que los nodos A y B ocupan posiciones sucesivas en el orden impuesto en la lista. Supongamos que queremos insertar en ella un nodo N que debe ocupar un lugar entre A y B. Después de la operación el nodo A apuntara al nodo N y este apuntara al nodo B, es decir, el nodo al que apuntaba antes A.
Algoritmo de insercion
Tres son las situaciones más comunes que nos encontraremos cuando insertamos nodos en una lista. Primero cuando queremos insertar un nodo al principio de la lista, segundo cuando queramos insertar un nodo de tras de un determinado, y tercero, cuando insertamos un nodo en una lista previamente ordenada. A continuación discutimos los algoritmos que llevan a cabo estas tareas suponiendo que la lista esta almacenada en memoria en la forma LISTA(INFO, ENLACE, COMIENZO, DISP) y que la variable ELEMENTO contiene la información que debe incorporarse a la lista.
Puesto que nuestros algoritmos de insercion utilizaran nodos de la lista de nodos disponibles, todos ellos deben incluir los siguientes pasos:
Estudiar si existe espacio libre en la lista de espacio disponible. Si no es así, es decir, si DISPONIBLE = NULO, el algoritmo debe imprimir el mensaje OVERFLOW.
Extraer el primer nodo de la lista de disponible. Si utilizamos la variable Nuevo, esta operación puede realizarse mediante dos asignaciones (en este orden) NUEVO: = DISP. DISP: = ENLACE[DISP].
Incorporar la información a insertar en el nodo recien obtenido, es decir: INFO [NUEVO] = ELEMENTO.
Insercion al principio de una lista
Supongamos que nuestra lista no está ordenada ni existe ninguna razón por la cual cualquier nodo que insertemos deba ocupar una determinada posición. En este caso lo más sencillo será insertar el nuevo nodo al comienzo de la misma. Un algoritmo que realiza esta operación es el siguiente.
Algoritmo: INSPRIN (INFO, ENLACE, COMIENZO, DISP, ELEMENTO)El algoritmo coloca ELEMENTO como primer componente de la lista.
[Overflow] si DISP = NULO, entonces: Escribir: OVERFLOW y salir.
[extrae el primer nodo de la lista DISP].
NUEVO: = DISP y DISP: = ENLACE [DISP].
INFO[NUEVO]: = ELEMENTO. [copia el dato en el nodo].
ENLACE [NUEVO]: = COMIENZO. [el nuevo nodo apunta ahora al que ocupa antes la primera posición].
COMIENZO: = NUEVO. [COMIENZO apunta ahora al elemento que ocupa la primera posición de la lista].
Salir.Insercion a continuación de un nodo determinado
Supongamos en este caso que se nos da un valor LUG que o bien representa la localización de un nodo A determinado o bien LUG = NULO. El algoritmo siguiente inserta ELEMENTO en la lista a continuación de A o bien coloca ELEMENTO como primer componente de la lista si LUG = NULO.
Sea N el nuevo nodo (cuya posición es NUEVO). Si LUG = NULO, entonces el nodo se coloca al comienzo de la lista. En otro caso hacemos que N apunte al nodo B (que originalmente seguía a A). El proceso implica las siguientes operaciones:
ENLACE [NUEVO]: = ENLACE[LUG]
Después del cual N apunta a B y
ENLACE [LUG]: = NUEVO
Tras el cual A apunta al nodo N.
Algoritmo: INSLUG (INFO, ENLACE, COMIENZO, DISP, LUG, ELEMENTO)El algoritmo inserta ELEMENTO a continuación del nodo que ocupa la posición LUG o coloca ELEMENTO como primer nodo si LUG=NULO
[Overflow] Si DISP = NULO, entonces: escribir: OVERFLOW y salir.
[Extrae el primer nodo de la lista de disponibles]
NUEVO: = DISP y DISP: = ENLACE [DISP].
INFO [NUEVO]: = ELEMENTO. [copia el dato en el nodo obtenido].
Si LUG = NULO, entonces [Lo inserta como primer nodo].
ENLACE [NUEVO]: = COMIENZO y COMIENZO: = NUEVO.
Si no: [Inserta de tras del nodo de posicion LUG].
ENLACE [NUEVO]: = ENLACE [LUG] y ENLACE [LUG]: = NUEVO.
[Final de la estructura condicional]
Salir.
Insercion de una lista enlazada y ordenada
Supongamos que queremos insertar ELEMENTO en una lista enlazada y ordenada y que ELEMENTO cumple que INFO(a) Para ello utiliza dos punteros PTR y AUX. Con PTR recorre la lista y va comparando ELEMENTO con INFO [PTR] para todos los nodos que visita. Después de cada comparación actualiza el valor de ambos punteros, de tl forma que AUX:= PTR y posteriormente PTR:= ENLACE [PTR]. Con este mecanismo garantizamos que AUX siempre apunta al nodo que precede al que está siendo apuntado por PTR. El recorrido de la lista continua hast que INFO [PTR] > ELEMENTO, o en otras palabras, la busqueda finaliza cuando ELEMENTO INFO [PTR].
Una representación formal del procedimiento es el siguiente. En dicho procedimiento se contemplan por separado los casos en que la lista esta vacia o bien cuando ELEMENTO < INFO [COMIENZO] debido a que no precisan el uso de la variable AUX.
Procedimiento: ENCA (INFO, ENLACE, COMIENZO, ELEMENTO, LUG)

El procedimiento encuentra la posicion LUG del ultimo nodo para el que INFO [LUG] < ELEMENTO o hace LUG = NULO.
[¿Lista vacia?] Si COMIENZO = NULO, entonces: LUG = NULO y retornar.
[¿caso especial?] Si ELEMENTO < INFO [COMIENZO]. entonces: LUG: = NULO y retornar.
AUX: = COMIENZO y PTR: = ENLACE [COMIENZO]. [Inicializamos los punteros].
Repetir pasos 5 y 6 mientras PTR!= NULO.
Si ELEMENTO < INFO [PTR]. entonces:
LUG: = AUX y retornar.
[Final de la estructura condicional].
AUX: = PTR y PTR: = ENLACE [PTR]. [Actualiza los punteros].
LUG: = AUX.
Salir.

Después de esto ya tenemos las herramientas necesarias para diseñar un algoritmo que nos inserte ELEMENTO en una lista enlazada.
Algoritmo: INSERT (INFO, ENLACE, COMIENZO, DISP, ELEMENTO)

El algoritmo inserta ELEMENTO en una lista enlazada ordenada.
[Utilizamos el procedimiento 6 para encontrar la posicion del nodo que precederá a ELEMENTO.]
Llamar ENCA (INFO, ENLACE, COMIENZO, ELEMENTO, LUG)
[Utilizaremos el algoritmo 5 para insertar ELEMENTO a continuacion del nodo que ocupa la posicion LUG.]
Llamar INSLUG(INFO, ENLACE, COMIENZO, DISP, LUG, ELEMENTO)
Salir.

Codigo:

Using System;
Using System.Collections.Generic;
Using System.ComponentModel;
Using System.Data;
Using System.Drawing;
Using System.Text;
Using System.Windows.Forms;

Namespace WindowsApplication1
{
Public partial class Insercion: Form
{
Public Insercion ()
{
InitializeComponent ();
}

Private void cdmInserta_Click(object sender, EventArgs e)
{
String elemento = txtInser.Text;
txtInser.Clear();
If (Listas.disponible == -999)
{
MessageBox.Show ("Lista llena", "Error", MessageBoxButtons.OK);
}
else
{
Int anterior = -999;
Int ptr = Listas.comienzo;
Int i = 0, nuevo;
Nuevo = Listas.disponible;
bool aux = false;
Listas.disponible = Listas.enlace[nuevo];
Listas.alumno[nuevo] = elemento;
while (ptr != -999 && aux == false)
{
If (Listas.alumno [ptr].Length < elemento.Length)
{
i = Listas.alumno [Listas.comienzo].Length;
}
Else
{
i = elemento.Length;
}
int h = 0;
for (h=0; h < i; h++)
{
If (Listas.alumno [ptr][h] == elemento[h])
{
}
If (Listas.alumno [ptr][h] < elemento[h])
{ Anterior = ptr;
h = i;
}
else
{
h = i;
Aux = true;
}
}
ptr = Listas.enlace [ptr];
}
If (anterior == -999)
{
Listas.enlace [nuevo] = Listas.comienzo;
Listas.comienzo = nuevo;
}
Else
{
Listas.enlace [nuevo] = Listas.enlace [anterior];
Listas.enlace [anterior] = nuevo;
}
button1.Text = "Cerrar";
}
}

Private void button1_Click (object sender, EventArgs e)
{
this.Hide ();
}
}
}
Corrida

ELIMINACION DE UN ELEMENTO DE UNA LISTA ENLAZADA
Sea lista una lista enlazada en la cual el nodo N se encuentra entre los nodos A y B. Supongamos que queremos eliminar el nodo N de la lista. La eliminación se produce tan pronto como el puntero de enlace siguiente del nodo A apunte al nodo B. (por ello cuando realizamos eliminaciones debemos almacenar de alguna forma la dirección del nodo que precede al que vamos a borrar.)
Supongamos que la lista enlazada se mantiene en memoria en la forma siguiente:
LISTA (INFO, ENLACE, COMIENZO, DISP)
Cuando eliminamos el nodo N de la lista debemos devolverlo inmediatamente a la lista de espacio disponible. Por facilidad en el proceso esta devolución se realiza insertando el nodo devuelto al principio de la lista DISP. Obsérvese que esta operación implica cambiar tres punteros de la forma siguiente:
el puntero siguiente del nodo A debe cambiarse para apuntar al nodo B, al que apuntaba previamente N.
el puntero del nodo N se cambia y se le hace apuntar al primer nodo de la lista de nodos disponibles.
El puntero DISP se cambia y pasa de apuntar al antiguo primer nodo de la lista de disponibles para apuntar a N que será el nuevo primer nodo.
Existen dos casos especiales que implican actuaciones distintas. Si el nodo N que eliminamos es el primero de la lista, el puntero COMIENZO deberá cambiarse para apuntar al nodo B. En cambio, si N es el último de la lista, entonces el puntero A deberá ponerse a NULO.
Algoritmos de eliminación
Los algoritmos que eliminan nodos de una lista son utilizados en distintas situaciones. En este epígrafe discutiremos dos de ellas. La primera situación es la que implica borrar el nodo siguiente a uno dado. La segunda situación implica borrar un nodo que contiene un determinado elemento. En todos los algoritmos suponemos que la lista enlazada se almacena en memoria de la forma
LISTA (INFO, ENLACE, COMIENZO, DISP).
También en todos ellos devolvemos el nodo eliminado a la lista de nodos disponibles, insertándolos al principio de esta. Por ello nuestros algoritmos incluirán las siguientes asignaciones, donde LUG es la posición del nodo N borrado: ENLACE [LUG]: = DISP y DISP: = LUG.
Algunos de nuestros algoritmos pueden borrar o bien el primer elemento de la lista o bien el ultimo. Cualquier algoritmo que haga esto debe analizar primero si existe algún elemento en la lista. Si no existe ningún, si COMIENZO = NULO, el algoritmo imprimirá el mensaje UNDERFLOW.
Eliminacion del nodo sucesor de uno determinado
Sea LISTA una lista enlazada almacenada en memoria. Supongamos que queremos eliminar de LISTA el nodo N que ocupa el lugar LUG y que conocemos el lugar LUGP del nodo que precede a N en la lista o bien si el nodo N es el primer LUG = NULO. El algoritmo siguiente elimina N de la lista.
Algoritmo: BOR (INFO, ENLACE, COMIENZO, DISP, LUG, LUGP)

El algoritmo elimina de la lista el nodo N que ocupa la posición LUG, siendo LUGP la posición del nodo que precede a N o bien LUGP = 0 si N es el primero de la lista.
si LUGP = NULO. Entonces:
COMIENZO: = ENLACE [COMIENZO]. [Elimina el primer nodo].
Si no:
ENLACE [LUGP]: = ENLACE [LUG]. [Elimina el nodo N].
[Devolvemos el nodo a la lista DISP].
ENLACE [LUG]: = DISP Y DISP: = LUG.
Salir.

Eliminacion de un nodo que contiene un determinado elemento de información
Sea LISTA una lista enlazada almacenada en memoria. Supongamos que queremos eliminar de la lista el primer nodo N que contenga la información ELEMENTO. (Si ELEMENTO es un valor de clave, solo puede contenerlo un único nodo.) Recuérdese que antes de borrar el nodo N que contiene a ELEMENTO debemos conocer que nodo precede a N en la lista. Por ello veremos previamente un procedimiento que localiza la posicion LUG del nodo N que contiene a ELEMENTO y la posicion LUGP del nodo que precede a N. En el caso de que N sea el primer nodo de la lista, el procedimiento devuelve LUGP = NULO y en caso de que ELEMENTO no se encuentre en la lista devolverá LUG = NULO. (Como puede verse el procedimiento es similar al procedimiento)
Procedimiento: ENCB (INFO, ENLACE, COMIENZO, ELEMENTO, LUG, LUGP)

El procedimiento encuentra la posicion LUG del primer nodo N que contiene a ELEMENTO y la posicion LUGP del nodo anterior a N. Si ELEMENTO no se encuentra en la lista, el procedimiento devuelve LUG = NULO y si ELEMENTO se encuentra en el primer nodo, entonces hace LUGP = NULO.
[¿Lista vacia?] Si COMIENZO: = NULO, entonces:
LUG: = NULO Y LUGP: = NULO y Retornar.
[¿Se encuentra ELEMENTO en el primer nodo?]
Si INFO[COMIENZO] = ELEMENTO, entonces
LUG: = COMIENZO y LUGP = NULO y Retornar.
AUX: = COMIENZO y PTR: = ENLACE [COMIENZO]. [Inicializamos los punteros].
Repetir mientras PTR!= NULO.
Si INFO[PTR] = ELEMENTO, entonces:
LUG: = PTR y LUGP: = AUX y Retornar.
AUX: = PTR y PTR: = ENLACE [PTR]. [Actualizamos los punteros]:
[Final del ciclo].
LUG: = NULO [Busqueda fallida].
Retornar.

El procedimiento recorre la lista utilizando dos punteros PTR y AUX. Con PTR recorremos la lista y comparamos sucesivamente ELEMENTO con INFO [PTR]. En cada momento AUX apunta al nodo anterior al apuntado por PTR. Por ello después de cada fallida actualizamos ambas de la siguiente forma:
AUX: = PTR y PTR: = ENLACE [PTR]
El recorrido de la lista continua mientras que INFO [PTR]!= ELEMENTO o, en otras palabras, la busqueda terminara cuando INFO [PTR]=ELEMENTO. En este momento PTR = LUG o dirección del nodo N buscado y AUX apuntara al nodo anterior.
La formalización de este procedimiento se establece a continuacion. En ella se puede observar que se tratan por separado los casos en que la lista esta vacia y el caso en que N es el primer nodo. Esto se hace así debido a que ambos casos no precisan la utilización de la variable AUX.
Después de desarrollar este procedimiento estamos en condiciones de diseñar un algoritmo muy sencillo que elimina de una lista enlazada aquel nodo N en el que aparece por primera vez la información ELEMENTO. La simplicidad de este algoritmo estriba en que la localización de N y de su predecesor pueda realizarse utilizando el procedimiento anterior.
Algoritmo: ELIMINAR (INFO, ENLACE, COMIENZO, DISP, ELEMENTO)

El algoritmo elimina de la lista enlazada el primer nodo N que contiene la información ELEMENTO.
[Utilizamos el procedimiento anterior para encontrar la posicion de N y su predecesor en la lista.]
Llamar ENCB (INFO, ENLACE, COMIENZO, ELEMENTO, LUG, LUGP).
Si LUG: = NULO, entonces: Escribir: ELEMENTO no se encuentra en la lista y salir.
[Eliminamos el nodo].
Si LUGP = NULO, entonces:
COMIENZO: = ENLACE [COMIENZO]. [Eliminamos el primer nodo].
Si no:
ENLACE [LUGP]: = ENLACE [LUG].
[Devolvemos el nodo eliminado a la lista de nodos disponibles].
ENLACE [LUG]: = DISP y DISP: = LUG.
Salir.

Codigo:

Using System;
Using System.Collections.Generic;
Using System.ComponentModel;
Using System.Data;
Using System.Drawing;
Using System.Text;
Using System.Windows.Forms;

Namespace WindowsApplication1
{
Public partial class Eliminacion: Form
{
Public Eliminacion ()
{
InitializeComponent ();
}

Private void cmdEliminar_Click (object sender, EventArgs e)
{
String elemento = txtdato.Text;
Int aux, lug = -999, lugp = 0, ptr;
txtdato.Clear ();
If (Listas.comienzo == -999)
{
Lug = -999;
Lugp = -999;
MessageBox.Show ("La lista esta vacia", "Error");
Return;
}
If (Listas.alumno [Listas.comienzo] == elemento)
{
Lug = Listas.comienzo;
Lugp = -999;
Listas.comienzo = Listas.enlace [Listas.comienzo];
}
Else
{
Aux = Listas.comienzo;
Ptr = Listas.enlace [Listas.comienzo];
While (ptr!= -999)
{
If (Listas.alumno [ptr] == elemento) {lug = ptr; lugp = aux; }
Aux = ptr; ptr = Listas.enlace [ptr];
}
}
If (lug == -999) {MessageBox.Show ("Elemento no encontrado", "Error", MessageBoxButtons.OK); return;}
If (lugp == -999) {Listas.comienzo = Listas.enlace [Listas.comienzo]; }
Else {Listas.enlace [lugp] = Listas.enlace [lug];}
Listas.enlace [lug] = Listas.disponible; Listas.disponible = lug;
MessageBox.Show ("Elemento borrado", "Proceso Completado");
button1.Text = "Cerrar";
}

Private void button1_Click (object sender, EventArgs e)
{
this.Close ();
}
}
}
Corrida

CONCLUSIÓN
El tener claros los conceptos y la información a trabajar, además de generar un análisis exhaustivo de las necesidades que debe cumplir el programa y por qué medio se van a cumplir, son características fundamentales previo a la creación de código, si no se tiene claro que se va a diseñar, no se puede tener claro cómo se va a realizar.

El tener un lenguaje correcto para aplicar a los programas es parte integral de estos, las desventajas de desconocer un lenguaje o no conocer lo que lo distingue de otros lenguajes es un desfavorecimiento para el programador. Por eso se usa C# lenguaje de programación, debido a que permite tener una compilación mucho más rápida y un uso para el usuario nada tedioso. Aunque no se genera un entorno gráfico muy cómodo para el usuario, este solo se encarga de ingresar la información para obtener el informe que necesita por lo cual en realidad no es un punto en contra el del lenguaje.

El uso de las mutualistas favorecen las labores de programación, con estas se agiliza profundamente el tener que hacer validaciones para el ingreso de datos y demás líneas de código que solo generan acumulación, además de hacer que el programa sea compilado mucho más lento.

BIBLIOGRAFÍA
Pila: http://www.programacionfacil.com/estructura_datos_csharp/pilas.html
http://pro-gramadores.blogspot.mx/2012/10/stack-pila-en-c.html

Colas: http://www.programacionfacil.com/estructura_datos_csharp/colas.html
http://pro-gramadores.blogspot.mx/2012/10/queue-cola-en-c.html

Listas enlazadas: http://www.programacionfacil.com/estructura_datos_csharp/listas_enlazadas.html

ESTRUCTURA DE DATOS, pilas, colas, listas enlazadas

Recommend Documents