You are on page 1of 11

PILAS, COLAS, LISTAS, ARBOLES, GRAFOS...

PILAS:
Las pilas son otro tipo de estructura de datos lineales, las cuales
presentan restricciones en cuanto a la posicin en la cual pueden
realizarse las inserciones y las extracciones de elementos.
Una pila es una lista de elementos en la que se pueden insertar y
eliminar elementos slo por uno de los extremos. Como consecuencia,
los elementos de una pila sern eliminados en orden inverso al que se
insertaron. Es decir, el ltimo elemento que se meti a la pila ser el
primero en salir de ella.
En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos
en una alacena, una pila de latas en un supermercado, una pila de
papeles sobre un escritorio, etc.
Una pila es un tipo especial de lista abierta en la que slo se pueden
insertar y eliminar nodos en uno de los extremos de la lista. Estas
operaciones se conocen como "push" y "pop", respectivamente
"empujar" y "tirar". Adems, las escrituras de datos siempre son
inserciones de nodos, y las lecturas siempre eliminan el nodo ledo.
Estas caractersticas implican un comportamiento de lista LIFO (Last In
First Out), el ltimo en entrar es el primero en salir.
El smil del que deriva el nombre de la estructura es una pila de platos.
Slo es posible aadir platos en la parte superior de la pila, y slo
pueden tomarse del mismo extremo.
REPRESENTACIONES

Representacin Grfica ( Graphic Representation )


top
.
.
DATA
LINK
.
+-------------+
...........>|
|
* |
+----------|--+
V
+-------------+
|
|
* |
+----------|--+
V
+-------------+
|
|
* |
el tope de la pila
+----------|--+
V
.
.
.
.
|
V
+-------------+
|
|
0 |
+-------------+

<------ add
------> delete

+---+
P |
| Variable con
+---+

Observar que las operaciones de agregar o eliminar un elemento a la pila, siempre se hacen sobre el nodo que est al tope y es
referenciado por la variable que representa la pila.

