Estructura de Datos

Luis Humeau
11-1155
Waldi Saturno
12-0412
Pilas

Una pila es una mtodo de estructuracin datos
usando la forma LIFO (ltimo en entrar, primero en
salir), que permite almacenar y recuperar datos.
Operaciones de las Pilas
Las operaciones que se pueden realizar con una
pila son:
PUSH (pila, elemento):
Introduce un elemento en la pila. Tambin se
le conoce como poner o meter.

POP (pila):
Elimina un elemento de la pila. Tambin
se le conoce como sacar o quitar.

VACIA(pila):
Funcin booleana que indica si la pila esta
vaca o no.
Ejemplo
Ejemplo 2 Java
import java.util.*;
/**
*
* @author Tecnologia
*/
public class PILA {
public static void main(String[] args) {
Stack<String> pila = new Stack<String>();
for (int x=1;x <= 1000;x++)
pila.push(Integer.toString(x));
while (!pila.empty())
System.out.println(pila.pop());
}
}



COLAS

Una cola es una estructura de
datos, caracterizada por ser
una secuencia de elementos
en la que la operacin de
insercin push se realiza por
un extremo y la operacin de
extraccin pop por el otro.

Tambin se le llama estructura
FIFO (del ingls First In First
Out), debido a que el primer
elemento en entrar ser
tambin el primero en salir.

Ejemplos

Cola de automoviles esperando servicio en
una gasolinera.
Cola de clientes en una ventanilla del banco
para pagar un servicio.
Cola de programas en espera de ser
ejecutados por una computadora.
Tipos de Colas
Cola Simple:
Estructura lineal donde los elementos salen en el mismo orden en
que llegan.

Cola circular :
Representacin lgica de una cola simple en un arreglo.

Cola de Prioridades:
Estructura lineal en la cual los elementos se insertan en cualquier
posicin de la cola y se remueven solamente por el frente.

Cola Doble (Bicola) :
Estructura lineal en la que los elementos se pueden aadir o quitar
por cualquier extremo de la cola (Cola bidireccional).
Operaciones
1.- Insertar A

2.- Insertar B

3-.Insertar C

4-.Remover Elemento

5-. Insertar D

6.- Remover Elemento
Operaciones bsicas en Colas Simples
Insertar.- Almacena al final de la cola el elemento que
se recibe como parmetro.
Eliminar.- Saca de la cola el elemento que se encuentra
al frente.
Vaca.- Regresa un valor booleano indicando si la cola
tiene o no elementos (true si la cola esta vaca, false
si la cola tiene al menos un elemento).
Llena.- Regresa un valor booleano indicando si la cola
tiene espacio disponible para insertar nuevos
elementos ( true si esta llena y false si existen
espacios disponibles).
Colas-Utilizacin


Las colas se utilizan en sistemas informticos,
transportes y operaciones de investigacin
(entre otros), dnde los objetos, personas o
eventos son tomados como datos que se
almacenan y se guardan mediante colas para
su posterior procesamiento. Este tipo de
estructura de datos abstracta se implementa
en lenguajes orientados a objetos mediante
clases, en forma de listas enlazadas.

Una cola es una estructura de datos,
caracterizada por ser una secuencia de
elementos en la que la operacin de insercin
push se realiza por un extremo y la operacin
de extraccin pop por el otro. Tambin se le
llama estructura FIFO (del ingls First In First
Out), debido a que el primer elemento en
entrar ser tambin el primero en salir.
Operaciones Bsicas
Crear:
se crea la cola vaca.
Encolar (aadir, entrar, insertar):
se aade un elemento a la cola. Se aade al final de esta.
Desencolar (sacar, salir, eliminar):
se elimina el elemento frontal de la cola, es decir, el primer elemento
que entr.
Frente (consultar, front):
se devuelve el elemento frontal de la cola, es decir, el primer
elemento que entr.

Colas-JAVA
Lista
En Ciencias de la Computacin, una lista enlazada es una de
las estructuras 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 (punteros) al nodo anterior
o posterior. El principal beneficio de las listas enlazadas
respecto a los array 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.
Lista (estructura de datos)
Una lista enlazada es un tipo de dato auto-
referenciado porque contienen un puntero o link a
otro dato del mismo tipo. Las listas enlazadas
permiten inserciones y eliminacin de nodos en
cualquier punto de la lista en tiempo constante
(suponiendo que dicho punto est previamente
identificado o localizado), pero no permiten un
acceso aleatorio. Existen diferentes tipos de listas
enlazadas: Lista Enlazadas Simples, Listas
Doblemente Enlazadas, Listas Enlazadas Circulares y
Listas Enlazadas Doblemente Circulares.
Lista
Las listas enlazadas pueden ser
implementadas en muchos lenguajes.
Lenguajes tales como Lisp y Scheme tiene
estructuras de datos ya construidas, junto con
operaciones para acceder a las listas
enlazadas. Lenguajes imperativos u orientados
a objetos tales como C o C++ y Java,
respectivamente, disponen de referencias
para crear listas enlazadas.
Operaciones basicas de una lista.
Recorrer los elementos hacia adelante
Recorrer los elementos hacia atras
Insertar un nuevo elemento al principio
Insertar un nuevo elemento al final
Insertar un nuevo elemento antes de otro
Insertar un nuevo elemento despues de otro
Remover un elemento del principio
Remover un elemento que esta antes que otro
Remover un elemento que esta despues de otro
Remover un elemento del principio
Remover un elemento del final
Implementacin de una lista enlazada en
C
#include <stdio.h> /* for printf */
#include <stdlib.h> /* for malloc */

typedef struct ns {
int data;
struct ns *next;
} node;

node *list_add(node **p, int i) {
/* algunos compiladores no requieren un casting del valor del retorno para malloc */
node *n = (node *)malloc(sizeof(node));
if (n == NULL)
return NULL;
n->next = *p;
*p = n;
n->data = i;
Implementacin de una lista enlazada en
C
return n;
}

void list_remove(node **p) { /* borrar cabeza*/
if (*p != NULL) {
node *n = *p;
*p = (*p)->next;
free(n);
}
}

node **list_search(node **n, int i) {
while (*n != NULL) {
if ((*n)->data == i) {
return n;
}
Implementacin de una lista enlazada en
C
n = &(*n)->next;
}
return NULL;
}

void list_print(node *n) {
if (n == NULL) {
printf("lista esta vaca\n");
}
while (n != NULL) {
printf("print %p %p %d\n", n, n->next, n->data);
n = n->next;
}
}

int main(void) {
Implementacin de una lista enlazada en
C
node *n = NULL;

list_add(&n, 0); /* lista: 0 */
list_add(&n, 1); /* lista: 1 0 */
list_add(&n, 2); /* lista: 2 1 0 */
list_add(&n, 3); /* lista: 3 2 1 0 */
list_add(&n, 4); /* lista: 4 3 2 1 0 */
list_print(n);
list_remove(&n); /* borrar primero(4) */
list_remove(&n->next); /* borrar nuevo segundo (2) */
list_remove(list_search(&n, 1)); /* eliminar la celda que contiene el 1 (primera) */
list_remove(&n->next); /* eliminar segundo nodo del final(0)*/
list_remove(&n); /* eliminar ultimo nodo (3) */
list_print(n);

return 0;
}
Fuente

1. http://es.kioskea.net/faq/2885-las-pilas-en-lenguaje-c
2. http://estructura-de-datos-garo.blogspot.com/2011/10/colas-informatica.html
3. http://www.slideshare.net/dma1991/colas-informaticas
4. http://www.madsgroup.org/docencia/alg/pilas_colas_listas.pdf