ELABORADO POR: LIC. ADRIAN E.

QUISBERT VILELA
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Las estructuras de datos, permiten manipular

los datos de forma adecuada y efectiva, las
mismas permiten diseñar algoritmos eficientes
para el desarrollo de software.

ESTRUCTURA DE DATOS
CON LENGUAJE PYTHON
Un Enfoque Práctico

Elaborado por:

Lic. Adrian E. Vilela Quisbet

ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

ÍNDICE GENERAL

TEMA 1. FUNDAMENTOS DE ESTRUCTURA DE DATOS ___________________1

1.1 Introducción. ____________________________________________________ 6

1.2 Definición de estructura de datos. ____________________________________ 6
1.3 Clasificación de la estructura de datos. ________________________________ 7
1.3.1 Estructuras de datos estáticas. _____________________________________ 8
1.3.2 Estructuras de datos dinámicas. ____________________________________ 8
1.3.3 Estructuras De Datos Lineales. _____________________________________ 8
1.3.4 Estructuras de datos no lineales. ___________________________________ 8
1.4 T.D.A. (Tipo De Dato Abstracto) _____________________________________ 8

TEMA 2. ARCHIVOS__________________________________________________5

2.1 Introducción._____________________________ ¡Error! Marcador no definido.

2.2 Definición de archivo. ______________________ ¡Error! Marcador no definido.
2.3 Organización de archivos. __________________ ¡Error! Marcador no definido.
2.4 Características de los archivos. ______________ ¡Error! Marcador no definido.
2.5 Organización de archivo secuencial___________ ¡Error! Marcador no definido.
2.5.1 Ejemplo de aplicación de archivo secuecial. ___ ¡Error! Marcador no definido.
2.6 Organización de archivo de acceso directo o aleatorio ____ ¡Error! Marcador no
definido.
2.6.1 Instrucciones para el manejo de archivo de acceso directo en java _____ ¡Error!
Marcador no definido.
2.6.2 Ejemplo de aplicación de archivo de acceso directo _____ ¡Error! Marcador no
definido.

TEMA 3. VECTORES Y MATRICES __________________________________ __44

3.1 Vectores _______________________________________________________ 10

3.1.1 Definición de vector. ____________________________________________ 10
3.1.2 Tipo de datos Abstracto (TDA) de un vector __________________________ 11
3.1.3 Ejemplos ____________________________________________________ 12
3.2 Matrices ________________________________ ¡Error! Marcador no definido.
3.2.1 Definición de matrices ____________________ ¡Error! Marcador no definido.
3.2.2 Tipo de datos abstracto de la matriz. ________ ¡Error! Marcador no definido.
3.2.3 Ejemplos _____________________________ ¡Error! Marcador no definido.
3.2.3.1 Generación de Matrices y operaciones con matrices. __ ¡Error! Marcador no
definido.

TEMA 4. PILAS____________________________________________________108

4.1 Definición ______________________________________________________ 29

4.2 Estructura pila __________________________________________________ 29
4.3 Tipo de datos Abstracto(T.D.A.) de una pila. ___________________________ 30
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

4.4 Implementación de la estructura pila en Java Netbeans. __________________ 30

4.5 Ejemplos con pilas simples ________________________________________ 32
4.6 Pila de caracteres _______________________________________________ 49
4.7 Aplicación de pilas para administrar libros _____________________________ 52
4.8 Multipilas o pilas multiples. ________________________________________ 58
4.8.1 Ejemplos de multipilas. __________________________________________ 61

TEMA 5. COLAS___________________________________________________164

5.1 Definición ______________________________________________________ 63

5.2 Estructura cola __________________________________________________ 63
5.3 Tipo de Dato Abstracto (T.D.A.) de una cola. __________________________ 64
5.4 Implementación de las operaciones básicas de una estructura cola. ________ 64
5.5 Implementación de la estructura cola en JAVA. _________________________ 64
5.6 Ejemplos de cola simple __________________________________________ 66
5.7. Colas circulares. ________________________________________________ 69
5.7.1 Definición. ____________________________________________________ 69
5.7.2 Estructura cola circular. __________________________________________ 70
5.7.3 Operaciones básicas de cola circular. _______________________________ 71
5.7.4 Implementación de la cola circular en JAVA NETBEANS. _______________ 71
5.7.5 Ejemplos de colas circulares. _____________________________________ 72
5.7.6 Aplicación de colas circulares. _____________ ¡Error! Marcador no definido.

TEMA 6 RECURSIVIDAD____________________________________________194

6.1 Definición. _____________________________________________________ 79

6.1.1 Funciones recursivas. ___________________________________________ 79
6.1.2 Ejemplos funciones recursivas ____________________________________ 80

TEMA 7. LISTAS ENLAZADAS____________________________________ ___223

7.1. Definición ____________________________________________________ 107

7.1.1 Clasificación de listas enlazadas__________________________________ 108
7.1.1.1 Listas enlazadas simples ______________________________________ 108
7.1.1.1.1 Operaciones básicas sobre listas simples enlazadas _______________ 109
7.1.1.1.2 Implementación de operaciones básicas de las listas_______________ 110
enlazadas. _______________________________________________________ 110
7.1.1.1.3 Ejemplo de aplicación. ______________________________________ 122
7.1.1.2 Listas enlazadas simples circulares ______________________________ 126
7.1.1.2.1 Operaciones básicas sobre lista enlazada simple circular ___________ 127
7.1.1.2.2 Implementación de operaciones de la lista enlazada simple circular. _ 127
7.1.1.2.3 Ejemplo de aplicación. ______________________________________ 140
7.1.1.3. Listas doblemente enlazadas ____________ ¡Error! Marcador no definido.
7.1.1.3.1 Operaciones básicas sobre listas doblemente enlazadas. ¡Error! Marcador
no definido.
7.1.1 .3.2 Implementación de operaciones básicas de una lista doblemente Enlazada. ¡Error!
Marcador no definido.
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

7.1.1.3.3 Ejemplos. __________________________ ¡Error! Marcador no definido.

7.1.1.3.4 Ejercicio de aplicación. ________________ ¡Error! Marcador no definido.
7.1.1.4. Listas circulares doblemente enlazadas ____ ¡Error! Marcador no definido.
7.1.1.4.1 Operaciones básicas sobre listas doblemente enlazadas. ¡Error! Marcador
no definido.
7.1.1.4.2 Implementación de operaciones básicas de una lista circular doblemente
enlazada. __________________________________ ¡Error! Marcador no definido.
7.1.1.5. Listas enlazadas multiples . _____________ ¡Error! Marcador no definido.
7.1.1.5.1. Ejemplo de aplicación. ________________ ¡Error! Marcador no definido.

TEMA 8. ÁRBOLES________________________________________________ 401

8.1 Introdución _____________________________ ¡Error! Marcador no definido.

8.2 Definición _______________________________ ¡Error! Marcador no definido.
8.4 Recorridos de arboles binarios. ______________ ¡Error! Marcador no definido.
8.4.1 Búsqueda en profundidad. ________________ ¡Error! Marcador no definido.
8.4.1.1 recorrido en pre-orden __________________ ¡Error! Marcador no definido.
8.4.1.2 recorrido en in-orden ___________________ ¡Error! Marcador no definido.
8.4.1.3 recorrido en post-orden _________________ ¡Error! Marcador no definido.
8.5. Implementación de arboles binario. __________ ¡Error! Marcador no definido.
8.6 Ejemplos. _______________________________ ¡Error! Marcador no definido.
Referencias Bibliograficas_________________________________________ _ 435
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

“Nunca consideres el estudio como una obligación, sino como una oportunidad
para penetrar en el bello y maravilloso mundo del saber.”
Albert Einstein

1.1 Introducción.

Muchas empresas han optado como una solución práctica, emplear sistemas
computacionales, con la finalidad de que los procesos cada vez sean más
productivos y competitivos, de esta manera prestar mejores servicios a los clientes.
Es en este contexto, las empresas almacenan y procesan la información mediante
sistemas computacionales. Toda esta información que se procesa no se lo realiza
de forma aislada como si fueran datos simples, si no más al contrario estas tienen
que estar organizados y estructurados de manera sistemática de acuerdo a
determinadas reglas. Cuando la información esta bien organizada trae ventajas
como ser: un fácil acceso y manejo eficiente de los datos, por tal razón los datos
deben estar bien organizados con un cierto tipo de estructura de datos.

Esta organización sistemática de los datos mediante las estructuras de datos hace
que los programas sean eficientes, efectivos de tal forma que habrá una eficiencia
integral de todo el algoritmo, es decir, en la ejecución del mismo.

1.2 Definición de estructura de datos.

Una estructura de datos es una forma de organizar un conjunto de datos

elementales (un dato elemental es la mínima información que se tiene en el sistema)
con el objetivo es facilitar la manipulación de estos datos como un todo y/o
individualmente. Una estructura de datos se define como un conjunto de datos
que están organizados de manera sistemática y metódica, interrelacionados,

7
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

que tienen asociados a un conjunto de operaciones (adicionar, eliminar,

buscar datos, etc.) (Pérez, 2019)

1.3 Clasificación de la estructura de datos.

La programación estructurada se refiere a un conjunto de técnicas que aumentan

considerablemente la productividad del programa reduciendo un elevado grado en
el tiempo requerido para escribir, verificar, depurar y mantener los programas. Utiliza
un número limitado de estructuras de control que minimizan la complejidad de los
programas y por consiguiente reducen los errores y hacen los programas en general
sean más eficientes. La figura 1.1 resume la principal clasificación de las estructuras
de datos
Según (Pérez, 2019), Las estructuras de datos se clasifican como siguen:

 Estructuras de datos estáticas

o Unidimensionales
o Bidimensionales
o multidimensionales
 Estructuras de datos dinámicas
o Lineales
o No lineales
Esta clasificación se muestra en la siguiente figura 1.1

Estructura de datos

Estáticos Dinámicos

Unidimensionales Lineales No lineales

Bimensionales Pilas Arboles

Colas Grafos
Multidimensionales
Listas

8
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Figura 1.1 . Clasificación básica de las estructuras de datos

1.3.1 Estructuras de datos estáticas.

Son aquellas en las que el tamaño ocupado en memoria se define antes de que el
programa se ejecute y no puede modificarse dicho tamaño durante la ejecución del
programa. Por ejemplo, los Arreglos, Registros y Conjuntos están en este grupo de
estructuras.

1.3.2 Estructuras de datos dinámicas.

Las estructuras de datos dinámicas, son estructuras que cuya dimensión puede
crecer o disminuir durante la ejecución del programa. Por ejemplos: Listas
Enlazadas, Árboles y Grafos.

1.3.3 Estructuras De Datos Lineales.

Las estructuras de datos lineales derivan del concepto de secuencia. Primero se

define secuencia como conjunto de elementos entre los que se establece una
relación de predecesor y sucesor. Los diferentes TADs basados en este concepto
se diferenciarán por las operaciones de acceso a los elementos y la manipulación
de la estructura. Desde el punto de vista de la informática, existen cuatro estructuras
lineales importantes que son: los vectores, las pilas, las colas y las listas enlazadas.

1.3.4 Estructuras de datos no lineales.

Se denominan estructuras de datos No Lineales porque a cada elemento le pueden

seguir varios elementos o puede estar rodeado de elementos. Por ejemplo: Árboles,
Grafos y Matrices (Pérez,2019)

1.4 T.D.A. (Tipo De Dato Abstracto)

Un Tipo de Dato Abstracto consiste en extraer los elementos más importantes de

objeto en estudio, un TDA se define como un conjunto de valores que pueden tomar
los datos de ese tipo, junto a las operaciones que los manipulan. Un TDA es un
modelo matemático de estructuras de datos que especifican los tipos de datos
almacenados, las operaciones definidas sobre esos datos y los tipos de parámetros
de esas operaciones, por lo tanto un TDA se representa en la siguiente ecuación.

9
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

TAD = Valores (tipo de dato) + operaciones

Un TDA define lo que cada operación debe hacer, más no como la debe hacer. En
un lenguaje de programación como Java un TDA puede ser expresado como una
interface, que es una simple lista de declaraciones de métodos. Un TDA es
materializado por una estructura de datos concreta, en Java, es modelada por una
clase. Una clase define los datos que serán almacenados y las operaciones
soportadas por los objetos que son instancia de la clase.

Según (Pérez,2019), al diseñar una estructura de datos con la técnica de

abstracción pasa a ser un TDA, que:

 Puede implementarse en cualquier lenguaje.

 Puede aplicarse en cualquier concepto.

Ejemplo: Abstraeremos el concepto Estudiante

Nombre del TAD ESTUDIANTE

Elementos Ru: entero

Nombre: Cadena
Sexo: carácter
Direccion: Cadena

LeerDatosEstudiante ()
Operaciones
ImprimirDatosEstudiante ()
o métodos ModificarDireccion()
CalcularNotaFinal()

Como se puede notar existe una operación No Permitida denominada:

CalcularNotaFinal(); que no debiera estar presente en el TAD, debido a que no se
cuenta con elementos que nos permitan realizar esta operación.

10
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

”La educación es el vestido de gala para asistir a la fiesta de la vida.”

Miguel Rojas Sánchez

2.1 Vectores
2.1.1 Definición de vector.

Un vector es una estructura de datos lineal que almacena los datos de un solo tipo,
los vectores también son llamados arreglos unidimensionales, el cual tiene las
siguientes características:

 Almacena los elementos en posiciones continuas.

 Tienen un mismo nombre de variable o identificador, que representa a todos
los elementos.
 Los elementos son referenciados mediante un índice que especifica el lugar
que ocupa cada elemento.
 Se tiene acceso directo aleatorio a los elementos individuales del arreglo.

Un vector se representa gráficamente de la siguiente manera.

Tamaño n=9
Elemento

V= 4 25 8 68 60 3 45 3 5
0 1 2 3 4 5 6 7 8

Nombre del vector Índice

Un vector para poder acceder a los datos se basa en el uso de sus índices.

 Cada elemento del vector se puede procesar como si fuera una variable
simple.
 El valor del índice indica cual es el elemento que se está referenciando, a
través de ellos pueden realizarse las siguientes operaciones:

11
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

o Asignar valores a un elemento del vector

V[1] = 25
V[4] = 60
A = V[7] => A= 3
V[3] = V[2] + V[4] => 8 + 60 el valor que almacena será
V[3]=68

2.1.2 Tipo de datos Abstracto (TDA) de un vector

El tipo de dato abstracto (TAD) de un vector se muestra en la siguiente figura 3.1

Figura 3.1 TDA de un vector

A continuación se implementa el TDA, con lenguaje python.

class Vectores(object):
vector = [None]
#Constructor que inicializa el vector
def __init__(self):
self.vector=[]
# Renicializa el vector
def reinicia(self):
self.vector=[]
# Llena datos al vector mediante
# Una cadena
def llenar(self,cadena):
subcadena=cadena.split(",")
for i in subcadena:
d=int(i)
self.vector.append(d)
#llena un vector, ingresando datos
# una a una
def llenar(self,n):
for i in range(n):
s=input("Dato:")
d=int(s)
self.V.append(d)
12
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# mostrar datos de un vector

def mostrar(self):
s=""
for i in self.vector:
s=s+" "+str(i)
return s

2.1.3 Ejemplos

1. Dado un vector con N elementos calcular la media aritmética

Si N=6

V= 4 6 8 9 2 1
0 1 2 3 4 5

Promedio = (4 + 6 + 8 + 9 + 2 + 1) / 6

Promedio = 30 / 6 = 5

Solución.
#Calcula el promedio de un vector
def promedio(self):
s=0
for i in self.V:
s=s+i
p=s/len(self.V)
return p

#Ejecucion del programa

vec = Vectores()
print("ingrese datos")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
s=vec.mostrar()
print("Mostrando Datos")
print(s)
p=vec.promedio()
print("El promedio es:",p)

13
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

2. Realice un programa que de un vector de N elementos, por cada elemento

indique la cantidad de veces que se repite.

Ejemplo:
4 2 4 4 7 7
B= 1 2 3 4 5 6

La salida sera :
Elemento Se repite
4 3
2 1
7 2
Solución.

#Cuenta la cantidad de veces que se repite

#por cada elemento
def cuenta_ocurrencias(self):
s = "\nElemento \tse repitio\n";
s = s + "___________________________________\n";
cont = 0;
for i in range(len(self.V)-1):
if (self.V[i]!=-999):
cont = 1;
s = s + " " + str(self.V[i])
for j in range(i + 1,len(self.V)):
if ((self.V[i] == self.V[j]) and (self.V[i] != -999)):
cont=cont+1
self.V[j] = -999;

self.V[i] = -999;
s = s + "\t=\t" + str(cont) + "\n";
return s;

#Ejecucion del programa

vec = Vectores()
print("ingrese datos")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
s=vec.mostrar()
print("Mostrando Datos")
print(s)
s=vec.cuenta_ocurrencias()

14
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

3. Realice un programa que elimine elementos duplicados de un vector.

Ejemplo:

A= 4 2 4 4 7 7
1 2 3 4 5 6
Eliminando los duplicados queda:

A= 4 2 7
1 2 3

Solución.
#Elimina los elementos repetidos
#de un vector
def elimina_repetidos(self):
D = []
for e in self.V:
if e not in D:
D.append(e)
self.V=D

#Ejecucion del programa

vec = Vectores()
print("ingrese datos")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
s=vec.mostrar()
print("Mostrando Datos")
print(s)
vec.elimina_repetidos()
s=vec.mostrar()
print(s)

4.- Llenar el vector V, con los primeros N números de Fibonacci

Ejemplo:
Si n = 6

V= 0 1 1 2 3 5
1 2 3 4 5 6

15
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución.

#Generar la serie de fibonaci en un vector

#V=[0,1,1,2,3,5,..]
def vectorFibonaci(self, n):
a = -1
b = 1
c = 0;
for i in range(n):
c = a + b
self.V.append(c)
a = b
b = c
#Ejecucion del programa
vec = Vectores()
print("ingrese datos")
n=int(input("Cantidad de datos:"))
vec.vectorFibonaci(n)
print("Mostrando Datos")
s=vec.mostrar()
print(s)

5. Dado un vector V de dimensión N, determinar los puntos silla y

mostrarlos. Se considera a un elemento V(i) como punto silla si se cumple la
siguiente condición: V(i-1) < V(i) < V(i+1).
Solución.

#Dado un vector V de dimensión N, determinar los puntos silla y mostrarlos.

#Se considera a un elemento V(i) como punto silla si se cumple la siguiente
#condición: V(i-1) < V(i) < V(i+1).
def puntoSilla(self):
s = ""
for i in range(len(self.V)-1):
if ((self.V[i - 1]<self.V[i])and(self.V[i] < self.V[i + 1])):
s = s + "Punto Silla:" + str(self.V[i]) + "\n"
return (s)
#Ejecucion del programa
vec = Vectores()
print("ingrese datos")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
print("Mostrando Datos")
s=vec.mostrar()
print(s)
print("Mostrando Punto Silla")
s=vec.puntoSilla()
print(s)
16
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

6. Teniendo dos vectores A y B de N posiciones cada uno, a partir de estos

crear otro vector C que contenga los elementos tanto de A como de B de forma
intercalada.

Ejemplo: Si N=4
Vector A:

1 4 9 0

Vector B:

20 30 40 50

Vector C:

1 20 4 30 9 40 0 50