EJEMPLOS:
C:

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
nodo
38.
39.
40.
41.
42.

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
struct agenda
{
char nombre[50];
char telefono[25];
char mail[50];
};
struct nodo
{
struct agenda dato;
struct nodo *proximo;
};
struct nodo *nuevonodo();
int colavacia(struct nodo *);
struct nodo *creacola(struct nodo *, struct agenda);
void mostrar(struct nodo *);
void main()
{
struct nodo *pri=NULL, *ult=NULL;
struct agenda x;
printf("Ingrese nombre: ");
gets(x.nombre);
while(strcmpi(x.nombre,"fin"))
{
printf("Ingrese telefono: ");
gets(x.telefono);
printf("Ingrese mail: ");
gets(x.mail);
ult=creacola(ult,x);
if(pri==NULL) pri=ult; // Si es la 1 pasada pongo en pri el valor del primer
printf("Ingrese nombre: ");
gets(x.nombre);
}
if(colavacia(pri)==1) { printf("No se ingresaron registros"); getch(); }
else mostrar(pri);

43.
}
44.
45.
struct nodo *nuevonodo()
46.
{
47.
struct nodo *p;
48.
p=(struct nodo *)malloc(sizeof(struct nodo));
49.
if(p==NULL)
50.
{
51.
printf("Memoria RAM Llena");
52.
getch();
53.
exit(0);
54.
}
55.
return p;
56.
}
57.
58.
struct nodo *creacola(struct nodo *ult, struct agenda x)
59.
{
60.
struct nodo *p;
61.
p=nuevonodo();
62.
(*p).dato=x;
63.
(*p).proximo=NULL;
64.
if(ult!=NULL) (*ult).proximo=p; // Si hay nodo anterior en prox pongo la
direccion del nodo actual
65.
return p;
66.
}
67.
68.
int colavacia(struct nodo *pri)
69.
{
70.
if(pri==NULL) return 1;
71.
else return 0;
72.
}
73.
74.
void mostrar(struct nodo *pri)
75.
{
76.
struct nodo *aux;
77.
while(pri!=NULL)
78.
{
79.
printf("Nombre: %s - Telefono: %s - Mail: %s \n",pri->dato.nombre,pri>dato.telefono,pri->dato.mail);
80.
aux=pri;
81.
pri=(*pri).proximo;
82.
free(aux);
83.
}
84.
getch();
85.

Colas:
Una cola es una coleccin de elementos homogneos (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
posicin sino solo por el final, as el elemento insertado queda como
ltimo.
Por esta razn la cola es denominada una estructura F.I.F.O., o
simplemente una lista F.I.F.O., esto representa el acrnimo de las
palabras inglesas first in, first out (primero en entrar, primero en salir).
Grficamente podemos representarla como: La cola fue recin creada y
esta vaca. (Frente y final apuntan FINAL FRENTE a nil).
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.

Usos concretos de la cola


La particularidad de una estructura de datos de cola es el hecho de que slo podemos acceder
al primer y al ltimo elemento de la estructura. As mismo, los elementos slo se pueden
eliminar por el principio y slo se pueden aadir por el final de la cola.

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.

EJEMPLO:
C:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
struct agenda
{
char nombre[50];
char telefono[25];
char mail[50];
};
struct nodo
{
struct agenda dato;
struct nodo *proximo;
};
struct nodo *nuevonodo();
int colavacia(struct nodo *);
struct nodo *creacola(struct nodo *, struct agenda);
void mostrar(struct nodo *);
void main()
{
struct nodo *pri=NULL, *ult=NULL;
struct agenda x;
printf("Ingrese nombre: ");
gets(x.nombre);
while(strcmpi(x.nombre,"fin"))
{
printf("Ingrese telefono: ");
gets(x.telefono);
printf("Ingrese mail: ");
gets(x.mail);
ult=creacola(ult,x);
if(pri==NULL) pri=ult; // Si es la 1 pasada pongo en pri el valor del primer nodo
printf("Ingrese nombre: ");
gets(x.nombre);
}
if(colavacia(pri)==1) { printf("No se ingresaron registros"); getch(); }
else mostrar(pri);
}
struct nodo *nuevonodo()
{
struct nodo *p;
p=(struct nodo *)malloc(sizeof(struct nodo));
if(p==NULL)
{
printf("Memoria RAM Llena");
getch();
exit(0);
}
return p;
}
struct nodo *creacola(struct nodo *ult, struct agenda x)

{
struct nodo *p;
p=nuevonodo();
(*p).dato=x;
(*p).proximo=NULL;
if(ult!=NULL) (*ult).proximo=p; // Si hay nodo anterior en prox pongo la direccion del nodo
actual
return p;
}
int colavacia(struct nodo *pri)
{
if(pri==NULL) return 1;
else return 0;
}
void mostrar(struct nodo *pri)
{
struct nodo *aux;
while(pri!=NULL)
{
printf("Nombre: %s - Telefono: %s - Mail: %s \n",pri->dato.nombre,pri->dato.telefono,pri>dato.mail);
aux=pri;
pri=(*pri).proximo;
free(aux);
}
getch();
}

LISTA
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, enlaces o punteros (punteros) al
nodo anterior o posterior. El principal beneficio de las listas enlazadas
respecto a losvectores 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.
Una lista enlazada es un tipo de dato autoreferenciado porque contienen
un puntero o enlace (en ingls link, del mismo significado) 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.

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.
Una lista es una estructura de datos secuencial.
Lista densa: la propia estructura determina cul es el siguiente elemento
de la lista. Ejemplo: un array.
Lista enlazada: la posicin del siguiente elemento de la estructura la
determina el elemento actual.
Una lista es una secuencia de elementos llamados nodos. Cada nodo
esta formado por un campo de datos y 1 o ms campos de enlace que
apunta(n) al siguiente nodo. Todo nodo tiene un predecesor y antecesor
excepto el primero y el ltimo.
La lectura de una lista se realiza secuencialmente pero su posicin fsica
en memoria solo depende del mtodo para implementarla. Si por
ejemplo usamos punteros que es la tcnica ms adecuada podemos
almacenar los componentes de la lista en posiciones dispersas de
memoria, aunque ante el usuario continuara apareciendo como una
estructura secuencial.
Se llaman operaciones simples las que afectan a un solo dato y
complejas las que afectan a varios. Las operaciones complejas pueden
realizarse repitiendo las simples.
Es necesario almacenar al menos la posicin de memoria del primer
elemento.
Adems es dinmica, es decir, su tamao cambia durante la ejecucin
del programa. Una lista enlazada se puede definir recursivamente de la
siguiente manera:
a) una lista enlazada es una estructura vaca o
b) un elemento de informacin y un enlace hacia una lista (un nodo).
c) Grficamente se suele representar as:
Una lista puede cambiar de tamao, pero su ventaja fundamental es que
son flexibles a la hora de reorganizar sus elementos; a cambio se ha de
pagar una mayor lentitud a la hora de acceder a cualquier elemento.
Implementacin con variables Referencias
Se debe definir una clase que implemente la lista.

