Embed Size (px)
Citation preview
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
1
Í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
2
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.
3
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
4
Procedimiento: Inserción de un elemento en Pila
Algoritmo
Inserción (Pila, Cima, Elemento)
1. [¿Pila llena?]
Si Cima = MaxPila, entonces:
- Escribir: Desbordamiento (Overflow) y Volver
Cima = Cima + 1;
Pila [Cima] = Elemento
Código
Void CmdInsercionClick(object sender, EventArgs e)
{
String elemento = txtElemento.Text;
txtElemento.Text = "";
txtElemento.Focus();
if (frmPrincipal.Cima == frmPrincipal.MaxPila)
5
{
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
Algoritmo
RECORRIDO (Pila, Top)
1. Apuntador = Top
2. repetir paso 3 mientras Apuntador != nulo
3. imprimir Pila(Apunatdor)
4. Apuntador = Apuntador - 1.
Fin del ciclo.
6
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
7
Procedimiento: Búsqueda de un elemento en Pila
Algoritmo
BUSQUEDA (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 = "";
8
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);
9
MessageBox.Show("Elemento no encontrado en Pila");
}
Corrida
Procedimiento: Eliminación de elemento en Pila
Algoritmo
Eliminar (Pila, Cima, Elemento)
1. [¿Pila Vacía?]
Si Cima = -1, entonces:
Escribe: Subdesbordamiento (Underflow)
2. Elemento = Pila [Cima]
3. Cima = Cima - 1
código
Void CmdEliminarClick(object sender, EventArgs e)
10
{
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
{
11
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();
}
}
}
12
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());
13
}
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();
}
14
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]
15
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] = Elemento
CODIGO
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;
}
16
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:
17
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)
{
18
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
{
int i = frmPrincipal.Frente;
do
{
lsElemCola.Items.Add(frmPrincipal.Cola[i]);
i = i + 1;
} while (i <= frmPrincipal.Final);
}
19
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
20
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)
{
21
lsBusqueda.Items.Add(frmPrincipal.Cola[frmPrincipal.Frente]);
return;
}
}
else if (frmPrincipal.Final < frmPrincipal.Frente)
{
int i = 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);
22
}
else
{
int i = 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.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
23
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. Volver
Có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;
}
24
else
{
frmPrincipal.Frente = frmPrincipal.Frente + 1;
}
lsEliminado.Items.Add(elemento);
}
Ejemplo 2.
using System;
using System.Collections.Generic;
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");
25
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("");
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("");
Console.WriteLine("");
}
Console.WriteLine("Elementos totales que se encuentran en la cola:
" + cola.Count);
Console.ReadKey();
}
}
}
26
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:
27
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.
28
ENLACE [4] = -999 valor nulo, luego termina la lista.
FORMA PRINCIPAL DE LA LISTA ENLAZADA
Código
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 Listas : Form
{
public Listas()
{
InitializeComponent();
}
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();
}
29
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
30
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.
1. PTR: = COMIENZO. [inicializa el puntero].
2. repetir pasos 3 y 4 mientras PTR!= 0.
3. aplicar PROCESO a INFO [PTR].
4. PTR: = ENLACE [PTR]. [PTR apunta ahora al siguiente nodo]. [fin del ciclo
paso 2].
31
5. 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 Recorrer : Form
{
public Recorrer()
{
InitializeComponent();
Recorrido();
}
private void cmdRecorrer_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
Recorrido();
}
private void Recorrido()
{
int ptr = Listas.comienzo;
32
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.
33
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.
1. PTR: = COMIENZO.
2. repetir paso 3 mientras PTR != NULO:
3. si ELEMENTO = INFO[PTR], entonces: LUG: = PTR y salir.
4. si no: PTR: = ENLACE [PTR]. [PTR apunta ahora al nodo siguiente].
5. [final de la estructura condicional].
6. [final del ciclo del paso 2].
7. [la búsqueda es fallida]. LUG: = NULO.
8. salir
Lista ordenada
34
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.
1. PTR:= COMIENZO.
2. repetir paso 3 mientras PTR != NULO:
3. si ELEMENTO < INFO[PTR], entonces:
4. PTR: = ENLACE [PTR]. [PTR apunta al siguiente nodo].
5. si no, si ELEMENTO = INFO[PTR], entonces:
6. LUG = PTR y salir. [la busqueda es satisfactoria].
7. si no: LUG: = NULO y salir. [ELEMENTO es mayor que INFO[PTR.
8. [final de la estructura condicional]
9. [final del ciclo del paso 2]
10.LUG: = NULO.
11.salir.
Codigo:
using System;
using System.Collections.Generic;
using System.ComponentModel;
35
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication1
{
public partial class Busqueda : Form
{
public Busqueda()
{
InitializeComponent();
}
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];
}
36
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
37
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.
1. [Overflow] si DISP = NULO, entonces: Escribir: OVERFLOW y salir.
2. [extrae el primer nodo de la lista DISP].
3. NUEVO: = DISP y DISP: = ENLACE [DISP].
4. INFO[NUEVO]: = ELEMENTO. [copia el dato en el nodo].
38
5. ENLACE [NUEVO]: = COMIENZO. [el nuevo nodo apunta ahora al que
ocupa antes la primera posición].
6. COMIENZO: = NUEVO. [COMIENZO apunta ahora al elemento que ocupa
la primera posición de la lista].
7. 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
1. [Overflow] Si DISP = NULO, entonces: escribir: OVERFLOW y salir.
39
2. [Extrae el primer nodo de la lista de disponibles]
3. NUEVO: = DISP y DISP: = ENLACE [DISP].
4. INFO [NUEVO]: = ELEMENTO. [copia el dato en el nodo obtenido].
5. Si LUG = NULO, entonces [Lo inserta como primer nodo].
6. ENLACE [NUEVO]: = COMIENZO y COMIENZO: = NUEVO.
7. Si no: [Inserta de tras del nodo de posicion LUG].
8. ENLACE [NUEVO]: = ENLACE [LUG] y ENLACE [LUG]: = NUEVO.
9. [Final de la estructura condicional]
10.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) <ELEMENTO⇐INFO (b). Por
tanto ELEMENTO debe insertarse en un nuevo nodo entre A y B. El procedimiento
siguiente calcula la posicion LUG que ocupa el nodo A, es decir, la posicion del
nodo que precederá a ELEMENTO en la lista.
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.
40
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.
1. [¿Lista vacia?] Si COMIENZO = NULO, entonces: LUG = NULO y retornar.
2. [¿caso especial?] Si ELEMENTO < INFO [COMIENZO]. entonces: LUG: =
NULO y retornar.
3. AUX: = COMIENZO y PTR: = ENLACE [COMIENZO]. [Inicializamos los
punteros].
4. Repetir pasos 5 y 6 mientras PTR!= NULO.
5. Si ELEMENTO < INFO [PTR]. entonces:
6. LUG: = AUX y retornar.
7. [Final de la estructura condicional].
8. AUX: = PTR y PTR: = ENLACE [PTR]. [Actualiza los punteros].
9. LUG: = AUX.
10.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.
1. [Utilizamos el procedimiento 6 para encontrar la posicion del nodo que
precederá a ELEMENTO.]
2. Llamar ENCA (INFO, ENLACE, COMIENZO, ELEMENTO, LUG)
41
3. [Utilizaremos el algoritmo 5 para insertar ELEMENTO a continuacion del
nodo que ocupa la posicion LUG.]
4. Llamar INSLUG(INFO, ENLACE, COMIENZO, DISP, LUG, ELEMENTO)
5. 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();
42
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;
43
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
44
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
45
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)
46
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.
1. si LUGP = NULO. Entonces:
2. COMIENZO: = ENLACE [COMIENZO]. [Elimina el primer nodo].
3. Si no:
4. ENLACE [LUGP]: = ENLACE [LUG]. [Elimina el nodo N].
5. [Final de la estructura condicional].
6. [Devolvemos el nodo a la lista DISP].
7. ENLACE [LUG]: = DISP Y DISP: = LUG.
8. 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)
47
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.
1. [¿Lista vacia?] Si COMIENZO: = NULO, entonces:
2. LUG: = NULO Y LUGP: = NULO y Retornar.
3. [Final de la estructura condicional].
4. [¿Se encuentra ELEMENTO en el primer nodo?]
5. Si INFO[COMIENZO] = ELEMENTO, entonces
6. LUG: = COMIENZO y LUGP = NULO y Retornar.
7. [Final de la estructura condicional].
8. AUX: = COMIENZO y PTR: = ENLACE [COMIENZO]. [Inicializamos los
punteros].
9. Repetir mientras PTR!= NULO.
10.Si INFO[PTR] = ELEMENTO, entonces:
11.LUG: = PTR y LUGP: = AUX y Retornar.
12. [Final de la estructura condicional].
13.AUX: = PTR y PTR: = ENLACE [PTR]. [Actualizamos los punteros]:
14. [Final del ciclo].
15.LUG: = NULO [Busqueda fallida].
16.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]
48
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.
1. [Utilizamos el procedimiento anterior para encontrar la posicion de N y su
predecesor en la lista.]
2. Llamar ENCB (INFO, ENLACE, COMIENZO, ELEMENTO, LUG, LUGP).
3. Si LUG: = NULO, entonces: Escribir: ELEMENTO no se encuentra en la
lista y salir.
4. [Eliminamos el nodo].
5. Si LUGP = NULO, entonces:
6. COMIENZO: = ENLACE [COMIENZO]. [Eliminamos el primer nodo].
7. Si no:
8. ENLACE [LUGP]: = ENLACE [LUG].
49
9. [Final de la estructura condicional].
10. [Devolvemos el nodo eliminado a la lista de nodos disponibles].
11.ENLACE [LUG]: = DISP y DISP: = LUG.
12.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 ();
50
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";
}
51
Private void button1_Click (object sender, EventArgs e)
{
this.Close ();
}
}
}
Corrida
52
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.
53
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