Solución
#Teniendo dos vectores A y B de N posiciones
#cada uno, a partir de estos crear
#otro vector C que contenga los elementos
#tanto de A como de B de forma intercalada.
def intercala (self,A,B,C):
for i in range(len(A.V)):
C.V.append(A.V[i])
C.V.append(B.V[i])

#Ejecucion del programa

vec = Vectores()
vec2 = Vectores()
vec3 = Vectores()
print("ingrese datos Vector 1")
n=int(input("Cantidad de datos:"))
vec.llenar(n)

print("ingrese datos Vector 2")

n=int(input("Cantidad de datos:"))
vec2.llenar(n)

print("Mostrando Datos Vector 1")

s=vec.mostrar()
print(s)

print("Mostrando Datos Vector 2")

s=vec2.mostrar()
print(s)
17
vec.intercala(vec,vec2,vec3)
print("Mostrando Datos Vector 3")
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

7. Buscar un elemento X por el método de la busqueda Binario.

Si N = 6 Elemento a buscar X=5

V= 4 6 8 9 2 3
0 1 2 3 4 5
El vector debe se ser ordenado

V= 2 3 4 6 8 9
0 1 2 3 4 5
Solución.
# busca un elemento Xpor el metodo
# de la busqueda Binario
def busquedaBinario(self,X):
pos = -1;
li = 0;
ls = len(self.V) - 1
while (li <= ls) :
mitad = (li + ls) // 2
if (X == self.V[mitad]):
pos = mitad
li = ls + 1
elif (X > self.V[mitad]):
li = mitad + 1
else:
ls = mitad - 1
return pos+1

#Ejecucion del programa

vec = Vectores()
print("ingrese datos Vector 1")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
print("Mostrando Datos Vector 1")
s=vec.mostrar()
print(s)
x=int(input("Elemento a buscar:"))
pos=vec.busquedaBinario(x)
print("Elemento encontrado en la posicion=",pos)

8. Ordenar un vector V por el método de la burbuja.

Si N = 6

18
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

V= 4 6 8 9 2 3
0 1 2 3 4 5
El vector ordenado

V= 2 3 4 6 8 9
0 1 2 3 4 5
Solución.

# Ordena un vector V por el metodo de la Burbuja

def ordenaBurbuja(self):
for i in range(len(self.V)- 1):
for j in range(i + 1,len(self.V)):
if (self.V[i] >= self.V[j]):
aux = self.V[i];
self.V[i] =self.V[j];
self.V[j] = aux;

#Ejecucion del programa

vec = Vectores()
print("ingrese datos Vector 1")
n=int(input("Cantidad de datos:"))
vec.llenar(n)
print("Mostrando Datos Vector 1")
s=vec.mostrar()
print(s)
vec.ordenaBurbuja()
print("Mostrando Datos ordenados")
s=vec.mostrar()
print(s)
9. Dado dos polinomios P1(x), P2(x) realizar las siguientes operaciones:

a) Sumar los polinomios en P3(x).

b) Multiplicar los polinomios P3(x)
c) Derivar una función polinómica en P3(x)

Suma dos polinomios.

P1(x)= 2x1 + 3x4 + 4x6

P2(x)=5X3 + 5X4 +6X5 + 8x7

Los polinonios se representa en vectores de la siguiente manera.

P1(x)= 2x1 + 3x4 + 4x6

2x1 3x4 4x6

19
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

P1 =

0 1 2

P2(x)=5X3 + 5X4 +6X5 + 8x7

5X3 5X4 6X5 8x7

P2 =

0 1 2 3

La suma sera

P3(x) = 2x1 + 5x3 + 8x4 + 10x5 + 8x7

2x1 5x3 8x4 10x5 8x7

P2 =

0 1 2 3

Solución

Para dar solución al problema de los polinomios se debe considerar los siguiente.

 El polinomio debe estar ordenado

 No debe existe exponentes repetidos en caso de existir se debe realizar la
suma respectiva.
Inicialmente se implementa las operaciones básicas:

 Leer un polinomio
 Mostrar un polinomio
 Ordenar un polinomio

El TDA del polinomio se muestra en la figura 3.2

20
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Figura 3.2 TDA de Polinomio

A continuación se realiza la implementación en lenguaje Python

class Termino:
def __init__(self, coef, expo):
self.coef = coef
self.expo = expo
def get_coef(self):
return self.coef
def set_coef(self, coef):
self.coef = coef
def get_expo(self):
return self.expo
def set_expo(self, expo):
self.expo = expo
def __str__(self):
return f"{self.coef}x^{self.expo}" if self.expo != 0 else
str(self.coef)

Implementación de la Clase Polinomio

from TerminoP import Termino

class Polinomio:
def __init__(self):
self.P=[]
# Llena datos al polinomio
def llenarDatos(self,n):
for i in range(n):
c=int(input("Coeficiente:"))
e=int(input("Exponente:"))
ter=Termino(c,e)
self.P.append(ter)
# Muestra datos del polinomio
def mostrarDatos(self):
s=""
for i in range(len(self.P)):
s=s+" "+str(self.P[i])
return s
#ordena datos del polinomio
def ordena(self): 21
for i in range(len(self.P)-1):
for j in range(i + 1,len(self.P)):
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Simplifica terminos repetidos del polinomio

def simplifica(self):
i = 0
while i < len(self.P) - 1:
if self.P[i].get_expo() == self.P[i + 1].get_expo():
self.P[i].set_coef(self.P[i].get_coef() + self.P[i
+ 1].get_coef())
# Elimina el término duplicado
del self.P[i + 1]
else:
i += 1

# Suma dos polinimios

def suma(self,p1, p2, p3):
j = 0;
for i in range(len(p1.P)):
ter = Termino(p1.P[i].get_coef(), p1.P[i].get_expo())
p3.P.append(ter)
for i in range(len(p2.P)):
ter = Termino(p2.P[i].get_coef(), p2.P[i].get_expo())
p3.P.append(ter)
p3.ordena()
p3.simplifica()
#programa principal
pol1 = Polinomio()
pol2 = Polinomio()
pol3 = Polinomio()
print("Polinomio 1")
pol1.llenarDatos(5)
pol1.ordena()
pol1.simplifica()
s=pol1.mostrarDatos()
print(s)
print("Polinomio 2")
pol2.llenarDatos(5)
pol2.ordena()
pol2.simplifica()
s=pol2.mostrarDatos()
print(s)
print("Polinomio 3")
pol3.suma(pol1,pol2,pol3)
s=pol1.mostrarDatos()
print(s)
s=pol2.mostrarDatos()
print(s)
s=pol3.mostrarDatos()
print(s)

22
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

b) Multiplicar los polinomios en P3(x)

P1(x)= 2x1 + 3x4 + 4x6

P2(x)=5X3 + 5X4

Los polinonios se representa en vectores de la siguiente manera.

P1(x)= 2x1 + 3x4 + 4x6

2X1 3X4 4X6

P1 =

0 1 2

P2(x)=5X3 + 5X4

5X3 5X4
P1 =

0 1

La multiplicación de los polinomios sera

P3(x) = 10x4 + 15x7 + 20x9 + 10x5 + 13x8 + 20x10

10X4 15X7 20X9 10X5 13X8 20X10

P3 =

0 1 2 3 4 5

El polinomio ordenado sera:

P3(x) = 10x4 + 10x5 + 15x7 + 15x8 + 20x9 + 20x10

10X4 10X5 15X7 15X8 20X9 20X10

P3 =

0 1 2 3 4 5

23
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Implementación del método para multiplicar los dos polinomios

#Multiplica dos polinomios

def multiplica(self,p1, p2, p3):
for i in range(len(p1.P)):
for j in range(len(p2.P)):
ter=Termino(p1.P[i].get_coef() *
p2.P[j].get_coef(), p1.P[i].get_expo() + p2.P[j].get_expo())
p3.P.append(ter)
p3.ordena();
p3.simplifica();

#programa principal
pol1 = Polinomio()
pol2 = Polinomio()
pol3 = Polinomio()
print("Polinomio 1")
pol1.llenarDatos(5)
pol1.ordena()
pol1.simplifica()
s=pol1.mostrarDatos()
print(s)
print("Polinomio 2")
pol2.llenarDatos(5)
pol2.ordena()
pol2.simplifica()
s=pol2.mostrarDatos()
print(s)
print("Polinomio 3")
pol3.multiplica(pol1,pol2,pol3)
s=pol1.mostrarDatos()
print(s)
s=pol2.mostrarDatos()
print(s)
s=pol3.mostrarDatos()
print(s)

10. En un vector almacenar los datos de un empleado(ci,nom,pat,mat,dir,salario) y

realizar las siguientes operaciones
a) Crear un vector de empleados
b) Llenar datos en el vector
c) Ordenar los empleados por el apellido paterno
d) Buscar un empleado
e) Calcular la planilla de los empleados
f) Buscar un empleado con el salario menor

24
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución.
Para resolver el problema primero se debe definir el TDA, el cual se muestra en la
siguiente figura 3.3

Figura 3.3 Tipo de datos Abstracto (TDA) administración de empleado

Implementación de la clase Empleado.

class Empleado(object):
emp=[]
#Constructor para inicializar los
#atributos de los empleados
def __init__(self):
self.emp=[]
#Adciona los datos de un empleado
def adicionar(self):
d=[]
n=int(input("cantidad de empleados"))
for i in range(n):
d=[]
idemp=input("C.I.:")
nom=input("Nombre:")
pat=input("Paterno:")
mat=input("Materno:")
dire=input("Direccion:")
sal=input("Salario:")

d.append(idemp)
d.append(nom)
d.append(pat)
d.append(mat)
d.append(dire)
d.append(sal)
self.emp.append(d)

25
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Lista los datos de los empleados

def mostrar(self):
s=""
for d in self.emp:
for i in d:
s=s+i+"\t"
s=s+"\n"
return s
# Elimina un empleado por el ci
def eliminar(self):
datoa=[]
cod=input("Codigo a eliminar")
for d in self.emp:
if d[0]!=cod:
datoa.append(d)

self.emp=datoa
#Modifica los datos de un empleados
def modificar(self):
cod = input("codigo a modificar")
for d in self.emp:
if d[0]==cod:
print ("ingreso de nuevos datos")
idemp=input("C.I.:")
nom=input("Nombre:")
pat=input("Paterno:")
mat=input("Materno:")
dire=input("Direccion:")
sal=input("Salario:")
d[1]=nom
d[2]=pat
d[3]=mat
d[4]=dire
d[5]=sal
break
#Busca datos de un empleado por el apellido paterno
def buscar(self):
s=""
pat = input("Paterno a buscar:")
for d in self.emp:
if d[1]==pat:
for i in d:
s=s+i+"\t"
s=s+"\n"
return s
#Ordena los datos de un empleado por el paterno
def ordenarPaterno(self):
dat_emp = sorted(self.emp, key=lambda x: x[3])
self.emp=dat_emp

26
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Calcula Planilla de los empleados

def calculaPlanilla(self):

s="CI\tPaterno\tMaterno\tNombre\tDireccion\tSalario\tAFP\t\tIVA\t\
tTOTAL DESCUENTO\t\tLIQUIDO PAGABLE \n"

s=s+"_____________________________________________________________
_________________________________________________\n"
for i in self.emp:
salario = float(i[5])
afp = salario * 0.1271;
if (salario > 8000):
iva = (salario - 8000) * 0.13;
else:
iva = 0;
descuento = afp + iva;
liquido_pagable = salario - descuento;
s=s+i[0] + "\t" + i[1] + "\t" + i[2] + "\t" + i[3] +
"\t" + i[4] + "\t" + i[5] + "\t" + str(afp) + "\t\t" + str(iva) +
"\t\t" +str(descuento) + "\t\t" + str(liquido_pagable) + "\n"
return s

#Obtiene el salario menor de los empleados

def salarioMenor(self):
s=""
dat = min(self.emp, key=lambda x: x[5])
s=s+dat[0] + "\t" + dat[1] + "\t" + dat[2] + "\t" + dat[3] + "\t"
+ dat[4] + "\t" + dat[5] + "\n"
return s

#Funcion para el programa principal

def menuPrin():

while True:
print("\nMenu")
print("1. Crear")
print("2. Adicionar")
print("3. Modificar")
print("4. Eliminar")
print("5. Listar ")
print("6. Buscar ")
print("7. Ordenar ")
print("8. Planilla ")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
empleado = Empleado()
elif opcion=="2":
empleado.adicionar()
elif opcion=="3":
e=empleado.modificar()

27
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Calcula Planilla de los empleados

def calculaPlanilla(self):

s="CI\tPaterno\tMaterno\tNombre\tDireccion\tSalario\tAFP\t\tIVA\t\
tTOTAL DESCUENTO\t\tLIQUIDO PAGABLE \n"

s=s+"_____________________________________________________________
_________________________________________________\n"
for i in self.emp:
salario = float(i[5])
afp = salario * 0.1271;
if (salario > 8000):
iva = (salario - 8000) * 0.13;
else:
iva = 0;
descuento = afp + iva;
liquido_pagable = salario - descuento;
s=s+i[0] + "\t" + i[1] + "\t" + i[2] + "\t" + i[3] +
"\t" + i[4] + "\t" + i[5] + "\t" + str(afp) + "\t\t" + str(iva) +
"\t\t" +str(descuento) + "\t\t" + str(liquido_pagable) + "\n"
return s

#Obtiene el salario menor de los empleados

Para la implementación
def de manejo de datos de un empleado se tendra el siguiente
salarioMenor(self):
formulario.s=""
dat = min(self.emp, key=lambda x: x[5])
s=s+dat[0] + "\t" + dat[1] + "\t" + dat[2] + "\t" + dat[3] + "\t"
+ dat[4] + "\t" + dat[5] + "\n"
return s

#Funcion para el programa principal

def menuPrin():

while True:
print("\nMenu")
print("1. Crear")
print("2. Adicionar")
print("3. Modificar")
print("4. Eliminar")
print("5. Listar ")
print("6. Buscar ")
print("7. Ordenar ")
print("8. Planilla ")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
empleado = Empleado()
elif opcion=="2":
empleado.adicionar()
elif opcion=="3":
e=empleado.modificar()

28
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="4":
empleado.eliminar()
elif opcion=="5":
s=empleado.mostrar()
print(s)
elif opcion=="6":
empleado.buscar()
elif opcion=="7":
empleado.ordenarPaterno()
elif opcion=="8":
s=empleado.calculaPlanilla()
print(s)
elif opcion=="9":
s=empleado.salarioMenor()
print(s)
elif opcion=="*":
break
else:
print("opcion no valida")
#Llamada al programa principal
menuPrin()

29
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Estar preparado es importante, saber esperar lo es aún más, pero aprovechar el

momento adecuado es la clave de la vida.
Arthur Schnitzler

3.1 Definición
Una pila representa una estructura de dato lineal, en la que se puede agregar o
quitar elementos específicos por uno de los dos extremos. En consecuencia, los
elementos de una pila se eliminan en orden inverso al que se insertaron; es decir,
el último elemento que se mete en la pila es el primero que se saca. Debido a esta
característica, se le conoce como estructura LIFO (Last input, first output) que
significa (ultimos en entrar, primeros en salir) (Cairo & Guardati, 2006)

Una pila tiene la siguiente representación gráfica como se muestra en la figura 4.1

Max 20
.
.

Tope 6
5 23
4 231
3 23
2 2
1 3
0 12
Pila
Figura 4.1 Representación de una Pila

3.2 Estructura pila

En una estructura pila se toma encuenta las siguientes consideraciones.
 Para crear la estructura Pila, debe existir el tamaño máximo de la pila, en
este caso denotaremos con la variable MAX.
 Al momento de crear la pila el Tope debe iniciar en cero (tope=0).
 Cuando se adiciona un elemento a la pila el Tope debe incrementar en 1
(tope=tope+1).

30
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

 Cuando se elimine un elemento de la pila el Tope debe decrementar en 1

(tope=tope-1).
 Si el Tope=0 entonces la pila esta vacía.
 Si el Tope=Max entonces la Pila está llena.

3.3 Tipo de datos Abstracto(T.D.A.) de una pila.

El tipo de dato abstracto de una pila se muestra en la siguiente figura 4.2

Nombre Pila
Int Max=20
Atributos int P[Max]
int tope
Crear()
Operaciones boolean Vacio()
boolean Lleno()
adiciona(int e)
Int eliminar()
String mostrar()
void restaurar()
Pila copiar()

Figura. 4.2 T.D.A Estructura Pila

Los métodos de la estructura Pila se detalla continuación.

 Crear () Crea una pila o inicializa el tope de la pila en cero.

 Vacío() Verifica si una pila esta vacío.
 Lleno() Verifica si una pila está lleno.
 Adiciona() Adiciona un elemento a la pila.
 Elimina() Elimina un elemento de la pila.
 Mostrar() Muestra los elementos de la Pila.
 Restaura() Restaura elementos de la Pila en otra pila.
 Copiar() Copia una pila a otra pila.

3.4 Implementación de la estructura pila en Python.

Para la implementación de la estructura Pila, primero se creara la clase con el

nombre Pila , el cual contendrá las operaciones básicas para el manejo de datos.

La implementación de la clase pila se empleara el lenguaje Python

31
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

import random
class Pilas (object):
#variables globales
P=[]
tope=0
#constructor, que inicializa los atributos
# iniciliaza objetos
# self (python) = this (java)
def __init__(self):
self.P=[]
self.tope=0
#verificamos si la pila esta vacio
def vacio(self):
if self.tope==0:
return True
else:
return False
#adiciona un elemento a la pila
def adiciona(self,e):
self.P.append(e)
self.tope=self.tope+1
#elimina un elemento de la pila
def elimina(self):
e=-1
if not(self.vacio()):
self.tope=self.tope-1
e=self.P.pop()
else:
print("pila vacia")
return e
# restaura datos
def restaura(self,PA):
while(not(PA.vacio())):
e=PA.elimina()
self.adiciona(e)
#lista datos de la pila
def listar(self):
s=""
PA=Pilas()
while(not self.vacio()):
e=self.elimina()
s= s+ " "+ str(e)
PA.adiciona(e)
self.restaura(PA)
return s
# En una Pila P llenar n datos
# de forma aleatoria en la pila
def adicionaAleatorio(self):
n=int(input("Cantidad de datos a generar:"))
for i in range(1,n+1):
e=random.randint(1,20)
self.adiciona(e)

32
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

3.5. Ejemplos con pilas simples

1. Dada una pila P1 contar elementos de longitud 3, es decir aquellos

números de la pila que tiene 3 dígitos

Solución.
Tope 8
7 55
6 4
5 456
4 1234
3 567
2 23
1 457
0 4
P1
Dígitos de longitud 3 son los siguientes números: 456 , 567, 457.

Solución.
Primero se implementará un módulo para contar los dígitos de un número N, la
implementación se muestra a continuación.
#cuenta cantidad de digitos
def cuentaDigitos(self,n):
cont = 0;
while (n != 0):
n = n // 10;
cont=cont+1
return cont;
Una vez implementado el método cuentaDigitos , ahora se implementará el
método cuenta3Digitos, que se muestra a continuación.
# Dada una pila contar elementos de longitud 3
def cuenta3Digitos(self):
cd = 0
e = 0
PA = Pilas()
while (not self.vacio()):
e = self.elimina()
PA.adiciona(e)
if (self.cuentaDigitos(e) == 3):
cd=cd+1
print("Total Digitos de Longitud 3=",cd)
self.restaura(PA)

33
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

2. Dada una pila P1 contar elementos repetidos de la pila P2 y almacenar los

datos en PT1, PT2

