Pilas:
Una pila es una estructura de datos a la cual se puede acceder solo por un
extremo de la misma. Las operaciones de inserción y extracción se
realizan a través del tope, por lo cual no se puede acceder a cualquier
elemento de la pila. Se la suele llamar estructura L.I.F.O. como
acrónimo de las palabras inglesas "last in, first out" (último en
entrar, primero en salir). La pila se considera un grupo ordenado de
elementos, teniendo en cuenta que el orden de los mismos depende del
tiempo que lleven "dentro" de la estructura.
Las pilas son frecuentemente utilizadas en el
desarrollo de sistemas informáticos y software en general. Por ejemplo,
el sistema de soporte en tiempo de compilación y ejecución del Pascal
utiliza una pila para llevar la cuenta de los parámetros de
procedimientos y funciones, variables locales, globales y dinámicas.
Este tipo de estructuras también son utilizadas para traducir
expresiones aritméticas o cuando se quiere recordar una secuencia de
acciones u objetos en el orden inverso del ocurrido.
Ahora bien, una vez conocido el comportamiento de las pilas veremos como se definen las mismas y su forma de manejo, o "comportamiento" de la pila.
Definición dinámica de una pila:
Las operaciones que definen el comportamiento de una pila o primitivas son las siguientes:
· Crear pila.
· Insertar elemento.
· Retirar elemento.
· Pila vacía.
· Vaciar pila.
La definición junto con la implementación de éste
tipo de estructura, es conveniente realizarlas en una unidad de
biblioteca, de este modo se mantiene el nivel de abstracción de la
estructura.
Unit Pilas
Colas:
Una cola es una colección de elementos
homogéneos (almacenados en dicha estructura), en la misma se pueden
insertar elementos por uno de los extremos, llamado frente, y retirar los mismos por el otro extremo, denominado final.
Es importante aclarar que, tanto el frente como el final de la cola, son los únicos
indicados para retirar e insertar elementos, respectivamente. Esto nos
indica que no podemos acceder directamente a cualquier elemento de la
cola, sino solo al primero, o sea el que está o se encuentra en el
frente, y no se pueden insertar elementos en cualquier posición sino
solo por el final, así el elemento insertado queda como último.
Por esta razón la cola es denominada una estructura F.I.F.O., o simplemente una lista F.I.F.O.,
esto representa el acrónimo de las palabras inglesas “first in, first
out” (primero en entrar, primero en salir). Gráficamente podemos
representarla como:
La cola fue recién creada y esta vacía. (frente y final apuntan FINAL FRENTE a nil).
Si ahora le ingresamos el elemento A, la misma quedará se la siguiente manera:
Como A es el único A elemento, frente y final apuntan a él. FINAL nil FRENTE
Si a continuación se ingresa el elemento B, el frente de la cola continuará apuntando a A, pero ahora el final apuntará al elemento recién ingresado.
B A El enlace se realiza desde el frente hacia el final. FINAL nil FRENTE
Al retirar un elemento, el frente apuntará al
siguiente del elemento retirado y en el caso que la cola quedara vacía,
frente y final apuntarán a nil.
B A elemento retirado. FINAL nil FRENTE
FINAL FRENTE
nil nil
Ahora bien, una vez conocido el comportamiento de las colas veremos como se definen las mismas y su forma de manejo, o "comportamiento" de la cola.
Para trabajar con una cola, así como para cualquier
tipo de estructura abstracta, tendremos que definir las operaciones que
representen el comportamiento de la misma, para de esta manera poder
utilizarlas. Dichas operaciones son:
· Crear cola.
· Insertar elemento.
· Retirar elemento.
· Cola vacía.
· Vaciar cola.
Podemos definir una cola en forma dinámica
implementándola como una lista simple y respetando las restricciones de
inserción (sólo se puede realizar a través del final) y extracción (sólo
se puede realizar por el frente).
A partir de la definición dada, podremos implementar una estructura de tipo cola en una unidad de biblioteca de la siguiente manera.
Unit Colas;
interface
type
tipo_dato = <dato a almacenar>;
ptr_nodo_cola = ^tnodo_cola;
tnodo_cola = record
dato : tipo_dato;
enlace : ptr_nodo_cola;
end;
tipo_cola = record
frente,
final : ptr_nodo_cola;
end;
{encabezamiento de las primitivas que utilizaremos en el tipo de dato COLA}
Procedure Cola_crear (var Cola : tipo_Cola);
{Pre: La cola nunca fue creada.
Post: Se creo la cola y se encuentra vacía}
Procedure Cola_insertar (var Cola : tipo_cola; elem : tipo_dato; var error : boolean);
{Pre: La Cola existe.
Post: Si error = false el elemento fue ingresado en
el final de la Cola, si error = true no se ha ingresado el elemento, la
Cola se encuentra llena}
Procedure Cola_retirar (var Cola : tipo_cola; var elem : tipo_dato);
{Pre:La Cola fue creada y no está vacia.
Post: El elemento del frente de la Cola fue retirado y
se encuentra en elem, la Cola queda igual, sin el elemento que se
encontraba en el frente}
Function Cola_vacia (Cola : tipo_cola);
{Pre: La Cola fue creada.
Post: Devuelve true si la Cola se encuentra vacía, y sino false}
Procedure Cola_vaciar (var Cola : tipo_cola);
{Pre: La Cola fue creada.
Post: La Cola se encuentra vacía}
Implementation
Procedure Cola_crear (var Cola : tipo_Cola);
begin
cola.frente := nil;
cola.final := nil;
end;
Procedure Cola_insertar (var Cola : tipo_cola; elem : tipo_dato; var error : boolean);
var ptr_aux : ptr_nodo_cola;
begin
error:= Maxavail < sizeof(tnodo_cola);
if (not error) then
begin
new (ptr_aux);
ptr_aux^.dato := elem;
ptr_aux^.enlace := nil;
if (Cola_vacía (cola)) then cola.frente := ptr_aux
else cola.final^.enlace := ptr_aux;
cola.final := ptr_aux;
end
end;
Procedure Cola_retirar (var Cola : tipo_cola; var elem : tipo_dato);
var ptr_aux : ptr_nodo_cola;
begin
ptr_aux := cola.frente;
cola.frente := cola.frente^.enlace;
if (cola.frente = nil) then cola.final := nil;
elem := ptr_aux^.dato;
dispose (ptr_aux);
end;
Function Cola_vacia (Cola : tipo_cola);
begin
Cola_vacía := (cola.frente=nil) and (cola.final=nil);
end;
Procedure Cola_vaciar (var Cola : tipo_cola);
var e: tipo_dato;
begin
while not(Cola_vacía(cola)) do
Cola_retirar(cola,e);
end;
<begin>
end.
Existen además del tipo de cola arriba definido,
otros que tienen distintas utilidades según el requerimiento del
programador, por ejemplo, la cola de prioridad.
Cola de prioridad:
Una cola de prioridad es una estructura
característica, donde se pude retirar e insertar un ítem teniendo en
cuenta la clave más grande o más chica (según la implementación)
definida por el programador. Si los ítems tienen claves iguales,
entonces la regla usual utilizada es que el primer ítem insertado es el
que se retirará primero.
Algunas aplicaciones de éste tipo de estructura son:
la representación simulada de eventos dependientes del tiempo, como por
ejemplo el funcionamiento de un aeropuerto, controlando partidas y
aterrizajes de aviones. Otro ejemplo puede verse en los sistemas
informáticos, el CPU asigna prioridades a las distintas tareas que debe
ejecutar y las inserta en su cola, para de esta manera realizarlas en el
orden correcto (multitareas).
Podemos
representar una cola de prioridad como una lista contigua ordenada, en
la cual retirar un ítem es una operación inmediata, pero la inserción
tomaría un tiempo proporcional al número de elementos que se encuentren
en la cola, hay que tener en cuenta que dicha operación se debe realizar
en forma tal que la cola quede ordenada. Otra forma de representación
es a través de una lista desordenada, en la cual el proceso de inserción
es inmediato, pero el de extracción es muy lento, ya que debo recorrer
toda la cola para encontrar el ítem que debo retirar.
ESTRUCTURA DE DATOS
lunes, 16 de abril de 2012
Estructura de datos java (Listas)
Lista enlazada es una de las estructura de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros (punteros) al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los vectores
convencionales es que el orden de los elementos enlazados puede ser
diferente al orden de almacenamiento en la memoria o el disco,
permitiendo que el orden de recorrido de la lista sea diferente al de
almacenamiento.
Aqui un ejemplo de Listas.!!!
/*
* Lista Simplemente enlazada.
*
*/ /**
*
* @author Pain
*/
//Clase Nodo. Utiliza el enlace llamado nodoDer o nodo derecho y el valor a introducir.
public class Nodo {
Nodo nodoDer;
int dato;
public Nodo(int dato) {
this.dato = dato;
this.nodoDer = null;
}
}
/*
* Clase de Lista enlazada y metodos de agregar al final y borrar del mismo, asi como mostrar tamaño y visualizar lista.
*
*/
import javax.swing.JOptionPane;
/**
*
* @author Pain
*/
public class ListaS {
private Nodo primero;
private Nodo ultimo;
private int tamano;
public ListaS() {
this.primero = null;
this.ultimo = null;
this.tamano = 0;
}
//Metodo utilizado para denotar que la lista se encuentra vacia.
public boolean siVacio() {
return (this.primero == null);
}
//Metodo para agregar al final de la lista.
public ListaS addLast(int dato) {
if(siVacio()) {
Nodo nuevo = new Nodo(dato);
primero = nuevo;
ultimo = nuevo;
nuevo.nodoDer = nuevo;
}
else {
Nodo nuevo = new Nodo(dato);
nuevo.nodoDer = null;
ultimo.nodoDer = nuevo;
ultimo = nuevo;
}
this.tamano++;
return this;
}
//Metodo para borrar al final de la lista.
public Nodo deleteLast() {
Nodo eliminar = null;
if(siVacio()) {
JOptionPane.showMessageDialog(null, "La lista se encuentra vacia");
return null;
}
if(primero == ultimo) {
primero = null;
ultimo = null;
}
else {
Nodo actual = primero;
while(actual.nodoDer != ultimo) {
actual = actual.nodoDer;
}
eliminar = actual.nodoDer;
actual.nodoDer = null;
ultimo = actual;
}
this.tamano--;
return eliminar;
}
//Metodo que imprime el tamaño de la lista.
public void tamano() {
JOptionPane.showMessageDialog(null, "El tamaño es:\n " + this.tamano);
}
//Metodo que imprime la lista y los valores ingresados.
public void imprimir() {
if(tamano != 0) {
Nodo temp = primero;
String str = "";
for(int i = 0; i < this.tamano; i++) {
str = str + temp.dato + "\n";
temp = temp.nodoDer;
}
JOptionPane.showMessageDialog(null, str);
}
}
}
* Lista Simplemente enlazada.
*
*/ /**
*
* @author Pain
*/
//Clase Nodo. Utiliza el enlace llamado nodoDer o nodo derecho y el valor a introducir.
public class Nodo {
Nodo nodoDer;
int dato;
public Nodo(int dato) {
this.dato = dato;
this.nodoDer = null;
}
}
/*
* Clase de Lista enlazada y metodos de agregar al final y borrar del mismo, asi como mostrar tamaño y visualizar lista.
*
*/
import javax.swing.JOptionPane;
/**
*
* @author Pain
*/
public class ListaS {
private Nodo primero;
private Nodo ultimo;
private int tamano;
public ListaS() {
this.primero = null;
this.ultimo = null;
this.tamano = 0;
}
//Metodo utilizado para denotar que la lista se encuentra vacia.
public boolean siVacio() {
return (this.primero == null);
}
//Metodo para agregar al final de la lista.
public ListaS addLast(int dato) {
if(siVacio()) {
Nodo nuevo = new Nodo(dato);
primero = nuevo;
ultimo = nuevo;
nuevo.nodoDer = nuevo;
}
else {
Nodo nuevo = new Nodo(dato);
nuevo.nodoDer = null;
ultimo.nodoDer = nuevo;
ultimo = nuevo;
}
this.tamano++;
return this;
}
//Metodo para borrar al final de la lista.
public Nodo deleteLast() {
Nodo eliminar = null;
if(siVacio()) {
JOptionPane.showMessageDialog(null, "La lista se encuentra vacia");
return null;
}
if(primero == ultimo) {
primero = null;
ultimo = null;
}
else {
Nodo actual = primero;
while(actual.nodoDer != ultimo) {
actual = actual.nodoDer;
}
eliminar = actual.nodoDer;
actual.nodoDer = null;
ultimo = actual;
}
this.tamano--;
return eliminar;
}
//Metodo que imprime el tamaño de la lista.
public void tamano() {
JOptionPane.showMessageDialog(null, "El tamaño es:\n " + this.tamano);
}
//Metodo que imprime la lista y los valores ingresados.
public void imprimir() {
if(tamano != 0) {
Nodo temp = primero;
String str = "";
for(int i = 0; i < this.tamano; i++) {
str = str + temp.dato + "\n";
temp = temp.nodoDer;
}
JOptionPane.showMessageDialog(null, str);
}
}
}
Suscribirse a:
Entradas (Atom)