Professional Documents
Culture Documents
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
<------ 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.
Operaciones Bsicas
esta.
Desencolar (sacar, salir, eliminar): se elimina 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.
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.
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).
Lista de adyacencias: se asocia a cada nodo del grafo una lista que contenga todos aquellos