8 Tope 8
7 7 6
6 6 1
5 5 19
Tope 4 4 1
3 6 3 6
2 8 2 8
1 4 1 1
0 1 0 9
P1 P2
8 8
7 7
6 6
5 5
Tope 4 Tope 4
3 1 3 3
2 4 2 0
1 8 1 1
0 6 0 2
PT1 PT2

34
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#cuenta repertidos de una pila p1 en otra pila p2 y almacena los

# Buscar un elemento x en la pila
datos en pt1, pt2
def buscar(self,PX,x):
def cuentaRep(self):
PA = Pilas()
s = "";
sw=False
PT1 = Pilas()
while not PX.vacio():
PT2 = Pilas()
e=PX.elimina()
PA = Pilas()
PA.adiciona(e)
#elimina elementos pares de la pila
defwhile (not self.vacio()):
eliminaPares(self):
if(e==x):
e1Pilas()
PA = = self.elimina()
sw=True
PA.adiciona(e1)
while (notbreak
self.vacio()):
if(self.buscar(PT1,e1)==False):
e = self.elimina()
PX.restaura(PA)
if cont
(e % = self.cuentaNum(self,e1)
2 != 0):
return sw
PA.adiciona(e)
PT1.adiciona(e1)
#busca un elemento en una pila y cuenta cuantas elementos existe
self.restaura(PA)
PT2.adiciona(cont)
def cuentaNum(self,PB,e):
cont = 1
self.restaura(PA)
PA = Pilas()
s = PT1.listar()
while (not PB.vacio()):
print(s)
e1 = PB.elimina()
s = PT2.listar()
PA.adiciona(e1)
print(s)
if (e1 == e):
cont=cont+1
PB.restaura(PA)
return cont

Solución.

3. Dada una Pila P1 eliminar los elementos pares de la pila.

Tope 8 8
7 4 X 7
6 8 X 6
5 21 5
4 12 X 4
3 6 X 3
2 8 X Tope 2
1 4 X 1 21
0 1 0 1
P1 P1

Solución.
4. Dada una Pila P Buscar un Elemento X en la pila

Tope 8
7 4
6 8
5 2

35
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

41
36
28
14
01
P
Elemento X=2 entonces existe

Solución.

# Buscar un elemento x en la pila

def buscar(self,PX,x):
PA = Pilas()
sw=False
while not PX.vacio():
e=PX.elimina()
PA.adiciona(e)
if(e==x):
sw=True
break
PX.restaura(PA)
return sw

5. Dada Una Pila P eliminar los elementos repetidos de la pila

Tope 8 8
7 4 X 7
6 8 6
5 4 X 5
4 1 X Tope 4
3 6 3 8
2 1 X 2 6
1 4 1 4
0 1 0 1
P P
Solución.
#elimina Todos los elemenos x
def eliminaTodoX(self,x):
PA=Pilas()
while not self.vacio():
e=self.elimina()
if x!=e:
PA.adiciona(e)
self.restaura(PA)
# Dada una Pila P, eliminar los elementos repetidos
def eliminaRepetido(self):
PA=Pilas()
while not self.vacio():
e=self.elimina()
self.eliminaTodoX(e) 36
PA.adiciona(e)
self.restaura(PA)
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

6. Dada dos Pilas P1, P2 realizar la unión de elementos en una tercera pila
P3

8 8 8
7 7 Tope 7
6 6 6 7
Tope 5 5 5 10
4 5 Tope 4 4 1
3 9 3 2 3 3
2 2 2 10 2 2
1 3 1 7 1 9
0 1 0 5 0 5

P1 P2 P3

Solución.
# Dada una Pila P, eliminar los elementos repetidos
def eliminaRepetido(self):
PA=Pilas()
while not self.vacio():
e=self.elimina()
self.eliminaTodoX(e)
PA.adiciona(e)
self.restaura(PA)

#dada dos pilas realizar la union de dos pilas

#en una tercera pila
def union(self,A,B,C):
paux = Pilas()
while (not A.vacio()):
e1 = A.elimina()
C.adiciona(e1)
paux.adiciona(e1)

A.restaura(paux)
Llamadawhile (not B.vacio()):
al programa desde el Botón del Menú Principal
e1 = B.elimina()
paux.adiciona(e1)
if (C.buscar(C, e1) == False):
C.adiciona(e1)
B.restaura(paux)

37
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

7. Dada dos Pilas P1, P2 realizar la intersección de elementos en una tercera

pila P3.

8 8 8
7 7 7
6 6 6
Tope 5 5 5
4 5 Tope 4 4
3 9 3 2 3
2 2 2 10 Tope 2
1 3 1 7 1 5
0 1 0 5 0 5
P1 P2 P3
Solución.

# Dada dos Pilas A,B,

# realizar la Intersección de
# elementos de una Pila C(la intersección debe
# ser con en teoría de conjuntos)
def intersecta(self,A,B,C):
PA = Pilas()
while not A.vacio():
e=A.elimina()
PA.adiciona(e)
if B.buscar(B,e)==True:
C.adiciona(e)
A.restaura(PA)

8. Dada dos pilas P1, P2 sumar las pilas, ambas pilas tienen la misma
cantidad de elementos.

8 8 8
7 7 7
6 6 6
Tope 5 Tope 5 Tope 5
4 5 4 2 4 7
3 9 3 2 3 9

38
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

2 2 2 10 2 12
1 3 1 7 1 10
0 1 0 5 0 6
P1 P2 P3
Solución.

#sumar dos pilas del mismo tamaño

def suma_pilas(self, A,B,C):
paux1 = Pilas()
paux2 = Pilas()
paux3 = Pilas()
while (not A.vacio()):
e1 = A.elimina()
e2 = B.elimina()
paux1.adiciona(e1)
paux2.adiciona(e2)
paux3.adiciona(e1 + e2)
A.restaura(paux1)
B.restaura(paux2)
C.restaura(paux3)

9. Dada una Pila P buscar el elemento mayor de la Pila

8
7
6
Tope 5
4 5
3 9
2 2
1 3
0 1
P1

Elemento mayor = 9
#Busca elemento mayor en una pIla
def elemento_mayor(self,A):
paux=Pilas()
mayor = A.elimina()
paux.adiciona(mayor)
while (not A.vacio()):
e2 = A.elimina()
paux.adiciona(e2)
if (mayor < e2):
mayor = e2 39
A.restaura(paux)
return mayor
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

10. Dada una pila A intercambiar el primer elemento de la pila con ultimo
elemento.

Tope 8 Tope 8
7 4 7 1
6 8 6 8
5 4 5 4
4 1 4 1
3 6 3 6
2 1 2 1
1 4 1 4
0 1 0 4
P P

#Intercambiar el último elemento de la pila por el primer elemento.

def intercambia_ultimo_primero(self):
paux = Pilas()
ultimo = self.elimina()
while (not self.vacio()):
e1 = self.elimina()
paux.adiciona(e1)
primero = paux.elimina()
paux.adiciona(ultimo)
self.restaura(paux)
self.adiciona(primero)

11. Dada una Pila A eliminar un elemento X de la pila

Tope 8 8
7 4 Tope 7
6 8 6 4
5 4 5 8
4 1 4 4
3 6 X 3 1
2 1 2 1
1 4 1 4

40
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

01 0 1
A A
Elemento a eliminar X=6
Solución.
# Elimina Un elemenro X de una Pila
def elimina_elemento(self,x):
paux = Pilas()
while (not self.vacio()):
e1 = self.elimina();
if (e1 != x):
paux.adiciona(e1)
else:
break
self.restaura(paux)
12. Dada una Pila A ordenar sus elementos de la pila A

Tope 8 Tope 8
7 5 7 10
6 8 6 9
5 4 5 8
4 2 4 5
3 3 X 3 4
2 10 2 3
1 9 1 2
0 1 0 1
A A
Solución.

#Busca elemento mayor en una pIla

def elemento_mayor(self,A):
paux=Pilas()
mayor = A.elimina()
paux.adiciona(mayor)
while (not A.vacio()):
e2 = A.elimina()
paux.adiciona(e2)
if (mayor < e2):
mayor = e2
A.restaura(paux)
return mayor

# Elimina Un elemenro X de una Pila