Ejemplo: en cdigo
public class nodo {
private Object elemento;
private nodo siguiente;
public nodo() {
this(null,null);
}
public nodo(Object e, nodo n){
elemento=e;
siguiente=n;
}
Object getElemento(){
return elemento;
} nodo getSiguiente(){
return siguiente;
}
void setElemento(Object nuevoelemento){
elemento=nuevoelemento;
}
void setSiguiente(nodo nuevosiguiente){
siguiente=nuevosiguiente;
}
}
Un programa que acceda a la lista.
public class agrega {
public static void main(String [] args){
nodo p,q;
p = new nodo("uno",null);
q = new nodo();
q.setElemento("dos");
q.setSiguiente(p);
p = q;
q = new nodo();
q.setElemento("tres");
q.setSiguiente(p);
p = q;
while (q!=null){
System.out.println(q.getElemento());
System.out.println(q.toString());
q=q.getSiguiente();
} } }

ARBOLES:
los arboles representan las estructuras no lineales y dinmicas de datos
mas importantes en computacin las estructuras de datos se dividen en
estticas y dinmicas:
ESTATICAS
-Arreglos
-Registros
-Conjuntos
DINAMICAS
-Listas
-Arboles
Un rbol es una estructura jerrquica aplicada a una construccin de
elementos llamados nodos y uno de los cuales es conocido como raz,
adems se crea una relacin o parentesco entre nodos, dando lugar a
trminos como padre, hijos, hermanos, antecesor, sucesor, ancestro,
etc...
Existen 4 formas de representar un rbol
-Grafo
-Diagrama de venn
-Anidacion de parntesis
-Notacin identada

Arboles y Caractersticas
Los rboles son estructuras de datos no lineales.
Cada elemento conocido con el nombre de NODO
Un rbol se define como una coleccin de nodos donde cada uno adems de
almacenar informacin, guarda las direcciones de sus sucesores.
Se conoce la direccin de uno de los nodos, llamado raz y a partir de el se tiene
acceso a todos los otros miembros de la estructura.
Grafos, anidacin de parntesis y diagramas de venn.
Hijo: Es aquel nodo que siempre va a tener un nodo antecesor o padre, son aquellos
que se encuentran en el mismo nivel
Padre: Es aquel que tiene hijos y tambin puede tener o no antecesores.
Hermano: Dos nodos son hermanos si son apuntados por el mismo nodo, es decir si
tienen el mismo padre.

Raz: Es el nodo principal de un rbol y no tiene antecesores.


Hoja o terminal: Son aquellos nodos que no tienen hijos o tambin los nodos finales
de un rbol.
Interior: Se dice que un nodo es interior si no es raz ni hoja.
Nivel de un nodo: Se dice que el nivel de un nodo es el numero de arcos que deben
ser recorridos, partiendo de la raz para llegar hasta el.
Altura del rbol: Se dice que la altura de un rbol es el mximo de los niveles
considerando todos sus nodos.
Grado de un nodo: se dice que el grado de un nodo es el nmero de hijos que tiene
dicho nodo.

GRAFOS:
Un grafo en el mbito de las ciencias de la computacin es
una estructura de datos, en concreto un tipo abstracto de datos (TAD),
que consiste en un conjunto de nodos (tambin llamados vrtices) y un
conjunto de arcos (aristas) que establecen relaciones entre los nodos. El
concepto de grafo TAD desciende directamente del concepto matemtico
de grafo.
Informalmente se define como G = (V, E), siendo los elementos de V los
vrtices, y los elementos de E, las aristas (edges en ingls).
Formalmente, un grafo, G, se define como un par ordenado, G = (V, E),
donde V es un conjunto finito y E es un conjunto que consta de dos
elementos de V.
FORMAS DE REPRESENTACIN
Existen diferentes implementaciones del tipo grafo: con una matriz de
adyacencias (forma acotada) y con listas y multilistas de adyacencia (no
acotadas).

Matriz de adyacencias: se asocia cada fila y cada columna a cada nodo


del grafo, siendo los elementos de la matriz la relacin entre los mismos,
tomando los valores de 1 si existe la arista y 0 en caso contrario.

Lista de adyacencias: se asocia a cada nodo del grafo una lista que contenga todos aquellos

nodos que sean adyacentes a l.

un grafo es un conjunto de objetos llamados vrtices o nodos unidos por


enlaces llamados aristas o arcos, que permiten representar relaciones
binarias entre elementos de un conjunto.

Tpicamente, un grafo se representa grficamente como un conjunto de


puntos (vrtices o nodos) unidos por lneas (aristas).
Desde un punto de vista prctico, los grafos permiten estudiar las
interrelaciones entre unidades que interactan unas con otras. Por
ejemplo, una red de computadoras puede representarse y estudiarse
mediante un grafo, en el cual los vrtices representan terminales y las
aristas representan conexiones (las cuales, a su vez, pueden
ser cables o conexiones inalmbricas).
Prcticamente cualquier problema puede representarse mediante un
grafo, y su estudio trasciende a las diversas reas de las ciencias
exactas y las ciencias sociales.

You might also like