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

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

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 autoreferenciado 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

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-inform
atica.html
3. http://www.slideshare.net/dma1991/colas-informaticas
4. http://www.madsgroup.org/docencia/alg/pilas_colas_listas.pdf