Estructura De Datos

ESTRUCTURA DE DATOS Y
ALGORITMOS INF- 131
INF – 131

PAOLO JHONATAN RAMOS MENDEZ
ESTUCTURA DE DATOS Y ALGORITMOS


ESTRUCTURA DE DATOS

ESTRUCTURA
DE DATOS

a)

SECUENCIAL
i) !1, !2, !3 … … , !"
b) SELECTIVAS
i) SIMPLE
(1) !" !"#$%!%"# !ℎ!"{… … . . }
ii) DOBLE
(1) !" !"#$%!%"# !ℎ!" … … . .

INF – 131

!"#! {… … … }
1.
2.

3.

4.

5.

6.

7.

1

PSEUDOCODIGO
PILAS
2.1. CONCEPTO
2.2.DIAGRAMA DE CLASES
COLAS
3.1. COLA SIMPLE NORMAL
3.2. COLA CIRCULAR
PILAS Y COLAS MULTIPLES
4.1. CONCEPTO
4.2. DIAGRAMA DE CLASES
LISTAS
5.1. CONCEPTO
5.2. TIPOS
5.3. LISTA SIMPLE NORMAL
5.4. LISTA SIMPLE CIRCULAR
5.5. LISTA DOBLE NORMAL
5.6. LISTA DOBLE CIRCULAR
5.7. LISTA MULTIPLE
RECURSIVIDAD
6.1. CONCEPTO
6.2. TIPOS
ÁRBOLES
7.1. CONCEPTOS
7.2. TIPOS
7.3. ÁRBOL BINARIO NORMAL
7.4. ÁRBOL BINARIOBUSQUEDA

c)

2
2 .1

iii) REPETITIVA
(1) !"#(!"# ! = 1; ! ≤ !; ! + +){−}
(2) !ℎ!"# !"#$%!%"# {… … . . }
(3) !" … … . !ℎ!"# !"#$%!%"#
MULTIPLE
i) !"#$ (!"#"$%&')
{------}

P ILAS
C ONCEPTO

Una pila es una estructura de datos lineal que se
caracteriza porque las inserciones y eliminaciones
se efectúan por un solo efecto al cual denominamos
tope.
2 .2

D IAGRAMA DE CLASES

P SEUDOCODIGO

1)OPERADORES
a) ARITMETICOS
 , ^,/,∗, +, −
b) LOGICOS
!"# , !" , !"#
c) RELACIONALES
<>, >, <, <=, >=
2) ENTRADA Y SALIDA
a) ENTRADA
!"#$ … … .
b) SALIDA
!"#$% … … .
3) ASIGNACIÓN
a) ! ← !
4) ENTRADA DE CONTROL BASICO

public class Pila {
private int tope;
private int MAX;
private int v[];
public Pila() {
tope = 0;
MAX = 100;
v = new int[MAX];
}


Página 1


ESTRUCTURA DE DATOS

publicPila(int m) {
tope = 0;
MAX = m;
v = new int[MAX];
}

public boolean esVacia() {
if (tope == 0)
return true;
return false;
}
public boolean esLlena() {
if (tope == MAX)
return true;
return false;
}
public void adicionar(int e) {
if (esLlena())
System.out.println("Pila
Llena");
else {
tope = tope + 1;
v[tope] = e;
}
}
public int eliminar() {
int e = 0;
if (esVacia())
System.out.println("PilaVacia");
else {
e = v[tope];
tope = tope - 1;
}
return e;
}
public void leer(int n) {
for (int i = 1; i <= n; i++) {
System.out.println("Int
elem");
adicionar(Leer.datoInt());
}
}
public void vaciar(Pila p) {
while (!p.esVacia())
this.adicionar(p.eliminar());
}
public void mostrar() {
int e;


Página 2

Pila aux = new Pila();
while (!esVacia()) {
e = eliminar();
System.out.println(e);aux.adicionar(e);
}
vaciar(aux);
}
public int nroElems() {
return tope;
}
int sumaP(Pila aux) {
if (!esVacia()) {
int e = eliminar();
aux.adicionar(e);
if (e % 2 == 0)
return (e +
sumaP(aux));
else
return (0 +
sumaP(aux));
} else {
vaciar(aux);
return 0;
}
}

}
Ejercicios:
Dada una pila que contiene datos numéricos se pide
eliminar el último par.
Begin( )
{
read(n);
Pila x = new Pila(n);
Pila aux = new Pila(n);
do{
read(p);
} while (p > n);
x.leer(p);
int sw = 0;
while (!x.esVacia() && sw == 0) {
int dato = x.eliminar();
if (dato % 2 == 0)
sw = 1;
else
aux.adicionar(dato);
}
while (!aux.esVacia())
x.adicionar(aux.eliminar());
x.mostrar();
}
Diseñar un programa que dada una pila con datos
numéricos se organice elementos de modo que a un
par le siga un impar.
Begin( ) {
read(n);


ESTRUCTURA DE DATOSPila z = new Pila(n);
Pila p = new Pila(n);
Pila i = new Pila(n);
do {
read(p);
} while (p > n);
z.leer(p);
int sw = 0;
while (!z.esVacia()) {
int dato = z.eliminar();
if (dato % 2 == 0)
p.adicionar(dato);
else
i.adicionar(dato);
}
while (!p.esVacia() && !i.esVacia())
z.adicionar(p.eliminar());
z.adicionar(i.eliminar());
}
while (!p.esVacia()) {
z.adicionar(p.eliminar());
}
while (!i.esVacia()) {z.adicionar(i.eliminar());
}
z.mostrar();

{

}
3

C OLAS

Son estructuras de datos lineales que se caracterizan
porque las inserciones se efectúan por el final (fin)
y los eliminaciones se efectúan por el comienzo
(inicio).
 Operaciones básicas
 Adicionar un elemento a la cola
 Eliminar un elemento a la cola
En caso de encontrarse en una situación similar
como se expone a continuación en el...