def elimina_elemento(self,x):
paux = Pilas()
while (not self.vacio()):
e1 = self.elimina();
if (e1 != x):
paux.adiciona(e1)
else:
break
self.restaura(paux)
41
# Ordena los elementos de una pila A
def ordena_pila(self) {
paux=Pilas()
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

13. Dada una Pila A ordenada insertar un elemento X en el lugar

correspondiente.
Elemento a insertar X=7

Tope 8
Tope 7 7 10
6 10 6 9
5 9 5 8
4 8 4 7
3 5 3 5
2 4 2 4
1 3 1 3
0 2 0 2
A A
Solución.
#insertar un elemento X en el lugar que le corresponde
def insertar_elemento(self,ex):
paux = Pilas()
sw = False
while (not self.vacio() and (sw == False)):
e1 = self.elimina()
if (e1 < ex):
paux.adiciona(ex)
paux.adiciona(e1)
sw = True
else:
paux.adiciona(e1)
#inserta en caso de que el elemento
#no esta por el medio
if (sw == False):
paux.adiciona(ex)
self.restaura(paux);

42
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

14. Dada una pila A con elementos, contar cuantos elementos se repiten por
cada elemento y almacenar la frecuencia de repeticiones en otras dos
pilas.

Tope 8 8 8
7 8 7 7
6 7 6 6
5 4 Tope 5 Tope 5
4 3 4 1 4 2
3 4 3 3 3 2
2 1 2 4 2 2
1 3 1 7 1 1
0 1 0 8 0 1
P1 p_rep1 p_rep2
Solución.

# Buscar un elemento x en la pila

def buscar(self,PX,x):
PA = Pilas()
sw=False
while not PX.vacio():
e=PX.elimina()
PA.adiciona(e)
if(e==x):
sw=True
break
PX.restaura(PA)
return sw

#busca un elemento en una pila y cuenta cuantas elementos existe

def cuentaNum(self,PB,e):
cont = 1
PA = Pilas()
while (not PB.vacio()):
e1 = PB.elimina()
PA.adiciona(e1)
if (e1 == e):
cont=cont+1
PB.restaura(PA)
return cont

#cuenta repertidos de una pila p1 en otra pila p2 y almacena los

datos en pt1, pt2
def cuentaRep(self):
s = "";
PT1 = Pilas()
PT2 = Pilas()
PA = Pilas()
while (not self.vacio()):
e1 = self.elimina()
PA.adiciona(e1)
if(self.buscar(PT1,e1)==False):
43
cont = self.cuentaNum(self,e1)
PT1.adiciona(e1)
PT2.adiciona(cont)
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

15. Dado un polinomio P donde se almacena en la pila coeficiente y

exponente evaluar el polinomio en un punto X.
Pol = 2X3 + 3X5 + 6X7 Evaluar en el punto X=2
3 + 5 7
Pol= 2*2 3*2 + 6*2 = 880

8
Tope 7
6
5 7
4 6
3 5
2 3
Exponente 1 3
Coeficiente 0 2
P1
Solución.

# Evaluacion un polinonio en punto x

def evalua_polinomio(self,pol,x):
suma = 0.0
paux = Pilas()
while (not pol.vacio()):
expo = pol.elimina()
paux.adiciona(expo)
coef = pol.elimina()
paux.adiciona(coef)

suma = suma + coef * (x ** expo)

pol.restaura(paux)
return suma

16. Dado dos Polinomios Pol1, Pol2 realizar la suma de los polinomios

Pol1 = 2X3 + 3X5 + 6X7

44
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Pol2 = 4X3 + 3X7 + 6X8

------------------------------------------------------------------

Pol3 = 6X3 + 3X5 + 9X7 + 6X8

8 8 Tope 8
7 7 7 8
Tope 6 Tope 6 6 6
5 7 5 8 5 7
4 6 4 6 4 9
3 5 3 7 3 5
2 3 2 3 2 3
1 3 1 3 1 3
0 2 0 4 0 6
Pol1 Pol2 Pol3

Solución .

# Sumar dos polinonios

def suma_polinomio(self,pol1,pol2,pol3):
paux1 = Pilas()
paux2 = Pilas()
while ((not pol1.vacio()) and (not pol2.vacio())) :
expo1 = pol1.elimina()
coef1 = pol1.elimina()
expo2 = pol2.elimina()
coef2 = pol2.elimina()
# si son iguales los exponentes se suman coeficientes
if (expo1 == expo2):
pol3.adiciona(coef1 + coef2)
pol3.adiciona(expo1)
paux1.adiciona(expo1)
paux1.adiciona(coef1)
paux2.adiciona(coef2)
paux2.adiciona(expo2)
elif (expo1 > expo2):
pol3.adiciona(coef1)
pol3.adiciona(expo1)
paux1.adiciona(expo1)
paux1.adiciona(coef1)
pol2.adiciona(coef2)
pol2.adiciona(expo2)
else:
pol3.adiciona(coef2)
pol3.adiciona(expo2)
pol1.adiciona(coef1)
pol1.adiciona(expo1)
paux2.adiciona(expo2)
paux2.adiciona(coef2)
#se copia el polinomio 1 cuando tiene mas terminos
while (not pol1.vacio()):
expo1 = pol1.elimina()
coef1 = pol1.elimina()
45
pol3.adiciona(coef1)
pol3.adiciona(expo1)
paux1.adiciona(expo1)
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

17. Dado dos Polinomios Pol1, Pol2 realizar la multiplicación de los

polinomios

Pol1 = 2X1 + 3X2

Pol2 = 4X2 + 2X3
------------------------------------------------------------------

Pol3 = 8X3 + 12X4 + 4X4 + 6X5

8 8 Tope 8
7 7 7 3
6 6 6 8
5 5 5 4
Tope 4 Tope 4 4 12
3 2 3 3 3 4
2 3 2 2 2 4
1 1 1 2 1 5
0 2 0 4 0 6
Pol1 Pol2 Pol3
Solución.

# Multiplicar dos polinomiios

def multiplica_polinomio(self,pol1,pol2,pol3):
paux1 = Pilas()
paux2 = Pilas()
while (not pol1.vacio()):
expo1 = pol1.elimina()
coef1 = pol1.elimina()
paux1.adiciona(expo1)
paux1.adiciona(coef1)
while (not pol2.vacio()):
expo2 = pol2.elimina()
coef2 = pol2.elimina() 46
pol3.adiciona(coef1 * coef2)
pol3.adiciona(expo1 + expo2)
paux2.adiciona(expo2)
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

47
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Finalmente, al terminar los programas el diseño del formulario principal de la pila

será la siguiente.

from PilasE import Pilas

def menuPrin():
pil=Pilas()
pil2=Pilas()
Pil3=Pilas()
while True:
print("\nMenu")
print("1. Crear")
print("2. Adicionar")
print("3. Adicionar Aleatoriamente P1")
print("4. Adicionar Aleatoriamente P2")
print("5. Eiminar")
print("6. Listar")
print("7. Cuenta Digitos de Longitud 3")
print("8. Cuenta Repetidos")
print("9. Elimina Pares")
print("10. Elimina Repetidos")
print("11. Union")
print("12. Interseccion")
print("13. Sumar Pilas")
print("14. Elemento Mayor")
print("15. Intercambia Primero con Ultimo Elemento")
print("16. Elimina un Elemento X de la Pila")
print("17. Ordena una Pila")
print("18. inserta un elemento x en Pila ordenada")
print("19. Evalua polinomio")
print("20. Suma Polinomio")
print("21. Multiplica Polinomio")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
pil=Pilas()
pil2=Pilas()
pil3=Pilas()

elif opcion=="2":
e=int(input("Ingrese dato"))
pil.adiciona(e)
elif opcion=="3":
pil.adicionaAleatorio()
elif opcion=="4":
pil2.adicionaAleatorio()
elif opcion=="5":
e=pil.elimina()
elif opcion=="6":
s=pil.listar()
print("datos Pila 1",s)

48
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="7":
pil.cuenta3Digitos()
elif opcion=="8":
pil.cuentaRep()
elif opcion=="9":
pil.eliminaPares()
elif opcion=="10":
pil.eliminaRepetido()
elif opcion=="11":
pil3=Pilas()
pil.union(pil,pil2,pil3)
s=pil.listar()
print("pila 1=",s)
s=pil2.listar()
print("pila 2=",s)
s=pil3.listar()
print("pila 3=",s)
elif opcion=="12":
pil3=Pilas()
pil.intersecta(pil,pil2,pil3)
s=pil.listar()
print("pila 1=",s)
s=pil2.listar()
print("pila 2=",s)
s=pil3.listar()
print("pila 3=",s)
elif opcion=="13":
pil3=Pilas()
pil.suma_pilas(pil,pil2,pil3)
s=pil.listar()
print("pila 1=",s)
s=pil2.listar()
print("pila 2=",s)
s=pil3.listar()
print("pila 3=",s)
elif opcion=="14":
m=pil.elemento_mayor(pil)
print("Elemento Mayor:",m)
elif opcion=="15":
pil.intercambia_ultimo_primero()
elif opcion=="16":
x=int(input("Dato a eliminar:"))
pil.elimina_elemento(x)
elif opcion=="17":
pil.ordena_pila(pil)
elif opcion=="18":
x=int(input("Dato a insrtar:"))
pil.insertar_elemento(x)
elif opcion=="19":
x=int(input("Punto a Evaluar:"))
ev=pil.evalua_polinomio(pil,x)
print("La evaluacion es:",ev)

49
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="20":
pil3=Pilas()
pil.suma_polinomio(pil,pil2,pil3)
s=pil.listar()
print("pila 1=",s)
s=pil2.listar()
print("pila 2=",s)
s=pil3.listar()
print("pila 3=",s)
elif opcion=="21":
pil3=Pilas()
pil.multiplica_polinomio(pil,pil2,pil3)
s=pil.listar()
print("pila 1=",s)
s=pil2.listar()
print("pila 2=",s)
s=pil3.listar()
print("pila 3=",s)
elif opcion=="*":
break
else:
print("opcion no valida")
menuPrin()

3.6 Pila de caracteres

Una pila de caracteres, contiene elementos letras (caracteres), la implementación

de las operaciones básicas se detalla en laclase Pilas_Char.

class Pilas (object):

#variables globales
P=[]
tope=0
#constructor, que inicializa los atributos
# iniciliaza objetos
# self (python) = this (java)
def __init__(self):
self.P=[]
self.tope=0
#verificamos si la pila esta vacio
def vacio(self):
if self.tope==0:
return True
else:
return False

50
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

51
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#adiciona un elemento a la pila

def adiciona(self,e):
self.P.append(e)
self.tope=self.tope+1

#elimina un elemento de la pila

def elimina(self):
e=-1
if not(self.vacio()):
self.tope=self.tope-1
e=self.P.pop()
else:
print("pila vacia")

return e

# restaura datos
def restaura(self,PA):
while(not(PA.vacio())):
e=PA.elimina()
self.adiciona(e)
#lista datos de la pila
def listar(self):
s=""
PA=Pilas()
while(not self.vacio()):
e=self.elimina()
s= s+ " "+ str(e)
PA.adiciona(e)
self.restaura(PA)
return s

#funcion para copiar de una pìla a otra

def copia(self,pc):
paux1 = Pilas()
paux2 = Pilas()
paux3 = Pilas()
while (not self.vacio()):
e = pc.elimina()
paux1.adiciona(e)
paux2.adiciona(e)
pc.restaura(paux1);
paux3.restaura(paux2);
return paux3;

# funcion para contar numero de elementos en un pila

def cuentaElementos(self):
cuenta = 0
paux1 = Pilas()
while (not self.vacio()):
paux1.adiciona(self.elimina())
cuenta=cuenta+1
self.restaura(paux1)
return cuenta

52
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

3.6.1. Ejemplos de pila de caracteres

1. Programa para verificar si una palabra es PALINDROME, una palabra se
considera palindrome si leído de izquierda a derecha y de derecha a izquierda
es la misma palabra. Por ejemplo si la palabra=”oso” es palindrome.

#Verifica si es palindrome
def palindrome(self):
sw = False
B = Pilas()
pa = Pilas()
palabra = input("Ingrese palabra a verificar: ")
for e in palabra:
self.adiciona(e)

B = self.copia(self)
while not self.vacio():
pa.adiciona(self.elimina())
con=0
while not B.vacio():
e = B.elimina()
e1 = pa.elimina()
self.adiciona(e1)
if e == e1:
con=con+1
cuenta=self.cuentaElementos()
if cuenta==con:
sw=True
self.restaura(pa)
return sw

3.7. Aplicación de pilas para administrar libros

Almacenar los datos de un libro (código, titulo, autor, editorial, isbn, año de
edición, cantidad de ejemplares, costo del libro), las operaciones a
implementar son las siguientes:

 Crear pilas de libros

 Adicionar un libro
 Eliminar un libro
 Eliminar por un año determinado
 Listar por autor
 Lista por una letra del título del libro

53
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución

Para dar solución primero se elabora el TDA correspondiente, el cual se muestra en

la figura 3.3

Figura 3.3 TDA de implemetación de Libros

54
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Primero se implementará la clase Libros.

class Libro:
def __init__(self, codigo, titulo, autor, editorial, isbn,
a_edicion, cantidad_ejem, costo):
self.codigo = codigo
self.titulo = titulo
self.autor = autor
self.editorial = editorial
self.isbn = isbn
self.a_edicion = a_edicion
self.cantidad_ejem = cantidad_ejem
self.costo = costo
# Getters
def get_codigo(self):
return self.codigo

def get_titulo(self):
return self.titulo

def get_autor(self):
return self.autor

def get_editorial(self):
return self.editorial

def get_isbn(self):
return self.isbn

def get_a_edicion(self):
return self.a_edicion

def get_cantidad_ejem(self):
return self.cantidad_ejem

def get_costo(self):
return self.costo
# Setters
def set_codigo(self, codigo):
self.codigo = codigo

def set_titulo(self, titulo):

self.titulo = titulo

def set_autor(self, autor):

self.autor = autor

def set_editorial(self, editorial):

self.editorial = editorial

55
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

def set_isbn(self, isbn):

self.isbn = isbn

def set_a_edicion(self, a_edicion):

self.a_edicion = a_edicion

def set_cantidad_ejem(self, cantidad_ejem):

self.cantidad_ejem = cantidad_ejem

def set_costo(self, costo):

self.costo = costo
def __str__(self):
return self.codigo +"\t"+ self.titulo +"\t"+
self.autor+"\t"+self.editorial+"\t"+self.isbn+"\t"+str(self.a_edic
ion)+"\t"+str(self.cantidad_ejem)+"\t"+str(self.costo)+"\n"

Una vez implementado la clase Libros, a continuación se implementará la clase

Pila_libros, con todas las operaciones necesarias.

class Biblioteca (object):

#variables globales
P=[]
tope=0
#constructor, que inicializa los atributos
# iniciliaza objetos
# self (python) = this (java)
def __init__(self):
self.P=[]
self.tope=0

#verificamos si la pila esta vacio

def vacio(self):
if self.tope==0:
return True
else:
return False
#adiciona un elemento a la pila
def adiciona(self,e):
self.P.append(e)
self.tope=self.tope+1

#elimina un elemento de la pila

def elimina(self):
e=-1
if not(self.vacio()):
self.tope=self.tope-1
e=self.P.pop()
else:
print("pila vacia")
return e

56
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#elimina un elemento de la pila

#por el año de edicion
def elimina_an(self,an):
s=""
PA=Biblioteca()
while(not self.vacio()):
lib=self.elimina()
a_ed=lib.get_a_edicion()
if(a_ed!=an):
PA.adiciona(lib)
self.restaura(PA)
# Lista Libros por autor
def listar_autor(self,autor):
s=""
PA=Biblioteca()
autor=autor.upper()
while(not self.vacio()):
lib=self.elimina()
PA.adiciona(lib)
aut=lib.get_autor().upper()
if(autor==aut):
s= s+ " "+ str(lib)
self.restaura(PA)
return s
#Lista por una letra o letras del título del libro
def listar_titulo(self,titBus):
s=""
PA=Biblioteca()
titBus=titBus.upper()
while(not self.vacio()):
lib=self.elimina()
PA.adiciona(lib)
titulo=lib.get_titulo().upper()
subcadena = titulo[0:len(titBus)]
if(subcadena==titBus):
s= s+ " "+ str(lib)
self.restaura(PA)
return s
# restaura datos
def restaura(self,PA):
while(not(PA.vacio())):
e=PA.elimina()
self.adiciona(e)
#lista datos de la pila
def listar(self):
s=""
PA=Biblioteca()
while(not self.vacio()):
e=self.elimina()
s= s+ " "+ str(e)
PA.adiciona(e)
self.restaura(PA)
return s

57
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Para integrar todo los métodos que se ha desarrollado, se diseñara un menu con
el nombre de MenuPrin, en donde se implemetara todo las acciones que sean
necesarias.
from Libros import Biblioteca
from Libros import Libro

def menuPrin():
lib = Biblioteca()
while True:
print("\nMenu Libros")
print("1. Crear")
print("2. Adicionar")
print("3. Eiminar")
print("4. Eiminar por año")
print("5. Listar")
print("6. Buscar por autor")
print("7. Buscar por titulo por iniciales")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
lib=Biblioteca()

elif opcion=="2":
print("Ingrese Datos del Libro.")
cod=input("Codigo:")
titulo=input("Titulo:")
autor=input("Autor:")
edit=input("Editorial:")
isbn=input("ISBN:")
aed=input("Año de Edicion:")
cant_ejem=input("Nro. de Ejemplares:")
costo=input("Precio:")
libro =
Libro(cod,titulo,autor,edit,isbn,aed,cant_ejem,costo)
lib.adiciona(libro)
elif opcion=="3":
le=lib.elimina()
elif opcion=="3":
an=input("Ingrese año del libro a eliminar:")
le=lib.elimina_an(an)

elif opcion=="5":
s=lib.listar()
print(s)
elif opcion=="6":
aut=input("Ingrese Autor a buscar")
s=lib.listar_autor(aut)
print("LIBROS ENCONTRADOS POR AUTOR")
print(s)

58
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="7":
tit = input("Iniciales del Titulode libro a Buscar")
s=lib.listar_titulo(tit)
print("LIBROS ENCONTRADOS POR TITULO")
print(s)
elif opcion=="*":
break
else:
print("opcion no valida")

menuPrin()

3.8. Multipilas o pilas multiples.

Para represetar la estructura multipila, se lo realizará mediante un vector de pilas.

9 9 9
8 8 8
7 7 7
Tope 6 6 6
PM = 5 5 5 ….. …… 5
4 7 Tope 4 4
3 9 3 6 Tope 3
2 2 2 5 2 3
1 3 1 4 1 1
0 1 0 7 0 6
P1 P2 PN
0 1 …. …. N

El TDA de la estructura pila multiple o multipila se muestra en la figura 4.4

59
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Figura 4.4 TDA de una estructura pila multiple

Una vez definido el TDA de la multiple a continuación se implementa la Clase

Pilas_multiples con sus respectivos métodos.

class PilasMultiples(object):
# Lista de listas para almacenar las pilas
def __init__(self, n):
self.n = n
self.PM = [[] for _ in range(n)]
# Verifica si la pila np está vacía
def vacio(self, np):
return len(self.PM[np]) == 0
# Añade un elemento a la pila np
def adiciona(self, np, e):
self.PM[np].append(e)
# Elimina y devuelve el elemento superior de la pila np
def elimina(self, np):
if not self.vacio(np):
e=self.PM[np].pop()
return e
#Lista datos de la n- esima pila
def listar_pila(self, np):
return self.PM[np]
#Listar todas las pilas
def lista_todo(self):
print("Mostrando todas las pilas")
print(self.PM)

60
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Una vez implementado la clase Pilas_multiples con las operaciones básicas, para
integrar estas operaciones, se desarrolla el siguiente programa.

# Menu Principal

from PilasMultiples import PilasMultiples

def menuPrin():

while True:
print("\nMenu")
print("1. Crear")
print("2. Adicionar")
print("3. Eiminar")
print("4. Listar pila i")
print("5. Listar todas las pilas")

print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
np = int(input("Cuantas pilas se creara:"))
pilm=PilasMultiples(np)
pilm2=PilasMultiples(np)
pilm3=PilasMultiples(np)

elif opcion=="2":
e=int(input("Ingrese dato:"))
np=int(input("En que pila se inserta:"))
pilm.adiciona(np,e)
elif opcion=="3":
np=int(input("Numero de pila:"))
e=pilm.elimina(np)
elif opcion=="4":
np=int(input("Numero de pila a listar:"))
s=pilm.listar_pila(np)
print("datos Pila: ",np,"Datos:",s)
elif opcion=="5":
s=pilm.lista_todo()
elif opcion=="*":
break
else:
print("opcion no valida")

menuPrin()

61
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

3.8.1. Ejemplos de multipilas.

1. Llenar Los datos de la pilas de forma aleatoria.

#llena datos en la pila i

def llena_datos(self,np):
n=int(input("Cantidad de elementos:"))
for i in range(1,n+1):
e=random.randint(1,10)
self.adiciona(np,e)

2. Dada una Multipila , eliminar los pares de la pila 1 y llevar a la pila 2, los
primos al pila 3 y en la pila 4 debe estar el resto de los elementos.

5
4
#funcion que verifica si un numero es primo o no
2
def verifica_primo(self,n): 5
cont = 0 3 4 2
op = 0 1 2 3 1
sw = False P1 P2 P3 P4 P5
Solución.for i in range (1,n+1):
op = n % i;
if (op == 0):
cont=cont+1;
if (cont == 2):
sw = True
return sw

# Eliminar los pares de la pila 1 y llevar a la pila 2, los primos

al pila 3
# y en la pila 4 debe estar el resto de los elementos
def eliminar_pares_primos(self):
while (not self.vacio(0)):
e = self.elimina(0)
self.adiciona(4, e)
if (e % 2 == 0):
self.adiciona(1, e)
elif (self.verifica_primo(e) == True):
self.adiciona(2, e)
else:
self.adiciona(3, e)
while (not self.vacio(4)):
e = self.elimina(4)
self.adiciona(0, e)

62
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La llamada al programa,será mediante el siguiente menu

from PilasMultiples import PilasMultiples

def menuPrin():
while True:
print("\nMenu")
print("1. Crear")
print("2. Adicionar")
print("3. Adicionar aleatorio")
print("4. Eiminar")
print("5. Listar pila i")
print("6. Listar todas las pilas")
print("7. Elimina pares,primos")

print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
np = int(input("Cuantas pilas se creara:"))
pilm=PilasMultiples(np)
pilm2=PilasMultiples(np)
pilm3=PilasMultiples(np)

elif opcion=="2":
e=int(input("Ingrese dato:"))
np=int(input("En que pila se inserta:"))
pilm.adiciona(np,e)
elif opcion=="3":
np=int(input("Numero de pila"))
pilm.llena_datos(np)
elif opcion=="4":
np=int(input("Numero de pila:"))
e=pilm.elimina(np)
elif opcion=="5":
np=int(input("Numero de pila a listar:"))
s=pilm.listar_pila(np)
print("datos Pila: ",np,"Datos:",s)
elif opcion=="6":
s=pilm.lista_todo()
elif opcion=="7":
s=pilm.eliminar_pares_primos()
elif opcion=="*":
break
else:
print("opcion no valida")
menuPrin()

63
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

“La inteligencia consiste no solo en el conocimiento, sino también en la destreza

de aplicar los conocimientos en la práctica.”
Aristóteles

5.1. Definición

Una cola constituye una estructura de dato lineal en la que los nuevos elementos
se introducen por un extremo y los ya existentes se eliminan por el otro extremo.Es
importante señalar que los componentes de la cola se eliminan en mismo orden en
el cual se insertaron. Es decir el primer elemento que se introduce en la estructura
será el que se eliminará en primer lugar. Debido a esta característica las colas
también reciben el nombre de estructuras FIFO ( First-Input First-Output: que
significa primero en entrar ,primero en salir) (Cairo&Guardati, 2006)

Una cola tiene la siguiente representación gráfica que muestra a continuación.

Tamaño de la Cola MAX=20

Principio Final

Cola 3 5 7 6 ….

0 1 2 3 4 … 17 18 19

5.2 Estructura cola

Para crear la estructura Cola debe existir el tamaño máximo de la cola, en este
caso denotaremos con la variable MAX, el cual toma un valor determinado
(MAX=20).

 Al momento de crear la cola el Principio y el Final debe iniciar en cero.

 Los elementos (datos) se adiciona por el final, luego se incrementa en
1.
 Los elementos se eliminan por el principio, luego se incrementa en 1.
 Si el Principio = Final entonces la cola está vacía.
 Si el Final=MAX entonces la Cola está llena.

64
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

1.3. Tipo de Dato Abstracto (T.D.A.) de una cola.

El TDA de la estructura de dato cola se muestra en la figura 5.1

Nombre Cola
int Max=20
Atributos int C[Max]
int fin, principio
int fin_aux
Void Crear()
Operaciones Boolean Vacio()
Boolean Lleno()
Void Adicionar(int e)
Int Eliminar()
String Mostrar()
Void Restaurar()
Cola Copiar()
Int Contar_elementos()

Figura. 5.1 Estructura base de la Cola

1.4. Implementación de las operaciones básicas de una estructura cola.

Para operar las colas se deben realizar operaciones básicas que se detalla a
continuación.
 Crear () Crea una pila o inicializa el tope de la pila en cero.
 Vacío() Verifica si una pila está vacío o no
 Lleno() Verifica si una pila está lleno
 Adiciona() Adiciona un elemento a la cola
 Elimina() Elimina un elemento de la cola
 Mostrar() Nuestra los elementos de la cola
 Restaura() Restaura elementos de la cola en otra cola
 Copia() Copia una cola a otra cola.
 Contar_elementos() Cuenta la cantidad de elementos de la cola

5.5 Implementación de la estructura cola en JAVA.

Para realizar la implementación de la cola se empleara el lenguaje Java con IDE

NetBeans.

Considerando el TDA de la figura 5.1 se implementa la clase Cola_Simple, a

continuación.

65
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

class Colas (object):

#variables globales
C=[]
#constructor, que inicializa los atributos

def ___init__(self):
self.C=[]

#verificamos si la cila esta vacio

def vacio(self):
if len(self.C) == 0:
return True
else:
return False

#adiciona un elemento a la cola

def adiciona(self,e):
self.C.append(e)

#elimina un elemento de la cola

def elimina(self):
e=-1
if not(self.vacio()):
e=self.C.pop(0)
else:
print("Cola vacia")
return e

# restaura datos
def restaura(self,CA):
while(not(CA.vacio())):
e=CA.elimina()
self.adiciona(e)

#lista datos de la cola

def listar(self):
s=""
CA=Colas()
while(not self.vacio()):
e=self.elimina()
s= s+ " "+ str(e)
CA.adiciona(e)
self.restaura(CA)
return s

66
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Copia una cola

def copia(self,col):
col1 = Colas()
col2 = Colas()
while (not col.vacio()):
e = col.elimina()
col1.adiciona(e)
col2.adiciona(e)
col.restaura(col2)
return col1

# Metodo para contar elementos de la cola

def cuenta_elementos(self):
contador = 0
col_aux = Colas()
while (not self.vacio()):
e = self.elimina()
col_aux.adiciona(e)
contador=contador+1
self.restaura(col_aux)
return contador

5.6 Ejemplos de cola simple

1. Dada una cola C eliminar los elementos pares de la cola.

Principio Final

Cola 3 5 9 8 5 10 14

0 1 3 2 3 4 5
X X X

La cola debería de quedar de la siguiente forma.

Principio Final

Cola 3 5 9 5

0 1 2 3 4 5

67
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución
#Metodo para eliminar de una cola los elementos Pares
def elimina_pares(self):
col_aux = Colas()
while(not self.vacio()):
e=self.elimina()
if(e%2!=0):
col_aux.adiciona(e)
self.restaura(col_aux)

2. Dada una cola C, realizar la rotación de elementos r-veces.

Principio Final

Cola 1 2 3 4
0 1 2 3 4 5

Número de rotación 3 veces.

Principio Final

Cola 2 3 4 1
0 1 2 3 4 5

Principio Final

Cola 3 4 1 2
0 1 2 3 4 5

Principio Final

Cola 4 1 2 3
0 1 2 3 4 5

Solución.

68
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Rota elementos r veces en una cola

def rotar(self, r):
colaaux = Colas()
for i in range(r):
e1 = self.elimina()
while not self.vacio():
e = self.elimina()
colaaux.adiciona(e)
colaaux.adiciona(e1)
s = colaaux.listar()
print("Rotacion ", i, ":", s)
self.restaura(colaaux)

Para integrar todo los programas se tiene el siguiente menu.

from Colas import Colas

def menuPrin():
col=Colas()
while True:
print("\nMenu Colas")
print("1. Crear")
print("2. Adicionar")
print("3. Genera Aleatorio cola ")
print("4. Eiminar")
print("5. Listar Cola 1")
print("6. Eliminar pares ")
print("7. Rotar ")
print("8. Contar elementos ")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
col=Colas()
elif opcion=="2":
e=int(input("Ingrese dato"))
col.adiciona(e)
elif opcion=="3":
col.adicionaAleatorio()
elif opcion=="4":
e=col.elimina()
elif opcion=="5":
s=col.listar()
print("datos Cola :",s)
elif opcion=="6":
col.elimina_pares()
s=col.listar()
s=print("cola:",s)

69
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="7":
n=int(input("Cantidad de rotaciones:"))
col.rotar(n)

elif opcion=="8":
cont=col.cuenta_elementos()
print("cuenta:",cont)
elif opcion=="*":
break
else:
print("opcion no valida")
menuPrin()

5.7. Colas circulares.

Uno de los problemas de la cola simple, es cuando se elimina un dato, ya no es

posible reutilizar las casillas del vector, por lo que a largo plazo existe un desperdicio
de memoria; La solución a este problema de las COLAS SIMPLES, es utilizar
COLAS CIRCULARES, con esto es posible volver a reutilizar los espacios vacíos
del vector.

5.7.1 Definición.

Una cola circular (queue en inglés) es una estructura de datos que almacena datos
y acceso a los datos es bajo la filosofía FIFO (del inglés First Input First Ouput
(PEPS) primero en entrar, primero en salir) que permite almacenar y recuperar
datos, en concreto, disponemos de un vector de estructuras donde almacenar los
datos. Sea m el número de estructuras. La cola circular no puede almacenar más
de N elementos y los datos los numeramos como siempre, por índices que varían
entre 0 y N-1 tal como se muestra en la figura 5.2

70
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Principio Final

0 1 2 3 4 5 … N-1
10 20 30 40 50
Figura 5.2 representacion de la cola circular

Figura 5.2 Representación de una Cola Circular

5.7.2. Estructura cola circular.

Para crear la estructura Cola Circular debe existir el tamaño máximo de la cola, en
este caso denotaremos con la variable MAX, el cual toma un valor determinado
(MAX=20).

También se debe considerar los siguientes aspectos:

 Al momento de crear la cola el Principio y el Final debe iniciar en cero.

 Los elementos (datos) se adiciona por el final, luego se incrementa en 1,
de la siguiente forma final = (final+1 ) mod MAX
 Los elementos se eliminan por el principio, luego se incrementa en 1, de la
siguiente manera principio = (principio + 1) mod MAX
 Si el Principio = Final entonces la cola está vacía.
 Si el (Final +1 ) mod MAX= Principio entonces la Cola está llena.

El TDA de la cola circular se muestra en la figura 5.3

Nombre Cola_circular
int Max=20
Atributos int C[Max]
int principio, fin
int fin_aux
+void Crear()
Operaciones +boolean Vacio()
+boolean Lleno()
+void Adicionar(int e)
+int Eliminar()
+String Mostrar()

71
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

+void Restaurar()
+void Copiar()

Figura. 5.3 T.D.A. de la Estructura Cola Circular

5.7.3 Operaciones básicas de cola circular.

Para operar las colas circulares se deben realizar operaciones básicas que se
detalla a continuación.

 Crear () Crea una cola o inicializa el tope de la pila en cero.

 Vacío() Verifica si una cola está vacío o no
 Lleno() Verifica si una cola está lleno
 Adiciona() Adiciona un elemento a la cola
 Elimina() Elimina un elemento de la cola
 Mostrar() Nuestra los elementos de la cola
 Restaura() Restaura elementos de la cola en otra cola
 Copia() Copia una cola a otra cola.

5.7.4 Implementación de la cola circular en Python.

Para realizar la implementación de la cola circular se empleará el lenguaje Python

En este caso se crea la clase con el nombre Colas_Circulares.

import random
from PilasE import Pilas
class ColaCircular:
#Cosntructor para crear la cola circular
def __init__(self, n):
self.MAX = n
self.C = [None] * n
self.prin = 0
self.fin = 0
#verifica si una cola esta vacia
def vacio(self):
if self.prin == self.fin:
return True
else:
return False;
#verifica si una cola esta llena

def lleno(self):
if ((self.fin+1)% self.MAX == self.prin):
return True
else:
return False
72
#Adiciona un elemento en la cola
def adicionar(self, e):
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Elimina un elemento de la cola

def eliminar(self):
e=-1
if not self.vacio():
e = self.C[self.prin]
self.C[self.prin] = None
self.prin = (self.prin + 1) % self.MAX
else:
print("La cola está vacía")
return e
# Restaura Elemento de una Cola auxiliar, ala cola Orginal
def restaura(self,CCA):
while (not CCA.vacio()):
e=CCA.eliminar()
self.adicionar(e)
#lista los datos de cola
def lista(self):
s = "";
aux = self.fin
while (aux!=self.prin):
e = self.eliminar()
self.adicionar(e)
s = s + " " + str(e)
return s

#cuenta elementos de la cola

def cuenta_elementos(self):
contador = 0;
aux = self.fin
while aux!=self.prin:
e = self.eliminar()
self.adicionar(e)
contador=+contador+1
return contador

5.7.5 Ejemplos de colas circulares.

1. Dada una cola circular buscar el elemento menor en la cola

Pricipio El elemento menor de la lista circular

será:

Emenor = 5

Final

73
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución.

#busca un elemento menor en luga lista circular

#sin utilizar cola auxiliar

def buscaMenor(self,CC):
emenor = 0
e = 0
aux = 0
if (not CC.vacio()):
aux = CC.fin
emenor = CC.eliminar()
CC.adicionar(emenor)
while (CC.prin != aux):
e = CC.eliminar()
CC.adicionar(e)
if (emenor > e):
emenor = e;
return emenor

2. Eliminar un elemento X de la cola circular

Principio El elemento a eliminar X=5 y la cola circular

quedara de la siguiente manera.

Fin

Fin

Principio

Solución.

#elimina un elemento X de la cola Circular

def eliminaX(self,CC,x):
if (not CC.vacio()):
aux = CC.fin
while (CC.prin != aux):
e1 = CC.eliminar()
if (e1 != x):
CC.adicionar(e1)

74
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

3. Dada una cola circular ordenar sus elementos de forma ascendente

Principio

Fin
Principio

Fin

Solución.
#busca un elemento menor en luga lista circular
#sin utilizar cola auxiliar

def buscaMenor(self,CC):
emenor = 0
e = 0
aux = 0
if (not CC.vacio()):
aux = CC.fin
emenor = CC.eliminar()
CC.adicionar(emenor)
while (CC.prin != aux):
e = CC.eliminar()
CC.adicionar(e)
if (emenor > e):
emenor = e;
return emenor
#elimina un elemento X la Primera ocurrencia
#de la cola Circular
def elimina1X(self,CC,x):
CCA = ColaCircular(self.MAX)
if (not CC.vacio()):
aux = CC.fin
while (CC.prin != aux):
e1 = CC.eliminar()
if (e1 != x):
CCA.adicionar(e1)
else:
break
while (not CCA.vacio()):
e=CCA.eliminar()
CC.adicionar(e)

#Ordenar una los elementos de una cola circular 75

def ordenaCola(self,CC):
CCA = ColaCircular(self.MAX)
em = 0
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

4. Dada una cola circular eliminar los elementos repetidos.

Principio Fin

Fin Principio

Solución.
#elimina un elemento X de la cola Circular
def eliminaX(self,CC,x):
if (not CC.vacio()):
aux = CC.fin
while (CC.prin != aux):
e1 = CC.eliminar()
if (e1 != x):
CC.adicionar(e1)
#elimina elementos repetidos
def elimina_repetidos(self,CC):
s=""
CCA = ColaCircular(self.MAX)
while (not CC.vacio()):
e = CC.eliminar()
CC.eliminaX(CC, e)
CCA.adicionar(e)

while (not CCA.vacio()):

e=CCA.eliminar()
CC.adicionar(e)

5. Dada una colar circular rotar r veces sus elementos.

Ejemplo número de rotación r=2
Rotación 1 Rotación 2

76
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Solución.

#rota elementos de una cola circular r veces

def rota(self,CC,nr):
s=""
for i in range (1,nr+1):
e = CC.eliminar()
CC.adicionar(e)
s = CC.lista()
print("Rotacion:",i ," ",s , "\n")

6. Dada una cola circular ordenada, Insertar un elemento X en el

correspondiente lugar de la cola circular .
Ejemplo. Elemento X a insertar 7

Solución.

#insertar un elemento en el lugar que corresponde en una cola circular

ordenada
def inserta_elemento(self,CC, e):
sw = False
aux = CC.prin;
aux = (aux + 1) % CC.MAX
while (((CC.fin + 1) % CC.MAX != aux) and (sw == False)):
e1 = CC.eliminar()
if (e > e1):
if ((CC.fin + 1) % CC.MAX == aux):
CC.adicionar(e1)
CC.adicionar(e)
else:
CC.adicionar(e1)
else:
CC.adicionar(e)
CC.adicionar(e1)
sw = True
while ((CC.fin + 1) % CC.MAX != aux):
e1 = CC.eliminar()
CC.adicionar(e1)

77
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

7. Dada una lista circular suma los elementos

Por ejemplo.

La suma de los elementos será:

S=3+6+8+10 = 27

Solución.

#sumar los elementos de colar circular

def sumaElementos(self,CC):
suma = 0;
aux = CC.fin
while (CC.prin != aux):
e1 = CC.eliminar()
suma = suma + e1
CC.adicionar(e1)

return suma

8. Dada una cola circular invertir sus elementos.

Ejemplo

Solución.
#invertir los elementos de la cola circular
def invertir_cola_cir(self,CC):
PA=Pilas()
while (not CC.vacio()):
e = CC.eliminar()
PA.adiciona(e)
while (not PA.vacio()):
CC.adicionar(PA.elimina())

78
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Finalmente todos los programas se integran mediante el siguiente menu.

from Colas import Colas

def menuPrin():
col=Colas()
while True:
print("\nMenu Colas")
print("1. Crear")
print("2. Adicionar")
print("3. Genera Aleatorio cola ")
print("4. Eiminar")
print("5. Listar Cola 1")
print("6. Eliminar pares ")
print("7. Rotar ")
print("8. Contar elementos ")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
col=Colas()
elif opcion=="2":
e=int(input("Ingrese dato"))
col.adiciona(e)
elif opcion=="3":
col.adicionaAleatorio()
elif opcion=="4":
e=col.elimina()
elif opcion=="5":
s=col.listar()
print("datos Cola :",s)
elif opcion=="6":
col.elimina_pares()
s=col.listar()
s=print("cola:",s)
elif opcion=="7":
n=int(input("Cantidad de rotaciones:"))
col.rotar(n)

elif opcion=="8":
cont=col.cuenta_elementos()
print("cuenta:",cont)
elif opcion=="*":
break
else:
print("opcion no valida")

menuPrin()

79
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

“Nuestra mayor debilidad reside en rendirnos. La forma más segura de tener

éxito es intentarlo una vez más”.
Thomas A. Edison

6.1 Definición.

La recursividad es una técnica de programación, un programa recursivo consiste en

que el programa se llama asi mismo. Se utiliza para resolver determinados
problemas sin utilizar estructuras de control de repetición.

La recursividad (recursión) es aquella propiedad que posee una función por la cual
dicha función puede llamarse a sí misma. Se puede utilizar la recursividad como
una alternativa a la iteración. Una solución recursiva es normalmente menos
eficiente en términos de tiempo de computadora que una solución iterativa debido
a las operaciones auxiliares que llevan consigo las llamadas suplementarias a las
funciones; sin embargo, en muchas circunstancias el uso de la recursión permite a
los programadores especificar soluciones naturales, sencillas, que serían, en caso
contrario, difíciles de resolver. Por esta causa, la recursión es una herramienta
poderosa e importante en la resolución de problemas y en la programación.
(Joyanes Aguilar, 2008)

Existen dos tipos de programas recursivos

 Funciones recursivas
 Procedimientos recursivos

6.1.1 Funciones recursivas.

Se dice que una función es recursiva cuando el cuerpo de la función utiliza a la

propia función. Dentro de una función recursiva tiene que existir tres partes:

80
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

 caso base: son casos simples, si la función es llamada con el caso base
la función simplemente devuelve un resultado
 caso recursivo: la función es llamada de forma recursiva hasta llegar al
caso base.
 Condición: Una función recursiva debe una condición y sea para llamar
al caso recursivo o al caso base.

La función recursiva tiene la siguiente estructura.

Tipo Nombre (lista de parámetros)

{
If(codición)
Return caso base;
Else
Return caso Recursivo
}

6.1.2. Ejemplos funciones recursivas

1. Calcular el factorial de un número N, el factorial se define de forma

general de la siguiente forma: N! = 1 * 2 * 3* 4 * 5 * ……. * (N-1)*N o
también se puede escribir como N! = N * (N-1) * (N-2)* ……….4 * 3 * 2 * 1.
Por definición el factorial de 0! Es 1
Ejemplo.
0! = 1 por definición
5! = 1 * 2 * 3 * 4 * 5 = 120 o
5! = 5 * 4 * 3 * 2 * 1 = 120

Solución.

El caso base del programa recursivo, esta dada por la definición del factorial, es
decir, cuando N=0 su factorial será 1

La formula recursiva se obtiene a partir de formula del factorial que se la define de

la siguiente forma:

N! = N * (N-1) * (N-2)* ……….4 * 3 * 2 * 1

Esta formula se puede escribir también de la siguiente forma.

N! = N * (N-1)!
(N-1)! = (N-1) * (N-2)!
(N-2)! = (N-2) * (N-3)!...

81
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Y en esto se observa que:

(N-1) ! = (N -1) * (N-2)!

Asi podemos ir generando sucesivamente esta operación es reiterativo,

y por lo tanto es recursivo

Por lo tanto la función recursiva será como sigue.

1 Si N=0

Factorial(N) =

N*Factorial(N-1) Si N>0

Ejecución de la función recursiva, por ejemplo el factorial de 6!

120
fase fase
Factorial(6) = 6 * Factorial (5) 1 Factorial(6) = 6* Factorial (5) = 6 * 120 = 720 2

24
Factorial(5) = 5* Factorial (4) Factorial(5) = 5* Factorial (4) = 5 * 24 = 120

6
Factorial(4) = 4* Factorial (3) Factorial(4) = 4* Factorial (3) = 4 * 6 = 24

2
Factorial(3) = 3* Factorial (2) Factorial(3) = 3* Factorial (2) = 3 * 2 = 6

1
Factorial(2) = 2* Factorial (1) Factorial(2) = 2* Factorial (1) = 2 * 1 = 2

1
Factorial(1) = 1* Factorial (0) Factorial(1) = 1* Factorial (0) = 1 * 1 = 1

Factorial(0) = 1 Factorial(0) = 1

Durante la ejecución de un programa recursivo realiza dos fases en la primera

fase, se llama a si mismo la función recursiva y en segunda fase evalua las llamadas
recursivas hasta llegar al caso base.

82
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

A continuación se tiene el programa recursivo.

class Recursividad (object):

#calcula el factorial de un numero

def factorial(self, N):
if N == 0:
return 1
else:
return N * self.factorial(N - 1)

2. Calcula la potencia de un número XY

Por ejemplo Z = 23 = 8 => Z=2*2*2=8

Solución.

Para dar solución partiremos de la siguiente definición.

Z= XY = X * X * X * X * ………… * X

Y – veces

Para encontrar el caso base, vemos la siguiente situación

Z=X0 = 1

Cual quier número elevado a la cero siempre es 1, por lo tanto cuando

Y=0, el resultado será 1

Para encontrar la formula recursiva partiremos del siguiente ejemplo.

Z=XY = 23 = 2 * 22 = 8

Z=XY = 23 = 4 * 21 = 8

Z=XY = 23 = 8 * 20 = 8

83
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Observe que el exponente se va reduciendo hasta llegar al caso base.

1 Si Y=0

Potencia(X,Y) =

X*Potencia(X,Y-1) Si Y>0

La ejecución de la función recursiva, será como sigue, considere como ejemplo

Z = 24 = 16.

fase
Potencia(2,4)= 2 * Potencia (2,3) 1

Potencia(2,3)= 2* Potencia (2,2)

Potencia(2,2)= 2* Potencia (2,1)

Potencia(2,1)= 2* Potencia (2,0)

Potencia(2,0)= 1

8 Fase 2
Potencia(2,4)= 2 * Potencia (2,3) = 2 * 8 = 16
4

Potencia(2,3)= 2 * Potencia (2,2)= 2 * 4 = 8

2

Potencia(2,2)= 2 * Potencia (2,1)= 2 * 2 = 4

1

Potencia(2,1)= 2 * Potencia (2,0)= 2 * 1 = 2

84
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Potencia(2,0)= 1

A continuación se tiene el programa recursivo.

# calcula la potencia de x
def potencia(self, x, y):
if (y == 0):
return (1) 1
else:
return (x * self.potencia(x, y - 1))

3. Sumar dos número a, b de forma recursiva

Por ejemplo C=A+B

C= 8 + 3 = 11

Solución.

Para dar solución partiremos de la siguiente definición.

C = A + B = A +( 1 + 1 + 1+ 1 + ……..+1)

B – veces
C = 8 + 3 = 8 + ( 1 + 1 + 1) = 11

Para encontrar el caso base, vemos la siguiente situación

C=0+B=B
Cualquier número sumado con cero es el mismo mumero, dado que el
cero es el neutro aditivo

Para encontrar la formula recursiva partiremos del siguiente ejemplo.

C = 8 + 3 = 8 + ( 1 + 1 + 1) = 11

La base es A y se añade 1 B-veces, por lo tanto la función recursiva

será la siguiente.
b Si
a=0

sumaDosNúmeros(a,b) =

85
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

1 + sumaDosNumeros(a- Si a>0
1,b)

La ejecución de la función recursiva, será como sigue, considere como ejemplo

C = 5 + 3 = 5 + ( 1 + 1 + 1) = 11

sumaDosNumeros(5,3)= 1 + sumaDosNumeros(4,3) fase

1

sumaDosNumeros(4,3)= 1 + sumaDosNumeros(3,3)

sumaDosNumeros(3,3)= 1 + sumaDosNumeros(2,3)

sumaDosNumeros(2,3)= 1 + sumaDosNumeros (1,3)

sumaDosNumeros (1,3)= 1 + sumaDosNumeros(0,3)

sumaDosNumeros (0,3)= 3
7
Fase 2
sumaDosNumeros(5,3) = 1+ sumaDosNumeros(4,3)= 1 + 7 =8

6
sumaDosNumeros(4,3) = 1+ sumaDosNumeros(3,3)= 1 + 6 =7

5
sumaDosNumeros(3,3) = 1+ sumaDosNumeros(2,3)= 1 + 5 =6

4
sumaDosNumeros(2,3) = 1+ sumaDosNumeros(1,3)= 1 + 4 =5

3
sumaDosNumeros(1,3) = 1+ sumaDosNumeros(0,3)= 1 + 3 =4

sumaDosNumeros(0,3) = 3

A continuación se tiene el numero.

#suma dos numeros recursivamente

def sumaDosNumeros(self, a, b):
86
if (a == 0):
return b
else:
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

4. ultipliplicar dos números a,b recursivamente

Por ejemplo C=A*B
C= 8 * 3 = 24

Solución.

Para dar solución al problema utilizaremos la multiplicación medinate

sumas sucesivas

C = A * B = ( A + A + A+ A + ……..+A)

B – veces

C = 8 * 3 = ( 8 + 8 + 8) = 24

Para encontrar el caso base, vemos la siguiente situación

C=A*0=0
Cualquier número multiplicado por cero el resultado será cero.
Para encontrar la formula recursiva partiremos del siguiente ejemplo.

C = 8 * 3 = ( 8 + 8 + 8) = 24

La base es A y se repite B-veces, por lo tanto, la función recursiva será

la siguiente.

0 Si
b=0

multiplicaDosNumeros(a,b) =

a + multiplicaDosNumeros(a,b- Si
1) b>0

La ejecución de la función recursiva, será como sigue, considere como ejemplo

C = 8 * 3 = 24

87
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

fase
multiplicaDosNumeros(8,3)= 8 + multiplicaDosNumeros(8,2) 1

multiplicaDosNumeros (8,2) = 8 + multiplicaDosNumeros(8,1)

multiplicaDosNumeros (8,1) = 8 + multiplicaDosNumeros(8,0)

multiplicaDosNumeros(8,0)= 0

16 Fase
multiplicaDosNumeros(8,3) = 8 + multiplicaDosNumeros(8,2)= 8 + 16 =24 2

8
multiplicaDosNumeros(8,2) = 8 + multiplicaDosNumeros (8,1)= 8 + 8 =16

0
multiplicaDosNumeros(8,1) = 8 + multiplicaDosNumeros (8,0)= 8 + 0 =8

multiplicaDosNumeros(8,0) = 0

A continuación se tiene el programa recursivo.

# multiplica dos numeros recursivamente

def multiplicaDosNumeros(self, a, b):
if (b == 0):
return 0
else:
return (a + self.multiplicaDosNumeros(a, b - 1))

5. Divide dos números a,b recursivamente, considere solo la parte entera.

Por ejemplo C = ‖A / B‖
C= ‖13 / 3‖ = 4

Solución.

88
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Para dar solución al problema utilizaremos la división de dos números medianate

restas sucesivas

A B

13 - 3 10 Se cuenta el número de veces

10 - 3 7 que resta hasta antes que se
7 - 3 4 vuelva negativo el resultado.
4 - 3 1 En este caso la cantidad de
1 - 3 -2 restas es 4

Para encontrar el caso base, vemos la siguiente situación

C = 3 / 10 = 0

Cuando el divisor es mayor que el dividendo el resultado siempre será

cero.

Para encontrar la formula recursiva partiremos del ejemplo anterior,

donde se resta hasta que B sea mayor que A y la función recursiva será
como sigue:

0 Si a<b

divideDosNumeros(a,b) =

1 + divideDosNumeros(a-b,b) Si
a>=b

El programa de la función recursiva sera de la siguiente forma.

# divide dos numeros solo la parte enterea recursivamente

def divideDosNumeros(self,a,b):
if (a < b):
return (0)
else:
return (1 + self.divideDosNumeros(a - b, b))

89
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

6. Calcular el logaritmo de un número N, de cualquier base b donde b<=10 y

b >=1 (nota solo se debe calcular la parte entera)

Por ejemplo C = ‖ logbX ‖

C = ‖ log2 10 ‖ = 3

Solución.

Para dar solución al problema utilizaremos divisiones sucesivas

A B
10 2

(1) 5 2

(1) 2 2

(0) 1

Como se observa en el ejemplo el divisor es mayor al dividendo, y se cuenta

cuantas divisiones se ha realizado en este caso son 3 divisiones, por tanto el log 2
10 sera 3.

Para encontrar el caso base considere la siguiente situación.

‖ Log 75 ‖ = 0

En este ejemplo se observa que la base 7 es mayor al número 5 por lo tanto el

logaritmo siempre sera cero.

Para encontrar la formula recursiva se toma encuenra las divisiones sucesivas

hasta que el divisor sea mayor al dividendo y se contara la cantidad de veces que
se divide. Por lo tanto la función recursiva sera de la siguiente forma.

0 Si n <
b

Logaritmo(n,b) =

1 + logaritmo(n/b,b) Si n>=b

90
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación de la función recursiva sera como sigue.

# obtiene el logartirmo solo parte entera

def logaritmo(self, n, b):
if (n < b):
return (0)
else:
return (1 + self.logaritmo(n / b, b))

7. Obtener el módulo de dos números a, b

Por ejemplo C = A mod B
C = 10 mod 3

A B

10 3

(1) 3

C = 1 (residuo llamado también módulo)

Solución

Para dar solución al problema utilizaremos restas sucesivas.

A B

10 - 3 7 El módulo sera 1, que es la

7 - 3 4 ultima resta antes de que el
4 - 3 1 resultado sea negativo, es decir
1 - 3 -2 hasta a sea menor a b (a<b).

La función recursiva sera de la siguiente forma.

a Si a<b

91
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Mod(a,b) =

Mod(a-b,b) Si a>=b

La implemetación de la función recursiva se muestra a continuación.

# obtiene el modulo recursicamnete
def mod(self,a,b):
if (a < b):
return (a)
else:
return (self.mod(a - b, b))

8. Calcular el máximo común dividor de dos números X,Y de forma

recursiva
Por ejemplo C = mcd(X, Y)
C = mcd(18,6) = 6

Solución.

Para encontrar el máximo común divisor se utilizara el siguiente algorítmo.

X= 18 12 6

Y= 6

El algorítmo consiste en restar del mayor el menor, por ejemplo primero

observamos cual de los dos números es el mayor , en el ejemplo el mayor
es X=18 y restamos el menor Y=6 quedando como resultado 12,
nuevamente nos preguntamos cual es el mayor X=12 y volvemos a restar
Y=6, este proceso se sigue hasta que ambos números llegen al mismo
valor en este caso X=6 y Y=6, como los dos números son iguales el
mcd(18,6) es 6., por lo tanto termina el algorítmo.

Para encontrar el caso base sera cuando X sea igual a Y (X=Y) cuando
esto sucede el máximo común divisor es X o puede ser Y, por ejemplo
Mcd(18,18) = 18.

X Si x=y

Mcd(x,y) = Mcd(x-y,y) Si x>y

Mcd(x,y-x) Si x<y

92
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación de la función recursiva en el lenguaje es la siguiente.

#calcula el maximo comun divisor

def mcd(self, x, y):
if (x == y):
return (x)
else:
if (x > y):
return (self.mcd(x - y, y))
else:
return (self.mcd(x, y - x))

9. Convertir un número N de base 10 a su equivalente a binario

Por ejemplo
N= 25 convertir a la base 2
N= 25 en binario sera igual a 11001

Solución.

Para dar solución al problema se utilizar las divisiones sucesivas.

N B
25 2

(1) 12 2

(0) 6 2

(0) 3 2

(1) 1 2

(1) 0

La división termina cuando N es menor a B (N<B)

El resultado será los residuos (11001) de cada división leídos de abajo hacia
arriba, tal como se ve en ejemplo.

Para encontrar el caso base sera cuando (N<B), es decir, es cuando se deja de
dividir,por ejemplo si N=1 y B=2 el resultado sera 1, porque ( N<B => 1 < 3).

La función recursiva sera de la siguiente manera.

93
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

N Si n<b

=
Cbase(n,b)
n mod b + Cbase(n / b, b) * 10 Si n>=b

La implemetación de la función recursiva en el lenguaje es la siguiente.

# Convierte un numero decinmal N

# a cualquier base B
# donde B<10 y B>1
def cbase(self, n, b):
if (n < b):
return (n)
else:
return (n % b + self.cbase(n // b, b) * 10)
10. Generar la serie de fibonaci de forma recursiva.
La serie de fibonaci es la siguiente
S=0,1,1,2,3,5,8,13, ………………
Por ejemplo
Si N= 7 la serie será.
S = 0,1,1,2,3,5,8

Solución

La función recursiva sera de la siguiente manera

0 Si n=0

= 1 Si n=1
Fibonaci(n)
Fibonaci(n-1) + Fibonaci(n-2) Si n>1

La implemetación de la función recursiva en el lenguaje es la siguiente.

#genera la serie de fibinaci

def fibonaci(self,n):
if (n == 1 or n == 2):
return 1
else:
return self.fibonaci(n - 1) + self.fibonaci(n - 2)

11. Invertir un número N de forma recursiva

94
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Por ejemplo la inversa de un número N

Es la siguiente.
Si N=1234 la inversa será : NI=4321
Solución
Para invertir un número se debe descomponer el número en sus dígitos
de la siguiente forma.

NI = 0
N NI=NI*10 + R

1234 10 NI = 0 * 10 + 4 = 4

(4) 123 10 NI = 4 * 10 + 3 = 43

R (3) 12 10 NI = 43 * 10 + 2 = 432

R (2) 1 10 NI =432 * 10 + 1 = 4321

R (1) 0

La función recursiva sera de la siguiente manera

0 Si n=0

invertir(n) =
Invertir(n/10) + (n mod 10) * 10 (longitud (n) – 1)¨ Si n>1

La implemetación de la función recursiva en el lenguaje es la siguiente

# Invertir un numero
def invertir(self, n):
if (n == 0):
return (0)
else:
return (self.invertir(n // 10) + (n % 10) *
(self.potencia(10, self.cuentaDigitos(n) - 1))) 95
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

12. Cuenta los dígitos de un número

Por ejemplo, si N=123 su longitud es 3, es decir la cantidad de dígitos que tiene el

número.

Solución.

Para dar solución al problema se realizará con divisiones sucesivas y se

contará la cantidad de divisiones que efectue con el número N.
cuenta cuantos digitos tiene un número divisiones sucesivas, y luego
conrtaremos la cantidad de divisiones que se efectua.
N C= 0

123 10 C=1

(3) 12 10 C=2

(2) 1 10 C=3

(1) 0

La función recursiva sera de la siguiente manera

0 Si
n=0

CuentaDigitos(n) =

1 + CuentaDigitos(n/10) Si
n>0

La implemetación de la función recursiva en el lenguaje es la siguiente

# Cuenta cuantos digitos tiene un numero

def cuentaDigitos(self,n):
if (n == 0):
return 0
else:
return (1 + self.cuentaDigitos(n // 10)) 96
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

13. Dado un vector V Sumar los elementos del vector

Ejemplo

V= 1 5 2 4 5 6
* 0 1 2 3 4 5

Tamaño del vector N=6

La suma S=1+5+2+4+5+6 = 23
Para suma el vector de forma recursiva se empieza de N=6 hasta llegar a la
primera posición 0.

Por lo tanto, la función recursiva será como sigue.

0 Si n = 0

SumaVec(V,n) =

V[n-1] + SumaVec(V,n-1) Si n > 0

La implemetación de la función recursiva en el lenguaje es la siguiente

# Suma elementos del vector

def sumaVec(self,V, n):
if (n == 0):
return 0
else:
return (V[n - 1] + self.sumaVec(V, n - 1))

14. Sumar los dígitos de un número

Ejemplo

N=2631 S=2+6+3+1 = 12

Solución.

Para resolver el ejercicio, se lo realizará mediante divisiones sucesivas.

S=0

97
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

N S=S+R

2631 10 S=S+1=1

(1) 263 10 S=1+3=4

R (3) 26 10 S = 4 + 6 = 10

R (6) 2 10 S = 10 + 2 = 12

R (2) 0

La formula recursiva es la siguiente

0 Si N=0

SumaDigitos(N) =

N mod 10 + SumaDigitos(N / 10) Si N>0

El programa Recursivo será la siguiente.

# Suma los digitos de un numero

def sumaDigitos(self,n):
if (n == 0):
return 0
else:
return (n % 10 + self.sumaDigitos(n // 10))

15. Buscar elementos menor en un vector

Ejemplo

V=
10 5 2 1 5 6
0 1 2 3 4 5
Em = 10 5 2 1
Tamaño del vector N=6

Elemento Menor EM = 1

98
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Para encontrar elemento menor en el vector de forma recursiva se empieza de

N=6 hasta llegar a la primera posición 0.

Por lo tanto la función recursiva será como sigue y la implemetación en el lenguaje

es la siguiente.
Solución.

# Busca un elemento menor en un vector

def elementoMenor(self,V, n, menor):
if (n == 0):
return menor
else:
if (menor > V[n]):
menor = V[n]
return (self.elementoMenor(V, n - 1, menor))
else:
return (self.elementoMenor(V, n - 1, menor))
16. Invertir una cadena
Ejemplo.

Palabra = “hola” Inversa = “aloh”

Solución.

Una cadena es simplemente un vector de caracteres que se lo representa de la

siguiente forma.

Palabra= h o l a
0 1 2 3
Donde la longitud de la palabra es 4

Como es un vector por lo tanto se la manipulación de los datos se lo realizará

utilizando los índices de atrás hacia adelante, es decir, de n=4 hasta llegar a la
posición 0 (n=0)

Por lo tanto la función recursiva será como sigue.

““ Si n = 0

invertirCad(palabra,n) =

palabra[n-1] + invertirCad(palabra,n- Si n > 0

1)

La implemetación de la función recursiva en el lenguaje es la siguiente

# Invertir una cadena

def invertirCadena(self,palabra, n):
if n == 0:
99
return ""
else:
return palabra[n - 1] + self.invertirCadena(palabra, n - 1)
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

17. Programar un algorítmo recursivo que determine si un número es par o

impar utilizando recursividad cruzada.
Ejemplo
N = 4 entondes N es un número par
N = 7 entonces N es un número impar

Solución.

Para verificar si un número es par o impar se lo realizará con funciones

recursivas cruzadas.

Función recursiva para verificar si un número N es par

true Si n = 0

Par( N ) =

Impar( N – 1 ) Si n > 0

Función Recursiva para verificar si un número N es impar

False Si n = 0

Impar( N ) =

par( N – 1 ) Si n > 0

La implemetación de la función recursiva en el lenguaje es la siguiente

// verifica si un numero es par

public boolean par(int n) {

if (n == 0) {
return true;
} else {
100
return impar(n - 1);
}
}
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

18. Programar un algorítmo recursivo que determine si un número es

positivo o negativo.

Ejemplo

Si N= 5 Entonces N es positivo

Si N= -95 Entonces N es negativo

Solución.

Para verificar si un número es positivo o negativo también se lo realizará con

funciones recursivas cruzadas.

Función recursiva para verificar si un número N es positivo.

True Si n < 0

Positivo( N ) =

Negativo( N – 1 ) Si n <= 0

Función Recursiva para verificar si un número N es impar

False Si n = 0

101
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Negativo( N ) =

Positivo( N – 1 ) Si n > 0

La implementación de la función recursiva en el lenguaje es la siguiente.

#verifica si un numero es positivo

def positivo(self,n):
if (n > 0):
return True;
else:
return self.negativo(n-1)

# verifica si un numero es negativo

def negativo(self,n):
if (n < 0): 1
return False
else:
return self.positivo(n-1)

19. Torres de hanoi

El juego matemático de las Torres de Hanoi consiste en un dispositivo que consta

de tres varillas verticales A, B y C y un número variable de discos. Los n discos son
todos de diferente tamaño y, en la posición de partida del juego, todos los discos
están colocados en la varilla A ordenados de mayor a menor tamaño, esto es, el
mayor en el lugar más bajo y el menor arriba.

La función recursiva es la siguiente.

102
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación de la función recursiva en el lenguaje es la siguiente

# Torres de Hanoi Recursivo

def hanoi(self,n, origen, auxiliar, destino):

if n == 1:
print(f"Mover disco de {origen} a {destino}")
else:
self.hanoi(n - 1, origen, destino, auxiliar)
print(f"Mover disco de {origen} a {destino}")
self.hanoi(n - 1, auxiliar, origen, destino)

20. Búsqueda binaria

Para buscar un elemento en un vector V, los datos del vector tiene que estar
ordenado los elementos.
Si N = 1

Hanoi( N ) =

2 * Hanoi ( N – 1 ) + 1 Si N > 0

N=6

V= 1 2 7 9 10 13

0 1 2 3 4 5

Elemento = 13 entonces existe.

Solución

Medio = (menor + mayor)/2 => Media = (0+5)/2 = 2

ValorMedio = V[Media] =>ValorMedio = 7

Si valorMedio < elemento entonces menor = Medio + 1

entonces menor = 2 + 1

103
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

V= 1 2 7 9 10 13

0 1 2 3 4 5

menor Medio Mayor

Medio = (menor + mayor)/2 => Medio = (3+5)/2 = 4

ValorMedio = V[Medio] =>ValorMedio = 10

Si valorMedio < elemento entonces menor = Medio + 1

Entonces menor = 4 + 1 = 5

V= 1 2 7 9 10 13

0 1 2 3 4 5

Menor Medio Mayor

Medio = (menor + mayor)/2 => Medio = (5+5)/2 = 5

ValorMedio = V[Medio] =>ValorMedio = 13

Si valorMedio = elemento entonces return medio

V= 1 2 7 9 10 13

0 1 2 3 4 5

Menor

Medio

Mayor

La función recursiva es la siguiente.

La implementación de la función recursiva en el lenguaje es la siguiente.

# Busqueda Binaria
def buscarBinaria(self,V, menor, mayor, elemento):
media = (mayor + menor) // 2
valorMedio = V[media]
print(valorMedio)
if menor > mayor:
return -1
elif valorMedio == elemento:
return media
elif valorMedio < elemento:
104
return self.buscarBinaria(V, media+1, mayor, elemento)
else:
return self.buscarBinaria(V, menor, media-1, elemento)
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Mat[0][0] Si fila=0 y col =

0

suma(fila,col,n,mat) = Suma(fila-1,n,n,mat) Si col<0

V,menormayor,,elemento)
Mat[fila][col] + suma(fila,col-1,n,mat) Si col>=0

21. Sumar los Elementos de una Matriz

Ejemplo
Si fila = 3 , columna = 4

0 1 2 3

0 1 5 6 2
M = 1 2 6 7 1

2 1 3 4 5

S = 1 + 5 + 6 + 2 + 2 + 6 + 7 + 1 + 1 + 3 + 4 + 5 = 43

Solución.
Los elementos de la matriz se suman elemento a elemento, y la función recursiva
es la siguiente.

La implementación de la función recursiva en el lenguaje es la siguiente.

int suma (int fila, int col, int orden, int mat [] [])
{
if (fila == 0 && col == 0)
return mat [0] [0];
else
if (col < 0)
return suma (fila - 1, orden, orden, mat);
else 105
return mat [fila] [col] + suma (fila, col - 1, orden, mat);
}
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

22. Buscar elemento Menor en un Vector

Ejemplo si N = 6

V= 5 2 1 7 10 13

0 1 2 3 4 5

Emenor = 1
El programa recursivo es la siguiente.

Solución.

int Emenor(int V[], int n)

{
int min = V[0];
if(n == 0) return min;
else
{
if(V[n] < min) min = V[n];

return Emenor(V, n-1);

}
}
23. Sumar dos vectores
Ejemplo
Si N=6

A= 1 6 2 4 1 6

0 1 2 3 4 5

B= 5 2 1 7 2 3

0 1 2 3 4 5

La suma de los vectores es la siguiente.

106
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

C= 6 8 3 11 3 9

0 1 2 3 4 5

En este caso se realizará un procedimiento recursivo como se muestra en el

código.
void suma2Vec(int A[], int B[], int C[], int n) {
if (n != 0) {
C[n - 1] = A[n - 1] + B[n - 1];
suma2Vec(A, B, C, n - 1);
}
}

24. Sumar Dos matrices

Para poder sumar dos matrices, la condición base es, que ambas matrices
deben ser del mismo tamaño y se suma es elemento a elemento. Por
ejemplo

Fil = 3 Col = 4

A B C
2 4 5 6 4 1 2 3 6 5 7 9
+ =
1 3 4 3 3 4 2 1 4 7 6 4

1 2 3 4 8 9 7 2 9 11 10 6

3x4 3x4
3x4

En el ejemplo las matrices son del mismo tamaño pòr lo tanto se puede
realizar la suma.

Para sumar se lo realiza elemento a elemento, por ejemplo.

C[0,0] = A[0,0] + B[0,0] => C[0,0]= 2 + 4 = 6

C[0,1] = A[0,1] + B[01] => C[0,1] = 4 +1 = 5
C[0,2] = A[0,2] + B[0,2] => C[0,2]= 5 + 2 =7
C[0,3] = A[0,3] + B[0,3] => C[0,3]= 6 + 3 =9
Y para los restantes elementos se procede de similar forma.
Con toda estas consideraciones se tiene el siguiente procedimiento
recursivo.

107
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

void suma2Mat(int A[][], int B[][], int C[][], int fil, int col, int n) {
if (fil != 0) {
if (col != 0) {
C[fil - 1][col - 1] = A[fil - 1][col - 1] + B[fil - 1][col - 1];
suma2Mat(A, B, C, fil, col - 1, n);
} else {
suma2Mat(A, B, C, fil - 1, n, n);
}
}
}
}

“Yo no enseño a mis alumnos, solo les proporciono las condiciones en las que
puedan aprender.”
Albert Einstein.

7.1. Definición

La estructura de dato lista, es una estructura lineal y dinamica. Lineal porque a cada
elemento le puede seguir solo otro elemento; dinamica porque se puede manejar la
memoria de manera flexible, sin la necesidad de reservar espacios con antelación.

La principal ventaja de manejar un tipo dinamico de datos es que se pueden adquirir

posiciones de memoria a medida que necesitan; estas se liberan cuando ya no se
requieren. Asi es posible crear estructuras dinamicas que se expanden o contraigan,
segun se les agregue o elimina elementos. Los dinamismos de estas estructuras
solucionan el problema de decidir cual es cantidad optima de memoria que se debe
reservar para un problema especifico. Sin embargo, es importante destacar que las
estructuras dinamicas no pueden reemplazar a los arreglos en todas sus
aplicaciones.

Las listas enlazadas son colecciones de elementos llamados nodos; el orden entre
estos se establece por medio de un tipo de datos denominado punteros,
apuntadores, direcciones o referencias a otros nodos(Cairo & Guardati, 2008)

108
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Una lista se lo representa de forma grafica tal como se muestra a continuación.

Nodo

Un nodo gráficamente se lo representa de la siguiente manera.

Donde:
Información : Información que se almacena en el nodo.
Siguiente : Almacena la dirección del siguiente nodo de la lista, el ultimo
nodo de la lista apunta a nulo.

7.1.1 Clasificación de listas enlazadas

Las listas se clasifican como siguien.

 Listas enlazadas simples

 Listas enlazadas circulares simples
 Listas doblemente enlazadas
 Listas doblemente circulares
 N - listas

7.1.1.1. Listas enlazadas simples

Una lista simplemente enlazada, constituye una colección de elementos llamados

nodos. El orden entre estos se establece por medio de punteros; es decir,
direcciones o referencias a otros nodos. Un tipo especial de lista simplemente
enlazada es la lista vacia.

109
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Gráficamente una lista simple se lo representa de la siguiente forma.

El tipo de dato abstracto (TDA) de una lista simple, se lo representa de la siguiente

forma como se observa en la figura 7.1.

Figura 7.1 TDA de una lista Simple

7.1.1.1.1 Operaciones básicas sobre listas simples enlazadas

Las operacines básicas de las listas enlazadas son las siguientes:

 Crear() : crea una lista
 InsertarInicio(e) :Insserta un elemento “e” al principio de la lista
 InsertarFinal(e) : Inserta un elemento “e” al final de la lista
 InsertarAntes(e,a) : Inserta un elemento “e” antes de un elemento “a”
 InsertarDespues(e,d) : Inserta un elemento “e” después del elemento “d”
 InsertarOrdnado(e) ;Inserta un elemento “e” de forma ordenada
 EliminarInicio() : Elimina un elemento “e” del inicio de la lista

110
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

 EliminarFinal() : Elimina un elemento “e” del final de la lista

 EliminarElemento(e) : Elimina un elemento “e” de la lista
 ListarElemento() :Lista los elemento de la lista L.
7.1.1.1.2 Implementación de operaciones básicas de las listas
enlazadas.

Primero implementaremos la clase nodo.

class Nodo(object):
dato = None
sigte = None
def __init__(self):
self.dato = None
self.sigte = None

Una vez implementado la clase Nodo, implementaremos la clase Listas_Simples

De la siguiente manera.

from NodoL import Nodo

class ListaSimple(object):
#Inicializamos la lista
def __init__(self):
self.L = None

Dentro de esta clase se implementará todos los métodos, descritos en el TDA

Listas_Simples

Crear() : crea una lista

//crea una Lista

public void crea() {
L = null;
}

InsertarInicio(e) :Insserta un elemento “e” al principio de la lista

Cuando se inserta un elemento al principio se tiene dos casos que la lista este vacia
o que la lista L tenga datos.

111
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Cuando la Lista es vacia

L
L

q
Q
En ambos casos el código será la siguiente.

#Adicionamos un elemento e al inicio de la Lista

def adicionaInicio(self, e):
q = Nodo()
q.dato=e
q.sigte = self.L
self.L = q

InsertarFinal(e) : Inserta un elemento “e” al final de la lista

Para insertar un elemento e en la lista al final se tiene dos casos.

Cuando la Lista es
vacia Cuando la lista tiene datos, el puntero r se debe
posicionar al final de la lista con el siguiente algorítmo
r = self.L
L while r.sigte!=None:
r = r.sigte

q
En el primer caso
cuando la lista esta
vacia, el algorítmo es Una vez que el puntero r se posiciona al final el
la siguiente. código de enlace es la siguiente
q = Nodo() r.sigte = q
q.dato=e q.sigte = None;

por lo tanto la lista queda de la siguiente forma

112
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Por lo tanto el algorítmo completo se muestra a continuación.

#Adicionamos un elemento e al final de la Lista
def adicionaFinal(self, e):
q = Nodo()
q.dato=e
if self.L is None:
self.L = q
else:
r = self.L
while r.sigte!=None:
r = r.sigte
r.sigte = q

InsertarAntes(e,a) : Inserta un elemento “e” antes de un elemento “a”

Para insertar un elemento “e” antes de un elemento “a”, primero se debe buscar el
elemento “a” si existe se inserta, caso contrario no se inserta.

Por ejemplo si e=9 y a=10

w r

q
También puede darse el caso que el elemento a insertar sea al principio, por
ejemplo. Si e=9 y a= 6

L r

113
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Por lo tanto el código será el siguiente.

# Adiciona un elemento e antes del elemento x

def adicionaAntes(self, e, a):
if self.L != None:
r = self.L
w = None
while r != None and r.dato != a:
w = r
r = r.sigte
if r!=None:
if r == self.L:
self.adicionaInicio(e)
else:
q = Nodo()
q.dato=e
q.sigte = r
w.sigte = q
else:
print("No se encontro elemento...")
else:
print("Lista Vacia...")

InsertarDespues(e,d) : Inserta un elemento “e” después del elemento “d”

Para insertar un elemento “e” después del elemento “d”, primero se debe buscar el
elemento “d”, si existe se inserta, caso contrario no se inserta.

Por ejemplo si e=9 y d=10

q
También puede darse el caso que el elemento a insertar este al final de la lista L,
por ejemplo. Si e=9 y d= 20

114
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementacion se detalla a continuación q

# Adiciona un elemento e despues del elemento d
def adicionaDespues(self, e, d):
if self.L!=None:
r = self.L
while r != None and r.dato != d:
r = r.sigte
if r != None:
if r.sigte == None:
self.adicionaFinal(e)
else:
q = Nodo()
q.dato=e
q.sigte = r.sigte
r.sigte = q
else:
print("No se encontró el elemento en la lista...")
else:
print("Lista vacía...")

InsertarOrdnado(e) ;Inserta un elemento “e” de forma ordenada.

Insertar un elemento “e” en una lista L, se lo realiza de forma ordenada.
Por ejemplo. e=12
r

q
El código de una lista ordenada L será la siguiente.

115
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Adiciona elementos en la lista

#de forma ordenada
def adicionaOrdenada(self, e):
if self.L == None:
self.adicionaInicio(e)
else:
r = self.L
w = None
while r != None and r.dato <= e:
w = r
r = r.sigte
if r == self.L:
self.adicionaInicio(e)
else:
if w.sigte==None:
self.adicionaFinal(e)
else:
q = Nodo()
q.dato=e
w.sigte = q
q.sigte = r

EliminarInicio() : Elimina un elemento “e” del inicio de la lista

Para eliminar un elemento del principio o inicio, se debe utilicar un puntero auxiliar
r, es decir r debe tomar la posición de L (r=L), luego L se debe mover a la siguiente
nodo (L=L,siguiente), de forma grafica se representa de la siguiente forma.
De la siguiente forma.

L
r

Luego la lista quedara de la siguiente forma

Una vez que el puntero L se mueve al siguiente nodo, la lista quedara de la siguiente
forma.

116
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación del código será como sigue.

# Elimina un elemento de la lista del principio

def eliminaInicio(self):
if self.L==None:
print("Lista vacía")
else:
print("Elemento eliminado:", self.L.dato)
self.L = self.L.sigte

EliminarFinal() : Elimina un elemento “e” del final de la lista

Para eliminar un elemento del final de una lista L, se debe utilizar un puntero r,
donde r inicia donde se encuentra el puntero L (r=L), luego r debe mover hasta el
ultimo nodo, y también se debe tener otro puntero auxiliar w, que este antes que el
puntero r, la lista tendrá la siguiente configuración.
w r

una vez que r esta en el ultimo nodo de la lista L, se elimina y w debe apuntar a null,
de forma grafica será de la siguiente forma.

Luego el puntero r se pone nul, de forma grafica se muestra a continuación.

117
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación del código será como sigue.

#Elimina un elemento de la lista del final

def eliminaFinal(self):
if self.L==None:
print("Lista vacía")
else:
r = self.L
w = None
while r.sigte:
w = r
r = r.sigte
if w == None:
print("Elemento eliminado:", r.dato)
self.L = None
else:
print("Elemento eliminado:", r.dato)
w.sigte = None

EliminarElemento(e) : Elimina un elemento “X” de la lista

Por ejemplo.

Si el elemento a eliminar X=15

Para eliminar un elemento X, primero debe existir dicho elemento en la lista, en caso
de existir se elimina, caso contrario no se elimina.

La búsqueda del elemento X, se lo realiza con un puntero auxiliar r, y el puntero r

recorre la lista hasta encontrar el elemento X, si no existe el elemento X, el puntero
r recorre hasta el final de la lista L.

Elemento a X puede encontrarse en casos, al principio, al final y al medio.

Caso 1. El elemento X se encuentra en el principio

Si X= 6
r

118
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Si el elemento X esta en el principio, entonces se invoca al programa que

eliminaPrincipo.

Caso 2. El elemento X se encuentra en el final

Si X= 20

w r

Si el elemento X esta en el final de la lista L, entonces se invoca al programa que

eliminaFinal.

Caso 3. El elemento X se encuentra en el medio de la lista L

Si x= 15

El elemento X se encuentra en el medio de la lista L, tal como se muestra en el

siguiente grafico.
w r

En este caso el enlace se realiza de la siguiente forma.

w r

El código del enlace será:

w.siguiente = r.siguiente

119
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación del código será como sigue.

#Elimina cualquier elemento de la lista

def eliminaElementoX(self, e):
if self.L==None:
print("Lista vacía")
else:
r = self.L
w = None
while r!= None and r.dato != e:
w = r
r = r.sigte
if r == None:
print("No existe el elemento")
else:
if r == self.L:
self.eliminaInicio()
elif r.sigte is None:
self.eliminaFinal()
else:
print("Elemento eliminado:", r.dato)
w.sigte = r.sigte

ListarElemento() :Lista los elemento de la lista L.

Para listar los elementos de la lista L, la lista se recorre con un puntero auxiliar r,
hasta el final de la Lista.
r

El código de listado de elemento se muestra a continuación.

# Listamos datos de la Lista

def mostrar(self):
r = self.L
s = ""
while r != None:
s += " " + str(r.dato)
r = r.sigte
return s

120
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Ejercios

Elimina elemento par.

Se debe eliminar todo los elementos pares de la lista L

Solucion.

# Dada una lista Simple

# Eliminar
else { el primer par
def eliminaPar(self):
w.siguiente = r.siguiente;
if self.L is not None:
JOptionPane.showMessageDialog(null, "elemento eliminado :" + r.dato);
r = self.L
r = null;
w = self.L
}
while r is not None and r.dato % 2 != 0:
}
w = r
} else {
r = r.sigte
JOptionPane.showMessageDialog(null, "No existe elemento ");
if r is not None:
}
if self.L == r:
} else {
self.eliminaInicio()
JOptionPane.showMessageDialog(null, "Lista Vacia...");
else:
}
if r.sigte is None:
} self.eliminaFinal()
else:
w.sigte=r.sigte
r=None
else:
print("Lista vacía...")

Dada una Lista simple ordenar sus elementos de forma ascedente.

Solucion.

121
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

A continuación se implementa el ordenamiento de datos de una lista simple

# Dada una lista Ordenar sus elementos

# por el metodo de la burbuja
def ordenaElementos(self):
if self.L is not None:
r = self.L
while r is not None:
w = r.sigte
e1 = r.dato
while w is not None:
e2 = w.dato
if e1 > e2:
w.dato = e1
r.dato = e2
e1 = e2
w = w.sigte
r = r.sigte
else:
print("Lista vacía...")

La implementación de la lista simple, y la ejecución de los métodos se lo realiza a

travez de un formulario que se muestra a continuación.

122
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La clase de este formulario es la siguiente.

package Listas;

import javax.swing.JOptionPane;
public class FormListaSimple extends javax.swing.JFrame {
Listas_Simples lista = new Listas_Simples();
double elemento;
public FormListaSimple() {
initComponents();
setBounds(10, 10, 950, 500);
}
…………..
…………..

7.1.1.1.3. Ejemplo de aplicación.

Mediante Lista Simples almacenar los datos de un empleado con los siguientes
atributos (ci, paterno, materno, nombre, dirección, salario) y realizar las siguientes
operaciones.
 Adicionar
 Eliminar un empleado por su Ci.
 Buscar un empleado por su nombre
 Listar todos los empleados

Solución.

Para solucionar el problema es necesario realizar el siguiente diagrama de clase

que muestra a continuación, en la figura 7.2

Figura 7.2 Diagrama de clase para administrar empleados

123
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Una vez definido el TDA se procede a implementar las clases correspondientes

Implementación de la Clase Empleado

#Creacion de la clase Empleado

#con los atribustos ci,paterno,materno,nombre,direccion,salario
class Empleado:
def __init__(self):
self.ci = ""
self.pat = ""
self.mat = ""
self.nom = ""
self.dir = ""
self.salario = 0.0

def set_empleado(self, ci, pat, mat, nom, dir, salario):

self.ci = ci
self.pat = pat
self.mat = mat
self.nom = nom
self.dir = dir
self.salario = salario

def get_ci(self):
return self.ci

def get_pat(self):
return self.pat

def get_mat(self):
return self.mat

def get_nom(self):
return self.nom

def get_dir(self):
return self.dir

def get_salario(self):
return self.salario

def set_ci(self, ci):

self.ci = ci

def set_pat(self, pat):

self.pat = pat

124
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Implementación de la clase Nodo_empleado.

from Empleado import Empleado

class NodoEmpleado:
def __init__(self):
self.emp = Empleado()
self.sigte = None

Implementación de la clase Lista_simple_empleado

from NodoEmpleado import NodoEmpleado
class ListaSimpleEmpleado:
#Constructor para crear la Lista
def __init__(self):
self.listaEmp = None

#Inicializa la lista
def crea(self):
self.listaEmp = None

#Adiciona un empleado
def adicionaInicio(self, datoEmp):
q = NodoEmpleado()
q.emp = datoEmp
q.sigte = self.listaEmp
self.listaEmp = q

#Elimina un empleado por C.I.

def eliminaEmpleado(self, ci):
if self.listaEmp is not None:
r = self.listaEmp
w = self.listaEmp
while r is not None and r.emp.ci != ci:
w = r
r = r.sigte
if r is not None:
if r == self.listaEmp:
self.listaEmp = self.listaEmp.sigte
elif r.sigte is None:
w.sigte = None
else:
w.sigte = r.sigte
print("Empleado eliminado")
else:
print("Empleado no existe")

125
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Lista todos los empleado de la lista

def mostrarEmpleado(self):
se = ""
r = self.listaEmp
while r is not None:
se += "\t" + r.emp.get_ci() + "\t" + r.emp.get_nom() +
"\t" + r.emp.get_pat() + "\t" + r.emp.get_mat() + "\t" +
str(r.emp.get_salario()) + "\n"
r = r.sigte
return se
#Busca empleados por Nombre
def buscarNombre(self, cadNombre):
s = ""
if self.listaEmp is not None:
r = self.listaEmp
longitud = len(cadNombre)
cadNombre = cadNombre.lower()
while r is not None:
cadNombreAux = r.emp.nom[:longitud].lower()
print(cadNombreAux+"-")
if cadNombre == cadNombreAux:
s += r.emp.get_ci() + "\t" + r.emp.get_nom() +
"\t" + r.emp.get_pat() + "\t" + r.emp.get_mat() + "\t" +
str(r.emp.get_salario()) + "\n"
r = r.sigte
return s

La implementación para las acciones se detalla acontinuacion.

#Menu Principal para administraer el empleado

from ListaSimpleEmpleados import ListaSimpleEmpleado

from Empleado import Empleado
def menuPrincipalEmpleado():
listaEmp=ListaSimpleEmpleado()
while True:
print("\nMenu Empleado")
print("1. Crear")
print("2. Adicionar")
print("3. Elimina")
print("4. Listar")
print("5. Buscar por Nombre")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
listaEmp=ListaSimpleEmpleado()

126
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="2":
print("INGRESE DATOS DEL EMPLEADO")
ci = input("C.I.:")
pat = input("Paterno:")
mat = input("Materno:")
nom = input("Nombre:")
dire = input("Direccion:")
salario =float(input("Salario:"))
datEmp=Empleado()
datEmp.set_empleado(ci,pat,mat,nom,dire,salario)
listaEmp.adicionaInicio(datEmp)
elif opcion=="3":
print ("ELIMINACION DE EMPLEADO POR CI")
ci=int(input("Ingrese C.I."))
listaEmp.eliminaEmpleado(ci)
elif opcion=="4":
print("LISTADO DE EMPLEADOS")
print("c.i.\tNombre\tPaterno\tNombre\tDireccion\t
Salario ")
ds=listaEmp.mostrarEmpleado()
print(ds)
elif opcion=="5":
print("BUSQUEDA DE DATOS POR NOMBRE DE EMPLEADO")
nom=input("Ingrese Nombre a buscar:")
ds=listaEmp.buscarNombre(nom)
print(ds)
elif opcion=="*":
break
else:
print("opcion no valida")
#Llamada a menu principal
menuPrincipalEmpleado()

7.1.1.2. Listas enlazadas simples circulares

Las listas circulares son similares a las listas simplemente enlazadas. Sin embargo,
tiene las características de que ultimo elemento de la lista apunta al primero, en
lugar de apuntar al vacio.(Cairo & Guardati 2008)

127
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Gráficamente se lo representa de la siguiente forma.

El tipo de datos abstracto (TDA) de una lista simple circular, se lo representa de la

siguiente manera que muestra en la figura 7.3

Figura 7.3 TDA de una lista circular

7.1.1.2.1. Operaciones básicas sobre lista enlazada simple circular

Las operaciones básicas de las listas enlazadas son las siguientes:

 Crear() : crea una lista
 InsertarInicio(e) :Insserta un elemento “e” al principio de la lista
 InsertarFinal(e) : Inserta un elemento “e” al final de la lista
 InsertarAntes(e,a) : Inserta un elemento “e” antes de un elemento “a”
 InsertarDespues(e,d) : Inserta un elemento “e” después del elemento “d”
 EliminarInicio() : Elimina un elemento “e” del inicio de la lista
 EliminarFinal() : Elimina un elemento “e” del final de la lista
 EliminarElemento(e) : Elimina un elemento “e” de la lista
 Mostrar() :Lista los elemento de la lista L.
7.1.1.2.2 Implementación de operaciones de la lista enlazada simple
circular.

128
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Para la implementación de los métodos básicos de la lista enlazada circular se

empleara JAVA , en este sentido la primera Clase que se implementa será la clase

class Nodo(object):
dato = None
sigte = None
def __init__(self):
self.dato = None
self.sigte = None

nodo.

Una vez implementado la clase Nodo, implementaremos la clase

ListaSimpleCircular, de la siguiente manera.

mport random
from NodoL import Nodo
class ListaSimpleCircular(object):
L = None
…….

Dentro de esta clase se implementará todos los métodos, descritos en el TDA

ListaSimpleCircular

Crear() : crea una lista

#Inicializa la lista circular

def crea(self):
self.L = Nodo()

InsertarInicio(e): Inserta un elemento “e” al principio de la lista simple circular

Cuando se inserta un elemento al principio se tiene dos casos que la lista circular,
esta vacia o que la lista LC tenga datos.

129
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Cuando la Lista es Si la lista tiene datos, el puntero r=LC, y el puntero r

vacía debe recorrer la lista hasta llegar al último elemento.

Cuando la lista esta

vacia solo se crea un El código de enlace será :
solo nodo de la
siguiente manera r = self.L
q.sigte = self.L
while r.sigte != self.L:
r = r.sigte
self.L = q
r.sigte = self.L
El código será una vez que se ha enlazado la lista, de forma grafica
q = Nodo() debe quedar de la siguiente manera.
q.dato = e
if self.L is
None:
self.L = q
q.sigte =
self.L

Por lo tanto el código será de la siguiente manera.

#Adiciona un elemento e al inicio

#de la lista circular
def adicionaInicio(self, e):
q = Nodo()
q.dato = e
if self.L is None:
self.L = q
q.sigte = self.L
else:
r = self.L
q.sigte = self.L
while r.sigte != self.L:
r = r.sigte
self.L = q
r.sigte = self.L

InsertarFinal(e) : Inserta un elemento “e” al final de la lista

Para insertar un elemento e en la lista al final se tiene dos casos.

130
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Cuando la Lista es
vacia Si la lista tiene datos, el puntero r=LC, y el puntero r debe
recorrer la lista hasta llegar al ultimo elemento.

Cuando la lista esta

vacia solo se crea un Para el caso de cuando la lista LC esta con datos, el
solo nodo de la puntero “r” debe iniciar donde esta el puntero LC, y luego
siguiente manera se debe llevar al final de la lista LC, luego se procede a
realizar el enlace.

r = self.L
while r.sigte != self.L:
r = r.sigte
r.sigte = q
El código será q.sigte = self.L
Nodo q = new
Nodo();
una vez que se ha enlazado la lista, de forma grafica debe
q = Nodo() quedar de la siguiente manera.
q.dato = e
if self.L is
None:
self.L = q
q.sigte =
self.L
or lo tanto el algorítmo completo se muestra a continuación.

#Adiciona un elemento e al final

#de la lista circular
def adicionaFinal(self, e):
q = Nodo()
q.dato = e
if self.L is None:
self.L = q
q.sigte = self.L
else:
r = self.L
while r.sigte != self.L:
r = r.sigte
r.sigte = q
q.sigte = self.L

InsertarAntes(e,a) : Inserta un elemento “e” antes de un elemento “a”

Para insertar un elemento “e” antes de un elemento “a”, primero se debe buscar el
elemento “a” si existe se inserta, caso contrario no se inserta.

131
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Por ejemplo si e=12 y a=6

El puntero r debe iniciar en LC (r=LC) y con el puntero r se busca el elemento “a”,

una vez que lo encuentra, la búsqueda termina, adicionalmente el puntero w debe
estar un nodo antes que el puntero r, la configuración de la lista LC debe quedar
como se muestra en la siguiente figura.

Puede darse el caso de que el elemento a insertar este al principio de la lista LC.

por ejemplo. Si e=12 y a= 6

Por lo tanto el código será el siguiente.

InsertarDespues(e,d) : Inserta un elemento “e” después del elemento “d”

Para insertar un elemento “e” después del elemento “d”, primero se debe buscar el
elemento “d”, si existe se inserta, caso contrario no se inserta.

#Adiciona un elemento e de la lista circular

#antes del elemento x
def adicionaAntes(self, e,x):
if self.L is not None:
r = self.L
w = self.L
while r.sigte != self.L and r.dato != x:
w = r
r = r.sigte
if self.L == r:
self.adicionaInicio(e)
else:
q = Nodo()
q.dato = e
w.sigte = q
q.sigte = r
else:
print("Lista vacia ...")

132
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Por ejemplo si e=12 y d=10

También puede darse el caso que el elemento a insertar este al final de la lista LC,
por ejemplo. Si e=8 y d= 20

Por lo tanto el código será el siguiente.

#Adiciona un elemento e de la lista circular

#despues del elemento x

def adicionaDespues(self, e,x):

if self.L is not None:
r = self.L
while r.sigte != self.L and r.dato != x:
r = r.sigte
if r.sigte == self.L:
self.adicionaFinal(e)
else:
q = Nodo()
q.dato = e
q.sigte = r.sigte
r.sigte = q
else:
print("Lista vacia ...")

Adiciona Aleatoriamente: Para agilizar el llenado de datos en la lista se puede

añadir elementos de forma aleatoria, para esto en Python es necesario import el
paquete random
# En una Lista llenar n datos de forma aleatoria
def adicionaAleatorio(self):
n=int(input("Cantidad de datos a generar:"))
for i in range(1,n+1):
e=random.randint(1,20)
self.adicionaFinal(e)

133
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

EliminarInicio() : Elimina un elemento “e” del inicio de la lista

Para eliminar un elemento del principio o inicio de la lista LC, se debe utilizar un
puntero auxiliar r, es decir r debe tomar la posición de LC (r=LC), luego LC se debe
mover a la siguiente nodo (LC=LC.siguiente), a continuación se representa de
forma grafica en la siguiente figura.

Luego la lista quedara de la siguiente forma

Puede darse el caso que la lista circular LC, puede tener un solo Nodo, cuando se
elimina la lista LC debe apuntar a null, como se muestra en la siguiente figura.

La implementación del código será como sigue.

#Elimina un elemento de inicio de la lista
def eliminaInicio(self):
e = None
if self.L is not None:
if self.L.sigte == self.L:
w = self.L
e = w.dato
self.L = None
else:
r = self.L
w = self.L
while r.sigte != self.L:
r = r.sigte
e = w.dato
self.L = self.L.sigte
r.sigte = self.L
w = None

134
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

EliminarFinal() : Elimina un elemento “e” del final de la lista

Para eliminar un elemento del final de una lista LC, se debe utilizar un puntero
auxiliar r, donde r inicia donde se encuentra el puntero LC (r=LC), luego r debe
mover hasta el ultimo nodo, y también se debe tener otro puntero auxiliar w, que
este antes que el puntero r, la lista LC se muestra con la siguiente configuración.

Una vez que r esta en el ultimo nodo de la lista LC, se elimina y w debe apuntar al
primer nodo de la lista LC, tal como se ve en la siguiente figura.

Puede darse el caso que la lista circular LC, puede tener un solo Nodo, cuando se
elimina la lista LC debe apuntar a null, como se muestra en la siguiente figura.

135
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

La implementación del código será como sigue.

#Elimina un elemento del final de la lista

def eliminaFinal(self):
e = None
if self.L is not None:
if self.L.sigte == self.L:
e = self.L.dato
self.L = None
else:
r = self.L
w = self.L
while r.sigte != self.L:
w = r
r = r.sigte
e = r.dato
r = None
w.sigte = self.L

EliminarElemento(e) : Elimina un elemento “X” de la lista

Por ejemplo.

Si el elemento a eliminar X=6

Para eliminar un elemento X, primero debe existir dicho elemento en la lista, en caso
de existir se elimina, caso contrario no se elimina.

La búsqueda del elemento X, se lo realiza con un puntero auxiliar r, y el puntero r

recorre la lista hasta encontrar el elemento X, si no existe el elemento X, el puntero
r recorre hasta el final de la lista L.

Para eliminar el elemento a X puede darse tres casos, al principio, al final y al

medio.

Caso 1. El elemento X se encuentra en el principio

Si X= 45

136
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Luego la lista quedara de la siguiente forma

Si el elemento X esta en el principio, entonces se invoca al programa que

eliminaPrincipio.

Caso 2. El elemento X se encuentra en el final

Si X= 20

Una vez que r esta en el ultimo nodo de la lista LC, se elimina y w debe apuntar al
primer nodo de la lista LC, tal como se ve en la siguiente figura.

Si el elemento X esta en el final de la lista LC, entonces se invoca al programa que

eliminaFinal.

Caso 3. El elemento X se encuentra en el medio de la lista LC

Si x= 6

137
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

El elemento X se encuentra en el medio de la lista LC, tal como se muestra en el

siguiente grafico.

En este caso el enlace se realiza de la siguiente forma.

El código del enlace será: w.siguiente = r.siguiente

Puede darse el caso que la lista circular LC, puede tener un solo Nodo, y el elemento
buscado sea el único elementos de la lista LC., dicha lista LC debe apuntar a null,
como se muestra en la siguiente figura.

138
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Elimina un elemento x de la lista

def eliminaElementoX(self, x):
e = None
if self.L is not None:
if self.L.sigte==self.L and self.L.dato==x:
self.L=None
else:
r = self.L
w = self.L
while r.dato != x and r.sigte != self.L:
w = r
r = r.sigte
if self.L == r and r.dato == x:
e = self.eliminaInicio()
elif r.sigte == self.L and r.dato == x:
w.sigte=self.L
elif r!= self.L and r.dato == x:
w.sigte = r.sigte
r = None
else:
print("No existe elemento a borrar")

La implementación del código será como sigue

ListarElemento() :Lista los elemento de la lista circular LC.

Para listar los elementos de la lista circular LC, la lista se recorre con un puntero
auxiliar r, hasta el final de la Lista.

El código de listado de elemento se muestra a continuación.

139
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

#Lista datos de la lista

def mostrar(self):
s = ""
r = self.L
if self.L is not None:
while r.sigte != self.L:
s =s+ " " + str(r.dato)
r = r.sigte
s =s+ " " + str(r.dato)
else:
print("Lista Vacia...")
return s

La implementación de la lista circular simple y la ejecución de los métodos, se lo

realiza a travez del siguiente codigo.
elif opcion=="2":
e=int(input("Ingrese dato"))
lista.adicionaInicio(e)
from ListaCircular import ListaSimpleCircular
elif opcion=="3":
def menuPrincipalLista():
e=int(input("Ingrese dato"))
lista=ListaSimpleCircular()
lista.adicionaFinal(e)
while True:
elif opcion=="4":
print("\nMenu")
lista.adicionaAleatorio()
print("1.
elif Crear")
opcion=="5":
print("2. Adicionar Inicio")
e=int(input("Ingrese dato"))
print("3. Adiciona Final")
a=int(input("Adicionar antes de:"))
print("4. Adiciona Aleatorio")
lista.adicionaAntes(e,a)
print("5. Adiciona Antes de")
elif opcion=="6":
print("6. Adiciona Despues
e=int(input("Ingrese de")
dato"))
print("7.Adiciona de forma despues
d=int(input("Adicionar ordenada")
de:"))
print("8. Elimina inicio")
lista.adicionaDespues(e,d)
print("9.
elif Elimina Final")
opcion=="7":
print("10. Elimina Elemento
e=int(input("Ingrese X")
dato"))
print("20. Listar")
lista.adicionaOrdenada(e)
print("*
elif Salir")
opcion=="8":
opcion=input("Elija Opcion:")
lista.eliminaInicio()
if opcion=="1":
elif opcion=="9":
lista=ListaSimpleCircular()
lista.eliminaFinal()
elif opcion=="10":
x=int(input("elemento a eliminar"))
lista.eliminaElementoX(x)
elif opcion=="20":
print(lista.mostrar())
***
elif opcion=="*":
Código Completobreak
de la Clase Lista_simple_circular se muestra a continuación
else:
print("opcion no valida")
#Llamada a la funcion principal
menuPrincipalLista()

140
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

7.1.1.2.3 Ejemplo de aplicación.

Mediante una lista circular simple administrar los datos de un producto cuyos
atributos son las siguientes(idprod, descripción, marca, procedencia, cantidad,
precio, stockmaximo, stockminimo). Realizar las siguientes operaciones (crear,
adicionar, elimina un X producto, listar productos por descripción, listar productos
agotarse)

Solución

El tipo de dato abstracto (TDA), tal como se muestra en la figura 7.4

141
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Figura 7.4 diagrama de clase para administrar producto

La representación de los productos en una lista circular se muestra en siguiente

grafica.

Donde P1,P2,P3,P4,P5,P6 son los productos que se almacena en la lista circular.

Los datos de los productos deben ser almacenados y mostrados de la siguiente

forma.

142
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

IdProd Descripoción Marca Procedencia Cantidad Precio Stock Stock

Max Min
P1 TELEVISOR SONY JAPON 10 5000 300 10
P2 RADIO PHILIPS CHINA 30 600 500 15
P3 CELULAR LG KOREA 60 4500 400 10

Para resolver el problema, primero se implementará la Clase Productos.

class Productos(object):
def __init__(self, idprod, descripcion, marca, procedencia, cantidad,
precio, stockMax, stockMin):
self.idprod = idprod
self.descripcion = descripcion
self.marca = marca
self.procedencia = procedencia
self.cantidad = cantidad
self.stockMax = stockMax
self.stockMin = stockMin
self.precio = precio
def set_idprod(self, idprod):
self.idprod = idprod
def set_descripcion(self, descripcion):
self.descripcion = descripcion
def set_marca(self, marca):
self.marca = marca
def set_procedencia(self, procedencia):
self.procedencia = procedencia
def set_cantidad(self, cantidad):
self.cantidad = cantidad
def set_precio(self, precio):
self.precio = precio
def set_stockMax(self, stockMax):
self.stockMax = stockMax
def set_stockMin(self, stockMin):
self.stockMin = stockMin
def get_idprod(self):
return self.idprod
def get_descripcion(self):
return self.descripcion
def get_marca(self):
return self.marca
def get_procedencia(self):
return self.procedencia
def get_cantidad(self):
return self.cantidad
def get_stockMax(self):
return self.stockMax
def get_stockMin(self):
return self.stockMin
def get_precio(self):
return self.precio
def get_todo(self):
return
f"{self.idprod}\t{self.descripcion}\t{self.marca}\t{self.procedencia}\t{s
elf.cantidad}\t{self.precio}\t{self.stockMax}\t{self.stockMin}\n"

143
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

A partir de la Clase productos se implementa la clase NodoProducto

class NodoProducto(object):
def __init__(self):
self.datoProd = None
self.sigte = None

Una vez implementado la clase Nodo_producto, se la Clase ListaCircularProductos

from NodoProducto import NodoProducto

from Productos import Productos
class ListaCircularProducto(object):
def __init__(self):
self.LCP = None

# Crea la lista circular

def crea(self):
self.LCP = None

# Adiciona un elemento al inicio en la lista circular

def adicionaInicio(self, datProd):
q = NodoProducto()
q.datoProd = datProd
if self.LCP is None:
self.LCP = q
self.LCP.sigte = self.LCP
else:
r = self.LCP
q.sigte = self.LCP
while r.sigte != self.LCP:
r = r.sigte
self.LCP = q
r.sigte = self.LCP

# Adiciona un elemento al final en la lista circular

def adicionaFinal(self, datProd):
q = NodoProducto()
q.datoProd = datProd
if self.LCP is None:
self.LCP = q
self.LCP.sigte = self.LCP
else:
r = self.LCP
while r.sigte != self.LCP:
r = r.sigte
r.sigte = q
q.sigte = self.LCP

144
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Elimina un elemento del Final

def eliminaFinal(self):
if self.LCP is not None:
r = self.LCP
w = self.LCP
while r.sigte != self.LCP:
w = r
r = r.sigte
w.sigte = self.LCP
r = None
else:
print("Lista Vacia...")

# Elimina un producto por el codigo

def eliminaProducto(self, cod):
if self.LCP is not None:
if(self.LCP.sigte==self.LCP and
self.LCP.datoProd.get_idprod() != cod):
self.LCP=None
else:
r = self.LCP
w = self.LCP
while r.sigte != self.LCP and
r.datoProd.get_idprod() != cod:
w = r
r = r.sigte
if self.LCP == r and r.datoProd.get_idprod() ==
cod:
self.eliminaInicio()
else:
if r.sigte == self.LCP and
r.datoProd.get_idprod() == cod:
w.sigte=self.LCP
r=None
else:
if r.sigte != self.LCP and
r.datoProd.get_idprod() == cod:
w.sigte = r.sigte
else:
print("No existe elemento...")
else:
print("Lista Vacia...")

145
ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

# Mostrar los datos de lista circular

def listar(self):
s = ""
if self.LCP is not None:
r = self.LCP
while r.sigte != self.LCP:
s += r.datoProd.get_todo()
r = r.sigte
s += r.datoProd.get_todo()
else:
print("Lista Vacia...")
return s

# Mostrar los datos de la lista circular

# por descripcion
def listarDescripcion(self, desc):
s = ""
if self.LCP is not None:
r = self.LCP
while r.sigte != self.LCP:
desc_parte = r.datoProd.get_descripcion()
desc_parte = desc_parte[:len(desc)]
if desc_parte == desc:
s += r.datoProd.get_todo()
r = r.sigte
desc_parte = r.datoProd.get_descripcion()
desc_parte = desc_parte[:len(desc)]
if desc_parte == desc:
s += r.datoProd.get_todo()
else:
print("Lista Vacia...")
return s

# Mostrar los datos de lista circular

# Productos por agotarse
def listarProductosAgotarse(self):
s = ""
if self.LCP is not None:
r = self.LCP
while r.sigte != self.LCP:
if r.datoProd.cantidad < r.datoProd.stockMin:
s += r.datoProd.get_todo()
r = r.sigte
if r.datoProd.cantidad < r.datoProd.stockMin:
s += r.datoProd.get_todo()
else:
print("Lista Vacia...")
return s

146
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

Finalmente para administrar los productos se tiene el siguiente programa Menu

Principal..

from ListaCircularProducto import ListaCircularProducto

from Productos import Productos
def menuPrincipalProductos():
while True:
print("\nMenu Productos")
print("1. Crear")
print("2. Adicionar")
print("3. Eliminar ")
print("4. Listar General")
print("5. Lista productos descripcion")
print("6. Lista productos agotados")
print("* Salir")
opcion=input("Elija Opcion:")
if opcion=="1":
listap=ListaCircularProducto()
elif opcion=="2":
idp = input("Codigo:")
des =input("Descripcion:")
mar =input("Marca:")
proc = input("Procedencia:")
cant = int(input("Cantidad:"))
stMax = int(input("Stock Maximo:"))
stMin = int(input("Stock Minimo:"))
prec = float(input("Precio:"))
prod=Productos(idp,des,mar,proc,cant,prec,stMax,stMin)
listap.adicionaInicio(prod)
elif opcion=="3":
idp=input("Ingrese codigo de Producto:")
listap.eliminaProducto(idp)
elif opcion=="4":
print("DATOS PRODUCTO")
print(listap.listar())
elif opcion=="5":
des=input("descripcion a Buscar:")
print("DATOS PRODUCTO")
print("Codigo Descripcion Marca Procedencia Cantidad
Precio Stock Maximo Stock Minimo")
s=listap.listarDescripcion(des)
print(s)
elif opcion=="6":
print("PRODUCTO AGOTADOS")
print("Codigo Descripcion Marca Procedencia Cantidad
Precio Stock Maximo Stock Minimo")
s=listap.listarProductosAgotarse()
print(s)

147
 ESTRUCTURA DE DATOS CON LENGUAJE JAVA UN ENFOQUE PRÁCTICO

elif opcion=="*":
break
else:
print("opcion no valida")
#Llamada al programa principal
menuPrincipalProductos()

148