Elvis Tapia Curso 4 Grupo 3 - PortafolioEstructuraDatos

UNIVERSIDAD DE GUAYAQUIL
PORTAFOLIO DE ESTRUCTURA DE DATOS II
AUTOR:
Tlgo. Elvis tapia Aparicio
DOCENTE:
Ing. Cesar Bustamante Chong
CUARTO SEMESTRE
GRUPO#3
AO LECTIVO:
2015-2016
FECHA:
28/08/2015
ndice
1. Introduccion
2. Material De Clase
2.1. Unidad 1er ParcialAlgoritmos De Ordenacin y Bsqueda
Insercin Directa
Burbuja
Shellsort
Radix
Algoritmo Quicksort
Ordenamiento Por Conteo
Ordenamiento Por Distribucion
2.2. Colecciones
Coleccin Map
Subclases De La Coleccin Map:
o HashMap
o TreeMap
o LinkedHashMap
3. Apuntes De La Clase
4. Ejercicios En Clase
4.1 Ejercicios con metodos de ordenamiento.
Insercion Directa
Quicksort 1
Conteo
Quicksort 2
Ejecucion de pasos del metodo quicksort
Ejemplo con diferentes metodos
4.2 Ejercicios de colecciones.
Coleccin MAP: Jugadores

Coleccin TREEMAP: Asignaturas
Coleccin: Digito Verificador de la cedula
Coleccin HASHMAP: Ciudades
5. Talleres Grupales
5.1 Taller 1: Metodos de insercion y Shell sort
5.2 Taller 2: Colecciones
6. Tareas
6.1. Insercion directa
6.2. Burbuja
6.3. Insercion directa :Timer
o Burbuja: Timer
o ShellSort: Timer
6.4. Conteo: Timer
o Quicksort:Timer
6.5. Remove
6.6. Colecciones
7.
Conclusion
8. Glosario
Dedico este xito a mi Dios que me da el privilegio de vivir y de seguir

superndome cada da, a mis padres que siempre estn apoyndome y guindome
hacia el camino del bien, a mis hermanos que estn siempre aconsejndome y
dndome fuerza para seguir siempre adelante y a nuestros profesores que cada da
se esfuerzan para que nosotros podamos adquirir nuevos conocimientos.
Por ellos va este xito, y por las personas que a veces tienen obstculos y quieren
rendirse dejar todo, yo les digo que sigan adelante con sacrificio con esfuerzo, con
el apoyo de las personas que nos quieren y con la fe de nuestro seor mi Dios todo
lo que nos propongamos lo podremos siempre.
Unidad 1er Parcial

MTODOS DE ORDENAMIENTO INTERNOS.
ORDENACIN INTERNA
Algoritmos de ordenamiento por intercambio
Burbuja
Quicksort
Shellsort
Algoritmos de ordenamiento por distribucion
Radix
Insercin directa.
Este metodo consiste en buscar el lugar adecuado para cada registro
recorriendo los registros anteriores para dejar un lugar vaco para el
nuevo elemento. El proceso de acomodo de cada elemento se repite
hasta llegar al ultimo elemento, los elementos previos al elemento a
acomodar se encuentran en orden.
Este es el metodo usado por los jugadores de cartas para acomodar
su juego.
Este ordenamiento parte del principio de que el primer elemento
esta ordenado y sucesivamente se van colocando los miembros en la
posicion adecuada de acuerdo a que pueden ir antes o despues del
primer miembro.
Para ser mas claros, supongamos que tenemos tarjetas con nombres
los cuales queremos ordenar de forma alfabetica, tomamos la
primer tarjeta, la tarjeta dos y la comparamos con la primera,
entonces decidimos si va antes o despues de la primera. Una vez
colocadas ambas tarjetas, seguimos con la tercera, la cual
comparamos con la primera y decidimos si va antes o despues de la
primera, si va despues entonces tendremos que comparar con la
segunda tarjeta, por lo que podra ir en medio de las tarjetas o al
final de las dos primeras.
Ordenamiento por insercin directa.
Burbuja (Bubble)
Este metodo realiza comparaciones de todas las posibles parejas de

llaves intercambiando aquellas que se encuentran fuera de orden.
Utiliza un proceso repetitivo comparando las parejas de datos
adyacentes del inicio al final del arreglo donde, despues de la primer
pasada la llave mayor queda en la ultima posicion del arreglo.
Shell sort.
El metodo Shell divide el arreglo a ordenar en varios grupos haciendo
comparaciones e intercambios entre ellos. El tamano de los subgrupos
se decrementa y el numero de subgrupos se incrementa hasta llegar a
tener n grupos de tamano 1. A partir de este punto, el metodo funciona
como el de insercion directa.
El tamano de los subgrupos as como el total de estos puede
determinarlos el usuario para hacer mas eficiente el algoritmo.
Consideremos el siguiente arreglo de nmeros enteros

74, 14, 21, 44, 38, 97, 11, 78, 65, 88, 30
Shell nos propone que hagamos sobre el array una serie de ordenaciones
basadas en la insercion directa, pero dividiendo el array original en varios
sub-arrays tales que cada elemento este separado k elementos del anterior
(a esta separacion a menudo se le llama salto o gap)
Se debe empezar con k=n/2, siendo n el numero de elementos de array, y
utilizando siempre la division entera.... despues iremos
variando k haciendolo mas pequeno mediante sucesivas divisiones por 2,
hasta llegar a k=1.
Pero vamos a ello... En nuestro ejemplo, n=11 (porque hay 11 elementos).
As que k=n/2=11/2=5
Hemos formado 5 sub-arrays en los cuales los elementos estan separados

por 5 lugares (porque k=5). Hemos ordenado cada sub-array por separado
utilizando insercion directa, y hemos logrado que cada elemento se dirija
hacia su ubicacion definitiva en pasos de 5 lugares.
Por supuesto, no hemos terminado todava, pero resulta evidente que
algunos elementos, como el 30, el 97 o el 11 han dado un gran salto y que
no deben andar muy lejos de su sitio final.
Decimos ahora que el array esta 5-ordenado.
Para continuar con el algortimo, debemos ir reduciendo progresivamente k
dividiendolo sucesivamente por 2 y k-ordenando los subarrays que nos
salgan (recuerda que nos salen k sub-arrays). Cuando lleguemos a k=1
habremos terminado.
Radix.
Algoritmo: Quicksort
Descripcin.
Se elige un pivote.
Se reubican los elementos respecto al pivote los menores antes, los
mayores atras.
El arreglo queda separado en dos subarreglos
Se repite el proceso con los subarreglos resultantes
El arreglo esta ordenado
Se llama tambien Divide y Venceras
Pseudo-cdigo
quicksort(q)
variables arreglos menores, arrPivotes, mayores
si la longitud de q es menor o igual que 1
devolver q
sino
seleccionar un pivote de q
para cada elemento en q excepto el pivote
si el elemento < pivote entonces agregarlo al arreglo menores
si el elemento pivote entones agregarlo al arreglo mayores
agregar el pivote al arrPivotes

devolver unir(quicksort(menores), arrPivotes, quicksort(mayores))
Descripcin.
Es el algoritmo de ordenacin ms rpido.

Se basa en la tcnica divide y vencers, que consiste en ir subdividiendo el
array en arrays ms pequeos, y ordenar stos.
Para hacer esta divisin, se toma un valor del array como pivote, y se
mueven todos los elementos menores que este pivote a su izquierda, y los
mayores a su derecha. A continuacin se aplica el mismo mtodo a cada una

de las dos partes en las que queda dividido el array.
Despus de elegir el pivote se realizan dos bsquedas:
Una de izquierda a derecha, buscando un elemento mayor que el
pivote
Otra de derecha a izquierda, buscando un elemento menor que el
pivote.
Cuando se han encontrado los dos elementos anteriores, se intercambian, y
se sigue realizando la bsqueda hasta que las dos bsquedas se encuentran.
La implementacin del mtodo de ordenacin Quicksort es claramente
recursiva.
Ejecucin por pasos.
La eleccion del pivote determinara la eficiencia de este algoritmo ya

que determina la particion del array. Si consideramos que el array esta
desordenado, podemos elegir el primer elemento y el algoritmo
funcionara de forma eficiente.
Pero si el array esta casi ordenado, elegir el primer elemento como
pivote sera una mala solucion ya que obtendramos un subarray muy
pequeno y otro muy grande.
Por la misma razon, elegir el ultimo elemento del array como pivote
tambien es una mala idea.
Pretendemos conseguir que el tamano de los subarrays sea lo mas
parecido posible.
Una alternativa a elegir el primer elemento es elegir como pivote un
elemento al azar de entre todos los del array.
Otra estrategia es calcular la mediana de los valores de la izquierda,
centro y derecha del vector.
Por ejemplo para el vector: 9 8 1 6 10 2 3, se calcula la mediana de los
elementos que ocupan el primer lugar, el ultimo y el centro o sea 9 3 6.
La mediana es 6 que determinara las particiones {1 3 2} {6} {8 10 9}.
Ordenamiento por conteo.

Este metodo utiliza un arreglo auxiliar para contabilizar el numero de
llaves que son mayores que la llave actual.
El arreglo de contadores, especifica la posicion final donde debera
estar cada elemento.
Ejemplo:
Ordenamiento por distribucin.

Este mtodo es bueno aplicarlo cuando existen muchas claves repetidas y
estas se encuentran en un rango pequeo entre u y v.
Rango u<=K1..n<=v
Utiliza un arreglo contador con posiciones desde u hasta v, adems de un
arreglo para generar la salida.
COLECCIONES
COLECCIN MAP.
La Interface Map (java.io.Map) en Java, nos permite representar una
estructura de datos para almacenar pares clave/valor; de tal manera
que para una clave solamente tenemos un valor. Esta estructura de
datos tambien es conocida en otros lenguajes de programacion como

Diccionarios, aunque en cada lenguajes esta estructura de datos tiene
sus matices. Al igual que dijimos en la entrada de ArrayList en Java,
con ejemplos los Maps en java tienen implimentada por debajo toda
la teora de las estructuras de datos de los Arboles (AVL, B, B+, B*) por
tanto permiten anadir, eliminar y modificar elementos de forma
trasparente para el programador.
// Declaracin de un Map (un HashMap) con clave "Integer" y Valor
"String". Las claves pueden ser de cualquier tipo de objetos, aunque los ms
utilizados como clave son los objetos predefinidos de Java como String,
Integer, Double ... !!!!CUIDADO los Map no permiten datos atmicos
Map<Integer, String> nombreMap = new HashMap<Integer, String>();
nombreMap.size(); // Devuelve el numero de elementos del Map
nombreMap.isEmpty(); // Devuelve true si no hay elementos en el Map y
false si si los hay nombre
Map.put(K clave, V valor); // Aade un elemento al Map
nombreMap.get(K clave); // Devuelve el valor de la clave que se le pasa
como parmetro o 'null' si la clave no existe
nombreMap.clear(); // Borra todos los componentes del Map
nombreMap.remove(K clave); // Borra el par clave/valor de la clave que se
le pasa como parmetro
nombreMap.containsKey(K clave); // Devuelve true si en el map hay una
clave que coincide con K nombreMap.containsValue(V valor); // Devuelve
true si en el map hay un Valor que coincide con V nombreMap.values(); //
Devuelve una "Collection" con los valores del Map
Otro elemento importante a la hora de trabajar con los Maps (aunque
no lo es tanto como a la hora de trabajar con los ArrayList) son los
Iteradores (Iterator). Los Iteradores sirven para recorrer los Map y
poder trabajar con ellos. Los Iteradores solo tienen tres metodos que
son el hasNext() para comprobar que siguen quedando elementos en
el iterador, elnext() para que nos de el siguiente elemento del
iterador; y el remove() que sirve para eliminar el elemento del
Iterador. En realidad se puede prescindir de los iteradores para
trabajar con los Map ya que la gran ventaja de los Map frente a los
ArrayList, es que estos tienen una clave asociada al objeto y se les
puede buscar por la clave, aunque nunca esta de mas saber utilizar los
iteradores para manejar los Map.
Antes de seguir con ejemplos, os habreis dado cuenta que hemos
empezado la entrada diciendo que Map es una Interface y por tanto se
deben de implementar los metodos de la interface. Java ya tiene
implementadas varias clases Map. No vamos a explicar todas, pero si
las tres que consideramos mas importantes y utiles para que veais la
diferencia como son la clase HashMap, TreeMap y
LinkedHashMap. La diferencia principal de estas 3 clases es la forma
o el orden en las que guardan los valores en el Map. Si disteis en la
carrera de Ingeniera Informatica (o derivados) toda esa teora de
arboles (que no vamos a recordar aqu), verais que la gran diferencia
entre los arboles AVL, B, B+ y B* es la forma en la que guardan los

datos para despues optimizar las altas, bajas, modificaciones y
consultas de los valores. Pues bien toda esa teora en esta entrada
para nosotros es trasparente, pero esta bien que veamos estas tres
clases para que en funcion de vuestro problema elijais la mejor clase:
HashMap: Los elementos que inserta en el map no tendran un orden
especfico. No aceptan claves duplicadas ni valores nulos.
TreeMap: El Mapa lo ordena de forma natural. Por ejemplo, si la
clave son valores enteros (como luego veremos), los ordena de menos
a mayor.
LinkedHashMap: Inserta en el Map los elementos en el orden en el
que se van insertando; es decir, que no tiene una ordenacion de los
elementos como tal, por lo que esta clase realiza las busquedas de los
elementos de forma mas lenta que las demas clases.
Con un TreeMap
Map<Integer, String> treeMap = new TreeMap<Integer, String>();

treeMap.put(1, "Casillas");
treeMap.put(15, "Ramos");
treeMap.put(3, "Pique");
treeMap.put(5, "Puyol");
treeMap.put(11, "Capdevila");
treeMap.put(14, "Xabi Alonso");
treeMap.put(16, "Busquets");
treeMap.put(8, "Xavi Hernandez");
treeMap.put(18, "Pedrito");
treeMap.put(6, "Iniesta");
treeMap.put(7, "Villa");
// Imprimimos el Map con un Iterador que ya hemos instanciado
anteriormente
it = treeMap.keySet().iterator();
while(it.hasNext()){
Integer key = it.next();

System.out.println("Clave: " + key + " -> Valor: " +
treeMap.get(key));
}
El resultado que tenemos es el siguiente en el que vemos que nos

ordena los objetos por clave en orden natural:
Clave: 1 -> Valor: Casillas
Clave: 3 -> Valor: Pique
Clave: 5 -> Valor: Puyol
Clave: 6 -> Valor: Iniesta
Clave: 7 -> Valor: Villa
Clave: 8 -> Valor: Xavi Hernandez
Clave: 11 -> Valor: Capdevila
Clave: 14 -> Valor: Xabi Alonso
Clave: 15 -> Valor: Ramos
Clave: 16 -> Valor: Busquets
Clave: 18 -> Valor: Pedrito
Con un LinkedHashMap
Map<Integer, String> linkedHashMap = new

LinkedHashMap<Integer, String>();
linkedHashMap.put(1, "Casillas");
linkedHashMap.put(15, "Ramos");
linkedHashMap.put(3, "Pique");
linkedHashMap.put(5, "Puyol");
linkedHashMap.put(11, "Capdevila");
linkedHashMap.put(14, "Xabi Alonso");
linkedHashMap.put(16, "Busquets");
linkedHashMap.put(8, "Xavi Hernandez");
linkedHashMap.put(18, "Pedrito");
linkedHashMap.put(6, "Iniesta");
linkedHashMap.put(7, "Villa");
// Imprimimos el Map con un Iterador que ya hemos
instanciado anteriormente
it = linkedHashMap.keySet().iterator();
while(it.hasNext()){
Integer key = it.next();

System.out.println("Clave: " + key + " ->
Valor: " + linkedHashMap.get(key));
}
El resultado que tenemos es el siguiente en el que vemos que nos
ordena los objetos tal y como los hemos ido introduciendo:
Clave: 1 -> Valor: Casillas Clave: 15 -> Valor: Ramos Clave: 3 ->
Valor: Pique Clave: 5 -> Valor: Puyol Clave: 11 -> Valor: Capdevila
Clave: 14 -> Valor: Xabi Alonso Clave: 16 -> Valor: Busquets
Clave: 8 -> Valor: Xavi Hernandez Clave: 18 -> Valor: Pedrito
Clave: 6 -> Valor: Iniesta Clave: 7 -> Valor: Villa
Unidad 2do Parcial
Pilas
STACK
La clase Stack es una clase de las llamadas de tipo LIFO (Last In - First Out, o ltimo
en entrar - primero en salir). Esta clase hereda de la clase Vector y con 5
operaciones permite tratar un vector a modo de pila o stack.Las operaciones
bsicas son push (que introduce un elemento en la
pila), pop (que saca un elemento de la pila), peek (consulta el primer elemento de
la cima de la pila), empty (que comprueba si la pila est vaca) y search (que busca
un determinado elemento dentro de la pila y devuelve su posicin dentro de
ella).Esta clase es muy sencilla y al crear un objeto de tipo Stack con el
constructor bsico evidentemente no contendr ningn elemento.Un conjunto
mucho ms completo y consistente para operaciones de stack LIFO son
proporcionados en la interface De qu y sus implementaciones, pero nosotros de
momento vamos a limitarnos al estudio de la clase Stack.
Realizaremos un ejemplo a modo de uso de pila. Uno de los casos ms usados en
informtica de una pila es cuando queremos verificar si una determinada sentencia
o instruccin est equilibrada en cuanto a nmero de parntesis, corchetes o llaves
de apertura y cierre.
Cuando se escribe cdigo de programacin si no existe equilibrio entre signos de
apertura (por ejemplo un parntesis de apertura) y cierre (por ejemplo un
parntesis de cierre) ni siquiera debera procesarse la sentencia ya que no estara
formalmente bien construida.
De esto se encargan los analizadores lxicos de los compiladores.As que vamos a
utilizar esta vez tan solo una clase Programa con el mtodo main, donde vamos a ir
analizando una sentencia para verificar si es equilibrada o no en smbolos de
parntesis, recorriendo todos sus caracteres desde el inicio hasta el final.
Iremos construyendo nuestra pila apilando un smbolo (cada vez que detectemos
un smbolo de apertura o desapilando de ella cuando detectemos un smbolo de
cierre.
Tendremos que ir analizando todos los caracteres de una expresin y actuar
cuando detectemos un parntesis, operando en funcin de si el parntesis ledo es

de abrir (() o cerrar ()). El equilibrio en la escritura vendr determinado al
terminar el anlisis en funcin de si la pila est vaca (hay equilibrio) o contiene
algn elemento (no hay equilibrio).
Ejemplo: analizamos la expresin Hay varios pases (Mxico, Espaa) que
comparten el mismo idioma (espaol o castellano).
El resultado al finalizar el anlisis de la sentencia sera que la pila est vaca, y esto
querr decir que nuestra sentencia es equilibrada en parntesis y por tanto el
resultado es correcto.
Si analizramos la expresin Hay varios pases (Mxico, Espaa) que comparten el
mismo idioma (espaol o castellano.El resultado al finalizar el anlisis ser que
la pila contiene un parntesis, lo que quiere decir que la expresin no es
equilibrada y no tiene el mismo nmero de parntesis abiertos que cerrados.
Listas tipo Pilas.

Una lista se comporta como una pila si las inserciones y extracciones las hacemos
por un mismo lado de la lista. Tambin se las llama listas LIFO (Last In First Out ltimo en entrar primero en salir)Una pila al ser una lista puede almacenar en el
campo de informacin cualquier tipo de valor (int, char, float, vector de caracteres,
un objeto, etc) Para estudiar el mecanismo de utilizacin de una pila supondremos
que en el campo de informacin almacena un entero.Inicialmente la PILA est
vaca y decimos que el puntero raiz apunta a null (Si apunta a null decimos que no
tiene una direccin de memoria.
Insertamos un valor entero en la pila: insertar(10)
Luego de realizar la insercin la lista tipo pila queda de esta manera: un nodo con el valor
10 y raz apunta a dicho nodo. El puntero del nodo apunta a null ya que no hay otro nodo
despus de este.
Insertamos luego el valor 4: insertar(4)
Ahora el primer nodo de la pila es el que almacena el valor cuatro. raz apunta a
dicho nodo. Recordemos que raz es el puntero externo a la lista que almacena la
direccin del primer nodo. El nodo que acabamos de insertar en el campo puntero
guarda la direccin del nodo que almacena el valor 10.
EXTRACCION DE NODOS
Ahora qu sucede si extraemos un nodo de la pila. Cul se extrae? Como sabemos
en una pila se extrae el ltimo en entrar.Al extraer de la pila tenemos: extraer()
La pila ha quedado con un nodo.Hay que tener cuidado que si se extrae un nuevo
nodo la pila quedar vaca y no se podr extraer otros valores (avisar que la pila
est vaca)
Colas
Una cola es simplemente un lugar para almacenar cosas, donde esas cosas se
insertan una detrs de otra y para extraer siempre se lo hace por adelante de la
cola donde se encuentra el primer elemento. Una cola funciona como una fila o cola
de personas, que esperan su turno para ser atendidas, la primera persona atendida
es siempre la primera de la fila y cuando llega una persona y queremos
incorporarla a cola o adicionarla debemos hacerlo por detrs de la ultima persona
en la cola.
Con fines educativos una cola se la puede representar grficamente as:
Una cola puede almacenar lo que nosotros queramos, nmeros, personas,

documentos, cualquier cosa. Esta estructura de datos tiene muchas aplicaciones en
la informtica al igual que la pila, por ejemplo cuando mandan a imprimir varios
documentos a una impresora, existe una cola de impresin que sigue la filosofa, se
imprimen los primeros documentos y si quiero imprimir un nuevo documento se
adiciona al final de todos los documentos que estn esperando a imprimirse.
Una vez comprendido en concepto ahora veamos como se implementa esto en un
lenguaje de programacin, por ahora lo implementaremos en Java. Java en sus
libreras ya tiene la forma de implementar Colas (queue), nosotros ahora haremos
como si no existiera, es decir crearemos nuestra versin, que es lo que
generalmente se hace cuando se aprende colas en la universidad.
Los mtodos de una cola son:
esVacia() : boolean retorna verdad si la cola esta vaca es decir no tiene ningn
elemento, para esto solo se pregunta si inicio es igual afin.
esLlena() : booleanretorna verdad si es que la cola esta llena, pasa cuando se ha
llenado todo el vector, la cantidad de elemento que permite la cola lo determina
lavariable MAXIMO.
adicionar(int a)adiciona un nuevo elemento a la cola, para esto solo se incrementa
la variable fin y se coloca el elemento en esa posicin.
eliminar() : int extrae el primer elemento de la cola, para esto se retorna la
posicin inicio + 1 del vector y se incrementa inicio en 1.
tamanio() : intretorna la cantidad de elementos que tiene la cola, para realizar esto
se realiza la resta fin - inicio.
copiar(Cola B)copia tal cual la cola B a la cola destino, al finalizar cola B queda
totalmente vaca. Este mtodo es muy til al momento de hacer operaciones con
colas.
Estructura de datos: Es un conjunto de informacin.

Informacin: Pasa a ser un dato.
Dato: se forma al momento que se da la informacin.
Operaciones bsicas con la informacin

Ingresar la informacin
Modificar cpsula
Eliminar
Mostrar la informacin : Select from table
Pasar informacin
Ordenar
Comparar y buscar
Mover
Filas: Representan un registro
Columnas: Representan campos o atributos
Ordenamiento: es mucho mas fcil buscar si la informacin esta ordenada.
ndices de una tabla

Clave primaria: primer ndice que se crea en una tabla.
Clave fornea : segundo ndice que se crea en una tabla.
Qu pasara si una tabla no tiene ndice?

Va a ver registros repetitivos
No hubiera ordenamiento
Insercin Directa
Este mtodo consiste en buscar el lugar adecuado para cada registro recorriendo
los registros anteriores para dejar un lugar vaco para el nuevo elemento.
a) Ejemplo: 50,20,30,40
Ordenar de menor a mayor.

1)
0
50
2) 20<50
20
50
3) 40<20 (f)
40<50 (v)
20
40
50
4) 80<20 (f)
80<40 (f)
80<50 (f)
20
40
50
80
5) 30<20 (f)
30<40 (f)
20
30
40
50
80
Shell Sort.
Divide el arreglo a ordenar en varios grupos haciendo comparaciones e
intercambios entre ellos.
Quicksort.
Es el algoritmo de ordenamiento mas rapido.
Se reubican los elementos respecto al pivote los menores antes, los mayores
atrs.
Ordenamiento por conteo.

Poe medio de este mtodo contamos en un arreglo auxiliar cuantas veces se
encuentra cada nmero en el arreglo original. Una vez que tengamos las
veces que aparecen, podemos saber cuantos nmeros son menores
sumando las casillas anteriores. Ahora que conocemos la cantidad de datos
que son menores, podemos acomodar el dato en la casilla que le
corresponde.
Colecciones.
Es un conjunto de arreglos que pueden crecer en forma dinmica.
Array list
1. List
Linked List
2. Map
Forman parte de
arreglos.
Hash Map
Hash table
Linked hash map
Tree map
3. set
Enum set
Hash set
Linked hash set
Sorted set
Tree set
Cast:
es la conversin que se puede realizar como numero a string
COLECCIN MAP.
Nos permite representar una estructura de datos para almacenar pares
clave/valor; de tal manera que para una clave solamente tenemos un valor.
Subclases de la coleccin map.

HashMap
Los elementos que inserta en el map no tendran un oeden especifico no aceptan
duplicadas ni valores nulos.
TreeMap
El map los ordena de forma natural
LinkedHashMap
Inserta en el map los elementos en el orden en el que se va insertando,no tiene
orden de elementos como tal por utiliza de elementarios lentos.
2do Parcial - Clases

Estructura de datos que permite insertar,eliminar,elementos (PUSH insertar, POP
eliminar).
Recorrer los elementos de la pila (SEARCH).
Metologia Lifo In First Out Ultimo entra Primero que sale.
EJERCICIOS CON METODOS DE

ORDENAMIENTO.
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package ed2;
/**
*
* @author cbustamante
*/
import java.util.Random;
public class ED2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
// DEFINIR EL ARREGLO DONDE SE GENERAN LOS DATOS
int[] ArregloDatos = new int[10];
// GENERAR EL ARREGLO CON LOS DATOS AL RANDOM
Random rnd = new Random();
for (int i = 0; i < ArregloDatos.length; i++)
ArregloDatos[i] = rnd.nextInt(60);
// ESCRIBIR EL ALGORITMO DE INSERCION Y ORDENAR EL ARREGLO
// "ARREGLODATOS"
/*
Inicio
Para i=2 hasta N incremento 1
v = K(i) //elemento a acomodar
j=i
Mientras (j > 1) y (K(j-1) > v)
K(j) = K(j-1) //mueve elementos
j = j-1
K(j) = v // inserta el elemento actual
Fin
}
}
2. QUICKSORT
3. CONTEO
Ejemplo con diferentes mtodos
1. COLECCIN MAP: JUGADORES

//
package ed2;
/**
*
* @author cbustamante
*/
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.LinkedHashMap;
import java.util.Iterator;
public class ColeccionMap {
// de la coleccion map: HASHMAP
Map ColeccionHM = new HashMap<>();
// PRIMERA OPERACION CON LA COLECCION ES INSERTAR
// ELEMENTOS A LA COLECCION
// IMPLEMENTAR A LA SELECCION DE FUTBOL EN LA COLECCION
// MAP, EN SUS DIFERENTES SUBCLASES: HASHMAP, TREEMAP,
// LINKEDHASHMAP
ColeccionHM.put(1, "Alexander Dominguez"); //arquero
ColeccionHM.put(2, "Juan Paredes"); //lateral derecho
ColeccionHM.put(3, "Arturo Mina"); //central derecho
ColeccionHM.put(4, "Frickson Erazo"); // central izquierdo
ColeccionHM.put(5, "Oscar Bagui"); // lateral izquierdo
ColeccionHM.put(6, "Christian Noboa"); // mediocentro derecho
ColeccionHM.put(7, "Jefferson Montero"); //volante de contencion
ColeccionHM.put(8, "Osvaldo Lastra"); //mediocentro izquierdo

ColeccionHM.put(9, "Fidel Martinez"); //atacante derecho
ColeccionHM.put(10,"Miller Bolaos"); // centro delantero
ColeccionHM.put(11, "Enner Valencia"); //atacante izquierdo
ColeccionHM.put(12, "Gustavo Quintero"); // director tecnico
// SEGUNDA OPERACION CON LA COLECCION QUE ES LA DE
// LEER LOS ELEMENTOS QUE TIENE LA MISMA
// PARA LA LECTURA SE UTILIZA UN ELEMENTO QUE SE LLAMA
// "ITERATOR"
Iterator<Integer> IndiceC_HM = ColeccionHM.keySet().iterator();
// CON UNA ESTRUCTURA DE CONTROL "SE LEE" LOS ELEMENTOS DE LA
// COLECCION
while (IndiceC_HM.hasNext()) {
// 1.- Obtener su valor en una variable de trabajo
Integer llave = IndiceC_HM.next();
// 2.- Mostrar ese valor almacenado en la variable de trabajo
System.out.println("La clave es: " + llave + " y el valor es: " + ColeccionHM.get(llave));
} // del while
// TERCERA OPERACION: ELIMINAR ELEMENTOS DE LA COLECCION
// ?????????
2. COLECCIN TREEMAP : ASIGNATURAS

Map ColeccionTM = new TreeMap<>();
// IMPLEMENTAR LAS MATERIAS QUE SE NECESITAN REGISTRAR
// EN LA COLECCION MAP, EN SUS DIFERENTES SUBCLASES:
// TREEMAP,
ColeccionTM.put(100, "Fundamentos de Programacin I");
ColeccionTM.put(110, "Fundamentos de Administracin I");
ColeccionTM.put(120, "Matemticas I");
ColeccionTM.put(200, "Fundamentos de Programacin II");
ColeccionTM.put(210, "Contabilidad");
ColeccionTM.put(220, "Matemticas II");
ColeccionTM.put(300, "Estructura de Datos I");
ColeccionTM.put(310, "Programacin II");
ColeccionTM.put(320, "Base de Datos I");
ColeccionTM.put(400, "Estructura de Datos II");
ColeccionTM.put(410, "Programacin III");
ColeccionTM.put(420, "Base de Datos II");
ColeccionTM.put(500, "Programacin Web");
ColeccionTM.put(510, "Programacin Orientada a Objetos I");
ColeccionTM.put(520, "Tpicos Especiales");
// "ITERATOR"
Iterator<Integer> IndiceC_TM = ColeccionTM.keySet().iterator();
// COLECCION
while (IndiceC_TM.hasNext()) {
Integer llave = IndiceC_TM.next();
System.out.println("La llave es: " + llave + " y el valor es: " + ColeccionTM.get(llave));
} // del while
// de la coleccion map: TREEMAP
Map ColeccionLHM = new LinkedHashMap<>();
// IMPLEMENTAR LAS MATERIAS QUE SE NECESITAN REGISTRAR
// EN LA COLECCION MAP, EN SUS DIFERENTES SUBCLASES:
// TREEMAP,
ColeccionLHM.put(600, "Programacion III");
ColeccionLHM.put(520, "Topicos Especiales");
ColeccionLHM.put(300, "Estructura de Datos I");
ColeccionLHM.put(110, "Fundamentos de Administracion I");
ColeccionLHM.put(500, "Programacion Web");
ColeccionLHM.put(200, "Fundamentos de Programacion II");
ColeccionLHM.put(510, "Programacion Orientada a Objetos I");
ColeccionLHM.put(420, "Base de Datos II");
ColeccionLHM.put(120, "Matematicas I");
ColeccionLHM.put(310, "Programacion II");
ColeccionLHM.put(400, "Estructura de Datos II");
ColeccionLHM.put(210, "Contabilidad");
ColeccionLHM.put(320, "Base de Datos I");
ColeccionLHM.put(220, "Matematicas II");
ColeccionLHM.put(100, "Fundamentos de Programacion I");
// "ITERATOR"M
Iterator<Integer> IndiceC_LHM = ColeccionLHM.keySet().iterator();
// COLECCION
while (IndiceC_LHM.hasNext()) {
Integer llave = IndiceC_LHM.next();
System.out.println("La llave LHM es: " + llave + " y el valor es: " +
ColeccionTM.get(llave));
} // del while
} // del main
} // de la clase
/*
*/
3. COLECCION: DIGITO VERIFICADOR DE LA

CEDULA.
public class AppColeccionMap {
public static void main(String[]args){
//definir elcalculo del digito verificador de la cedula de identidad
//presentando al final dos cosas.
//1- por los primeros dos digitos- la provincia que pertenece.
//2- por los siguientes 3 digitos - la ciudad donde nacio.
HashMap<String,String> Provincia= new HashMap<>();
HashMap<String,String> Ciudades= new HashMap<>();
//llenar las llaves y valores de la conexion.
Provincia.put("01", "picincha");
Provincia.put("04", "carhi");
Provincia.put("09", "guayas");
Provincia.put("12", "los rios");
Provincia.put("13", "manabi");
Provincia.put("02", "galapago");
Provincia.put("08", "esmeraldas");
Provincia.put("11", "loja");
Provincia.put("24", "santa elena");
Provincia.put("22", "orellana");
//leer una sola en ellas.
String llave="09";
String valor=Provincia.get(llave);
//System.out.println("la llave es:"+llave+ "y el valor es:"+valor);

//recorrer en la coleccin
Iterator<String> IndiceC_prov=Provincia.keySet().iterator();
while(IndiceC_prov.hasNext()){
String contenido =IndiceC_prov.next();
System.out.println("la llave es:"+contenido+"y el valor es:"+Provincia.get(contenido));
}// del while
//el tamao de la coleccion.
System.out.println("el tamao de la coleccion es :"+Provincia.size());
//comprobar si la coleccion esta vacia o no.
boolean SiVacia= Provincia.isEmpty();
System.out.println("la coleccion es:"+si vaca);
//limpiar de todos los elementos de la coleccin.
Provincia.clear();
System.out.println("la coleccion es:"+Provincia.size());
boolean SiVacia1= Provincia.isEmpty();
System.out.println("la coleccion es:"+SiVacia1);
}
}
4.
COLECCIN HASHMAP: CIUDADES
public class ejer {

public static void main(String [] args){
HashMap<String, String> Provincia = new HashMap<>();
HashMap<String, String> Ciudades = new HashMap<>();
Ciudades.put("09100", "guayaquil");
Ciudades.put("09110", "duran");
Ciudades.put("09120", "daule");
Ciudades.put("09130", "nobol");
Ciudades.put("09140", "yaguachi");
Ciudades.put("09150", "jujan");
Ciudades.put("09160", "lomas de sargentillo");
Ciudades.put("09170", "Santa lucia");

Ciudades.put("09180", "palestina");
Ciudades.put("09190", "chongon");
Ciudades.put("09200", "pedro carbo");
Ciudades.put("09210", "isidro ayora");
String llave="09150";
String valor=Ciudades.get(llave);
Iterator<String> IndiceC_ciu=Ciudades.keySet().iterator();
while(IndiceC_ciu.hasNext()){
String contenido =IndiceC_ciu.next();
System.out.println("la llave es:" +contenido+"y el valor es:" +Ciudades.get(contenido));
}
System.out.println("el tamao de la coleccion es :"+Ciudades.size());
TreeMap CiudadOrdenada = new TreeMap(Ciudades);
System.out.println("Coleccion TreeMap es Ordenada:" + CiudadOrdenada);
}
}
Realizar los siguientes metodos:insercin,Shell Sort
CDIGO TALLER GRUPAL: Colecciones

package ESTRUCTURA;
import java.util.Scanner;
public class AppColeccionMap{
public static void main(String[] args){
String Contenido;
String Contenido3 = null;
String Contenido4;
String Contenido5;
int cont=0;
System.out.println("");
HashMap<String, String> CiudadesGuayaquil = new HashMap<>();
HashMap<String, String> CiudadesRios = new HashMap<>();
HashMap<String, String> CiudadesManabi = new HashMap<>();
System.out.println("COLECCION PROVINCIAS");
Provincia.put("01", "Los Rios");
Provincia.put("04", "Manabi");
Provincia.put("09", "Guayas");
Contenido="09";
String Contenido2="01";
Iterator<String> Leer_Masivo_Provincia= Provincia.keySet().iterator();
while (Leer_Masivo_Provincia.hasNext()){
Contenido = Leer_Masivo_Provincia.next();
}
System.out.println("La llave es:" +Contenido+ "y el valor es:"+Provincia.get(Contenido));
System.out.println("El tamao de la Coleccion es:" +Provincia.size());

System.out.println("COLECCION CIUDADES");
//GUAYAS
Ciudades.put("09162", "Guayaquil");
Ciudades.put("09163", "Duran");
Ciudades.put("09164", "Samborondon");
Ciudades.put("09165", "Simon Bolivar");
Ciudades.put("09166", "Balao");
Ciudades.put("09168", "Balzar");
Ciudades.put("09169", "General Villamil");
Ciudades.put("09170", "Milagros");
Ciudades.put("09171", "Isidro Ayora");
Ciudades.put("09172", "Lomas de Sargentillo");
Ciudades.put("09173", "Naranjito");
Ciudades.put("09174", "Pedro Carbo");
Ciudades.put("09175", "Palestina");
Ciudades.put("09176", "Santa Lucia");
Ciudades.put("09177", "El Triunfo");
Ciudades.put("09178", "Bucay");
Ciudades.put("09179", "Empalme");
Ciudades.put("1210", "Quevedo");
Ciudades.put("1211", "Babahoyo");
Ciudades.put("1212", "Vinces");
Ciudades.put("1213", "Baba");
Ciudades.put("1215", "Buena Fe");
Ciudades.put("1216", "Mocache");
Ciudades.put("1217", "Montalvo");
Ciudades.put("1218", "Palenque");
Ciudades.put("1219", "Urdaneta");
Ciudades.put("1220", "Valencia");
Ciudades.put("1221", "Ventanas");
Ciudades.put("1310", "Cascol");
Ciudades.put("1311", "Chone");
Ciudades.put("1312", "Manta");
Ciudades.put("1312", "Bolivar");
Ciudades.put("1312", "Caar");
Ciudades.put("1312", "Pichcincha");
Ciudades.put("1312", "Pajan");
Ciudades.put("1312", "San Vicente");

Ciudades.put("1312", "Puerto Lopez");
Ciudades.put("1312", "Olmedo");
Ciudades.put("1312", "Junin");
Ciudades.put("1312", "Pedernales");
Ciudades.put("1312", "Montecristi");
Ciudades.put("1312", "Tosagua");
Ciudades.put("1312", "24 de Mayo");
Ciudades.put("1312", "Santa Anas");
Ciudades.put("1312", "El Carmen");
Ciudades.put("1312", "Flavio Alfaro");
Ciudades.put("1312", "Jaramijo");
Ciudades.put("1312", "Jipijapa");
Ciudades.put("1312", "Rocafuerte");
Ciudades.put("1312", "Sucre");
Ciudades.put("1312", "Jama");
Iterator<String> Leer_Masivo_Ciudad = Ciudades.keySet().iterator();
while (Leer_Masivo_Ciudad.hasNext()){
String Contenido1 = Leer_Masivo_Ciudad.next();
System.out.println("La llave es:" +Contenido1+ "y el valor es:"+Ciudades.get(Contenido1));
}
CiudadesGuayaquil.put("09162", "Guayaquil");
CiudadesGuayaquil.put("09163", "Duran");
CiudadesGuayaquil.put("09164", "Samborondon");
CiudadesGuayaquil.put("09165", "Simon Bolivar");
CiudadesGuayaquil.put("09166", "Balao");
CiudadesGuayaquil.put("09167", "yaguachi");
CiudadesGuayaquil.put("09168", "Balzar");
CiudadesGuayaquil.put("09169", "General Villamil");
CiudadesGuayaquil.put("09170", "Milagros");
CiudadesGuayaquil.put("09171", "Isidro Ayora");
CiudadesGuayaquil.put("09172", "Lomas de Sargentillo");
CiudadesGuayaquil.put("09173", "Naranjito");
CiudadesGuayaquil.put("09174", "Pedro Carbo");
CiudadesGuayaquil.put("09175", "Palestina");
CiudadesGuayaquil.put("09176", "Santa Lucia");
CiudadesGuayaquil.put("09178", "Bucay");
CiudadesGuayaquil.put("09179", "Empalme");
Iterator<String> Leer_Masivo_CiudadGuayaquil = CiudadesGuayaquil.keySet().iterator();

while (Leer_Masivo_CiudadGuayaquil.hasNext()){
Contenido3 = Leer_Masivo_CiudadGuayaquil.next();
String Obtener_ciudades= Contenido3+CiudadesGuayaquil.get(Contenido3);
}
CiudadesRios.put("1210", "Quevedo");
CiudadesRios.put("1211", "Babahoyo");
CiudadesRios.put("1212", "Vinces");
CiudadesRios.put("1213", "Baba");
CiudadesRios.put("1215", "Buena Fe");

CiudadesRios.put("1216", "Mocache");
CiudadesRios.put("1217", "Montalvo");
CiudadesRios.put("1218", "Palenque");
CiudadesRios.put("1219", "Urdaneta");
CiudadesRios.put("1220", "Valencia");
CiudadesRios.put("1221", "Ventanas");
Iterator<String> Leer_Masivo_CiudadRios = CiudadesRios.keySet().iterator();
while (Leer_Masivo_CiudadRios.hasNext()){
Contenido4= Leer_Masivo_CiudadRios.next();
String Obtener_ciudadesR= Contenido4+CiudadesRios.get(Contenido4);
}
System.out.println();
System.out.println("INTRODUCE EL CODIGO DE LA PROVINCIA:");
Scanner sc = new Scanner(System.in);
int codigo;
codigo =sc.nextInt();
if (codigo ==9){
for(int i=0; i< CiudadesGuayaquil.size(); i++) {
cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido)+ "y la cantidad de
ciudades es: "+ cont);
}
if (codigo ==01){
for(int i=0; i< CiudadesRios.size(); i++) {
cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido2)+ "y la cantidad de
}
CiudadesManabi.put("1310", "Cascol");
CiudadesManabi.put("1312", "Chone");
CiudadesManabi.put("1313", "Manta");
CiudadesManabi.put("1314", "Bolivar");
CiudadesManabi.put("1315", "Caar");
CiudadesManabi.put("1316", "Pichcincha");
CiudadesManabi.put("1317", "Pajan");
CiudadesManabi.put("1318", "San Vicente");
CiudadesManabi.put("1319", "Puerto Lopez");
CiudadesManabi.put("1320", "Olmedo");
CiudadesManabi.put("1321", "Junin");
CiudadesManabi.put("1322", "Pedernales");
CiudadesManabi.put("1323", "Montecristi");
CiudadesManabi.put("1324", "Tosagua");
CiudadesManabi.put("1325", "24 de Mayo");
CiudadesManabi.put("1326", "Santa Anas");

CiudadesManabi.put("1327", "El Carmen");
CiudadesManabi.put("1328", "Flavio Alfaro");
CiudadesManabi.put("1329", "Jaramijo");
CiudadesManabi.put("1330", "Jipijapa");
CiudadesManabi.put("1331", "Rocafuerte");
CiudadesManabi.put("1332", "Sucre");
CiudadesManabi.put("1333", "Jama");
Iterator<String> Leer_Masivo_CiudadManabi = CiudadesManabi.keySet().iterator();
while (Leer_Masivo_CiudadManabi.hasNext()){
Contenido5= Leer_Masivo_CiudadManabi.next();
String Obtener_ciudadesM= Contenido5+CiudadesManabi.get(Contenido5);
}
if (codigo ==04){
for(int i=0; i< CiudadesManabi.size(); i++) {
cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido7)+ "y la cantidad de
}
}
Tarea # 1 :CDIGO
package EstructuradeDatos;
public class deber1 {
// TODO Auto-generated method stub
int [] k= new int [10];
int v;
for (int i = 0; i < k.length ; i++) {
k[i]= (int)(Math.random()*60);
System.out.print( k[i]+"\t");
v=k[i];
for (int j= i-1; j>=0 && k[j]>v ; j--) {
k[j+1]=k [j];
k[j]=v;
}
//System.out.println();
}
System.out.println("Datos Ordenados");
for (int x= 0; x < k.length ; x++) {
System.out.print( k[x]+"\t");
}
}
VISUALIZACIN
Tarea #2 :CDIGO
public class deber2 {

int[]K= new int[10];

Random rnd= new Random();
for(int j=0;j<K.length;j++){
K[j]=rnd.nextInt(60);
System.out.print(K[j]+"\t");
}
for(int i=1;i<K.length;i++){
for(int j=0;j<K.length-1;j++){
if(K[j]>K[j+1]){
int reemplazar_areglo=K[j];
K[j]=K[j+1];
K[j+1]=reemplazar_areglo;
}
}
}
System.out.println("Metodo Burbuja");
for (int w= 0; w< K.length ; w++) {
System.out.print(
K[w]+"\t");
}
}
}
VISUALIZACIN
Tarea #3: CDIGO INSERCIN DIRECTA - TIMER

public class deberTimerInsercion {

long inicio=System.nanoTime();
int [] k= new int [10];
int v;
for (int i = 0; i < k.length ; i++) {
k[i]= (int)(Math.random()*60);
System.out.print(
k[i]+"\t");
v=k[i];
for (int j= i-1; j>=0 && k[j]>v ; j--) {
k[j+1]=k [j];
k[j]=v;
}
for (int x= 0; x < k.length ; x++) {
System.out.print( k[x]+"\t");
}
long fin=System.nanoTime();
long tiempo=fin-inicio;
System.out.println("Tiempo:"+tiempo);
}
}
VISUALIZACIN
CDIGO BURBUJA TIMER

public class deberTimerBurbuja {

int[]K= new int[10];
Random rnd= new Random();
for(int j=0;j<K.length;j++){
K[j]=rnd.nextInt(60);
System.out.print(K[j]+"\t");
}
for(int i=1;i<K.length;i++){
for(int j=0;j<K.length-1;j++){
if(K[j]>K[j+1]){
int reemplazar_areglo=K[j];
K[j]=K[j+1];
K[j+1]=reemplazar_areglo;
}
}
}
for (int w= 0; w< K.length ; w++) {
System.out.print(
K[w]+"\t");
}
}
}
VISUALIZACIN
CDIGO SHELL SORT- TIMER

public class deberTimerShellsort {
private static final long inicio = 0;

public static void main(String args[]){
int arreglo_dato[]={14,58,96,11,12,45,8,85};
shellSort(arreglo_dato);
for (int i=0;i < arreglo_dato.length;i++){
System.out.print(arreglo_dato[i]+"\t");
}
}
public static void shellSort( int a[ ]){
for( int k= a.length / 2; k > 0; k = k == 2 ? 1 : (int) ( k /
2.2 ) ){
for( int i = k; i < a.length; i++ ){
int auxiliar = a[ i ];
int j;
for(j = i; j >= k && auxiliar <
k ){
a[ j ] = a[ j - k];
}
a[ j ] = auxiliar;
}
a[ j - k ] ; j -=
}
}
VISUALIZACIN
Tarea #4 :CDIGO QUICK SORT - TIMER

import java.util.Arrays;
public class debertimerQuickSort {

int[] arreglo = { 8, 1, 4, 7, 3, 7,
10,223,356,1,345,8789,7234,554,665,88,77};
System.out.println(Arrays.toString(arreglo));
int arreglar = 0;
int high = arreglo.length - 1;
quickSort(arreglo, arreglar, high);
System.out.println(Arrays.toString(arreglo));
}
public static void quickSort(int[] array, int arreglar,
int high) {
if (array == null || array.length == 0)
return;
if (arreglar >= high)

return;
int respuesta = arreglar + (high - arreglar) / 2;
int pivot = array[respuesta];

// Gire a la izquierda <pivote y derecho> pivote
int i = arreglar, j = high;
while (i <= j) {
while (array[i] < pivot) {
i++;
}
while (array[j] > pivot) {
j--;
}
if (i <= j) {
int auxiliar = array[i];
array[i] = array[j];
array[j] = auxiliar;
i++;
j--;
}
}
// Recursiva especie de dos sub-partes
if (arreglar < j)
quickSort(array, arreglar, j);
if (high > i)
quickSort(array, i, high);
long fin =System.nanoTime();
System.out.println("Tiempo:"+ tiempo);
}
}
VISUALIZACIN
CDIGO CONTEO TIMER

public class deberTimerConteo {
public static class CountingSort {
static int minimo,maximo;
int[] Arreglo_orden
={28,44,64,56,76,1,3,4,176,9,7,9,234,15434,95};//arreglo a ordenar
mostrar(Arreglo_orden);//imprimir original
counting_sort(Arreglo_orden,rango(Arreglo_orden));//llamado a funcion de
ordenamiento
mostrar(Arreglo_orden);//imprimir ordenado
}
public static void mostrar(int[] arreglo){//imprimir arreglo
for(int i=0;i<arreglo.length;i++){
System.out.print(arreglo[i]+",");
}
}
public static int rango(int [] array){//calcula el max y min
y devuelve la diferencia
//Se utiliza para conocer el tamao del arreglo auxiliar
maximo=array[0];
minimo=array[0];
for(int i=0;i<array.length;i++){
if(array[i]<minimo)
minimo=array[i];
if(array[i]>maximo)
maximo=array[i];
}
return maximo-minimo;
}
public static void counting_sort(int[] A,int k){//k
diferencia entre max y min
int[] auxiliar = new int[k+1];//Array aux servira para
contar frecuencias,Se suma 1 para incluir al minimo
for(int i=0;i<=k;i++){//Se inicializan frecuencias 0
auxiliar[i]=0;
}
for(int j=0;j<A.length;j++){//se recorre arreglo a
ordenar y se suma 1 por cada vez que se encuentra
auxiliar[A[j]-minimo]+=1;
//el numero
}
int x=0;//recorrer arreglo final/original
for(int i=0;i<auxiliar.length;i++){//recorre frecuencias
(arrego aux)
for(int j=0;j<auxiliar[i];j++){//las veces que
aparece el num
A[x]=i+minimo;
x++;//siguiente posicion del arreglo ordenado
long fin =System.nanoTime();
System.out.println("Tiempo:"+ tiempo);
}
}
}
}}
VISUALIZACIN
Tarea #5 :CDIGO REMOVE

package ESTRUCTURA;
import java.util.Map;
public class COLECCIONMAP {
// de la coleccion map:HASHMAP
Map ColeccionHM = new HashMap<>();
ColeccionHM.put(1, "Alexander Dominguez"); //arquero
ColeccionHM.put(2,"Juan Carlos Paredes"); //lateral derecho
ColeccionHM.put(3,"Arturo Mina"); //central derecho
ColeccionHM.put(4,"Frickzon Erazo"); //central izquierdo
ColeccionHM.put(5,"Oscar Bagui"); //lateral izquierdo
ColeccionHM.put(6,"Christhian Noboa"); //mediocentro derecho
ColeccionHM.put(7,"Jefferson Montero"); //volante de contencion
ColeccionHM.put(8,"Oswaldo Lastra"); //mediocentro izquierdo
ColeccionHM.put(9,"Fidel Martinez"); //atacante derecho
ColeccionHM.put(10,"Miller Bolaos"); //centro delantero
ColeccionHM.put(11,"Enner Valencia"); //atacante izquierdo
ColeccionHM.put(0,"Gustavo Quintero"); //director tecnico
//LEER LOS ELEMENTOS QUE TIENEN LA MISMA
//PARA LA ALECTURA SE UTILIZA UN ELEMENTO QUE SE LLAMA
//"ITERATOR"
ColeccionHM.remove(0);
ColeccionHM.remove(10);
Iterator<Integer> IndiceC_HM = ColeccionHM.keySet().iterator();
//
CON UNA ESTRUCTURA DE CONTROL " SE LEE" LOS ELEMENTOS DE LA
//COLECCION
while(IndiceC_HM.hasNext()){
//1._ Obtener su valor en una variable de trabajo
Integer llave= IndiceC_HM.next();
//2._ Mostrar su valor alamacenado en la variable de
trabajo
System.out.println("la clave es : " + llave + " y el
valor es:"+ ColeccionHM.get(llave));
}// del while
}
}
VISUALIZACIN
Tarea #6 :CDIGO TALLER GRUPAL

package ESTRUCTURA;
import java.util.Scanner;
public class AppColeccionMap{
String Contenido;
String Contenido3 = null;
String Contenido4;
String Contenido5;
int cont=0;
HashMap<String, String> CiudadesGuayaquil = new HashMap<>();
HashMap<String, String> CiudadesRios = new HashMap<>();
HashMap<String, String> CiudadesManabi = new HashMap<>();
System.out.println("COLECCION PROVINCIAS");
Provincia.put("01", "Los Rios");
Provincia.put("04", "Manabi");
Provincia.put("09", "Guayas");
Contenido="09";
Iterator<String> Leer_Masivo_Provincia= Provincia.keySet().iterator();
while (Leer_Masivo_Provincia.hasNext()){
Contenido = Leer_Masivo_Provincia.next();
System.out.println("La llave es:" +Contenido+ "y el valor
es:"+Provincia.get(Contenido));
}
System.out.println("El tamao de la Coleccion es:" +Provincia.size());
System.out.println("COLECCION CIUDADES");
//GUAYAS
Ciudades.put("09162", "Guayaquil");
Ciudades.put("09163", "Duran");
Ciudades.put("09164", "Samborondon");
Ciudades.put("09165", "Simon Bolivar");
Ciudades.put("09166", "Balao");
Ciudades.put("09168", "Balzar");
Ciudades.put("09169", "General Villamil");
Ciudades.put("09170", "Milagros");
Ciudades.put("09171", "Isidro Ayora");
Ciudades.put("09172", "Lomas de Sargentillo");
Ciudades.put("09173", "Naranjito");
Ciudades.put("09174", "Pedro Carbo");
Ciudades.put("09175", "Palestina");
Ciudades.put("09176", "Santa Lucia");
Ciudades.put("09177", "El Triunfo");
Ciudades.put("09178", "Bucay");
Ciudades.put("09179", "Empalme");
Ciudades.put("1210", "Quevedo");
Ciudades.put("1212", "Vinces");
Ciudades.put("1213", "Baba");
Ciudades.put("1215", "Buena Fe");
Ciudades.put("1216", "Mocache");
Ciudades.put("1217", "Montalvo");
Ciudades.put("1218", "Palenque");
Ciudades.put("1219", "Urdaneta");
Ciudades.put("1220", "Valencia");
Ciudades.put("1221", "Ventanas");
Ciudades.put("1310", "Cascol");
Ciudades.put("1311", "Chone");
Ciudades.put("1312", "Manta");
Ciudades.put("1312", "Bolivar");
Ciudades.put("1312", "Caar");
Ciudades.put("1312", "Pichcincha");
Ciudades.put("1312", "Pajan");
Ciudades.put("1312", "San Vicente");
Ciudades.put("1312", "Puerto Lopez");
Ciudades.put("1312", "Olmedo");
Ciudades.put("1312", "Junin");
Ciudades.put("1312", "Pedernales");
Ciudades.put("1312", "Montecristi");
Ciudades.put("1312", "Tosagua");
Ciudades.put("1312", "24 de Mayo");
Ciudades.put("1312", "Santa Anas");
Ciudades.put("1312", "El Carmen");
Ciudades.put("1312", "Flavio Alfaro");
Ciudades.put("1312", "Jaramijo");
Ciudades.put("1312", "Jipijapa");
Ciudades.put("1312", "Rocafuerte");
Ciudades.put("1312", "Sucre");
Ciudades.put("1312", "Jama");
Iterator<String> Leer_Masivo_Ciudad = Ciudades.keySet().iterator();
while (Leer_Masivo_Ciudad.hasNext()){
String Contenido1 = Leer_Masivo_Ciudad.next();
System.out.println("La llave es:" +Contenido1+ "y el valor
es:"+Ciudades.get(Contenido1));
}
CiudadesGuayaquil.put("09162", "Guayaquil");
CiudadesGuayaquil.put("09163", "Duran");
CiudadesGuayaquil.put("09164", "Samborondon");
CiudadesGuayaquil.put("09165", "Simon Bolivar");
CiudadesGuayaquil.put("09166", "Balao");
CiudadesGuayaquil.put("09167", "yaguachi");
CiudadesGuayaquil.put("09168", "Balzar");
CiudadesGuayaquil.put("09169", "General Villamil");
CiudadesGuayaquil.put("09170", "Milagros");
CiudadesGuayaquil.put("09171", "Isidro Ayora");
CiudadesGuayaquil.put("09172", "Lomas de Sargentillo");
CiudadesGuayaquil.put("09173", "Naranjito");
CiudadesGuayaquil.put("09174", "Pedro Carbo");
CiudadesGuayaquil.put("09175", "Palestina");
CiudadesGuayaquil.put("09176", "Santa Lucia");
CiudadesGuayaquil.put("09178", "Bucay");
CiudadesGuayaquil.put("09179", "Empalme");
Iterator<String> Leer_Masivo_CiudadGuayaquil =
CiudadesGuayaquil.keySet().iterator();
while (Leer_Masivo_CiudadGuayaquil.hasNext()){
Contenido3 = Leer_Masivo_CiudadGuayaquil.next();
String Obtener_ciudades= Contenido3+CiudadesGuayaquil.get(Contenido3);
}
CiudadesRios.put("1210", "Quevedo");
CiudadesRios.put("1212", "Vinces");
CiudadesRios.put("1213", "Baba");
CiudadesRios.put("1215", "Buena Fe");
CiudadesRios.put("1216", "Mocache");
CiudadesRios.put("1217", "Montalvo");
CiudadesRios.put("1218", "Palenque");
CiudadesRios.put("1219", "Urdaneta");
CiudadesRios.put("1220", "Valencia");
CiudadesRios.put("1221", "Ventanas");
Iterator<String> Leer_Masivo_CiudadRios = CiudadesRios.keySet().iterator();
while (Leer_Masivo_CiudadRios.hasNext()){
Contenido4= Leer_Masivo_CiudadRios.next();
String Obtener_ciudadesR= Contenido4+CiudadesRios.get(Contenido4);
}
System.out.println("INTRODUCE EL CODIGO DE LA PROVINCIA:");
Scanner sc = new Scanner(System.in);
int codigo;
codigo =sc.nextInt();
if (codigo ==9){
for(int i=0; i< CiudadesGuayaquil.size(); i++) {
cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido)+ "y la
cantidad de ciudades es: "+ cont);
}
if (codigo ==01){
for(int i=0; i< CiudadesRios.size(); i++) {

cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido2)+ "y
la cantidad de ciudades es: "+ cont);
}
CiudadesManabi.put("1312", "Chone");
CiudadesManabi.put("1313", "Manta");
CiudadesManabi.put("1314", "Bolivar");
CiudadesManabi.put("1315", "Caar");
CiudadesManabi.put("1316", "Pichcincha");
CiudadesManabi.put("1317", "Pajan");
CiudadesManabi.put("1318", "San Vicente");
CiudadesManabi.put("1319", "Puerto Lopez");
CiudadesManabi.put("1320", "Olmedo");
CiudadesManabi.put("1321", "Junin");
CiudadesManabi.put("1322", "Pedernales");
CiudadesManabi.put("1323", "Montecristi");
CiudadesManabi.put("1324", "Tosagua");
CiudadesManabi.put("1325", "24 de Mayo");
CiudadesManabi.put("1326", "Santa Anas");
CiudadesManabi.put("1327", "El Carmen");
CiudadesManabi.put("1328", "Flavio Alfaro");
CiudadesManabi.put("1329", "Jaramijo");
CiudadesManabi.put("1330", "Jipijapa");
CiudadesManabi.put("1331", "Rocafuerte");
CiudadesManabi.put("1332", "Sucre");
CiudadesManabi.put("1333", "Jama");
Iterator<String> Leer_Masivo_CiudadManabi =
CiudadesManabi.keySet().iterator();
while (Leer_Masivo_CiudadManabi.hasNext()){
Contenido5= Leer_Masivo_CiudadManabi.next();
String Obtener_ciudadesM= Contenido5+CiudadesManabi.get(Contenido5);
}
if (codigo ==04){
for(int i=0; i< CiudadesManabi.size(); i++) {
cont= i+1;
}
System.out.println("pertenece a la provincia del:"+Provincia.get(Contenido7)+ "y

la cantidad de ciudades es: "+ cont);
}
}
}
VISUALIZACIN
Tareas Grupales: 2do

Parcial
Tarea #1
1. crear una coleccin Map,llamada nmero y letras
2. ingresar en la coleccin los primeros 25 nmeros con su respectiva
denominacin en letras.
3. general al rango 15 nmeros que estn entre 1y 25 realizar
4. leer el arreglo de la coleccin si existe la llave numgenerado
mostrar el valor de la coleccin
import
import
import
import
public
java.util.Iterator;
java.util.Map;
java.util.HashMap;
java.util.Random;
class ESTRUCTURA_DEBER {
int[]Arreglo1= new int[15];
Map<Integer, String> numeroyletras = new HashMap<>();
// ingreso en la coleccion los primeros 25 numeros
numeroyletras.put(1, "UNO");
numeroyletras.put(2,"DOS");
numeroyletras.put(3,"TRES");
numeroyletras.put(4,"CUATRO");
numeroyletras.put(5,"CINCO");
numeroyletras.put(6,"SEIS");
numeroyletras.put(7,"SIETE");
numeroyletras.put(8,"OCHO");
numeroyletras.put(9,"NUEVE");
numeroyletras.put(10,"DIEZ");
numeroyletras.put(11,"ONCE");
numeroyletras.put(12,"DOCE");
numeroyletras.put(13, "TRECE");
numeroyletras.put(14,"CATORCE");
numeroyletras.put(15,"QUINCE");
numeroyletras.put(16,"DIECISEIS");
numeroyletras.put(17,"DIECISIETE");
numeroyletras.put(18,"DIECIOCHO");
numeroyletras.put(19,"DIECINUEVE");
numeroyletras.put(20,"VEINTE");
numeroyletras.put(21,"VEINTIUNO");
numeroyletras.put(22,"VEINTIDOS");
numeroyletras.put(23,"VEINTITRES");
numeroyletras.put(24,"VEINTICUATRO");
numeroyletras.put(25,"VEINTICINCO");
// GENERAMOS AL RANDOM 15 NUMEROS QUE ESTEN ENTRE 1 Y 25
Random NUMEROS= new Random();
for(int i=0;i<15;i++){
int numero=NUMEROS.nextInt(25)+1;
Arreglo1[i]=numero;
System.out.println("los valores random son:" +Arreglo1[i]);
}
System.out.println(" la coleccin elegidos aleatoriamente es : ");
for(int i=0;i<15;i++){
Integer llave =Arreglo1[i];
String valor = numeroyletras.get(llave);
if(llave==Arreglo1[i]){
System.out.println("La llave es : " +llave+ " y el valor
es : " + valor);
}
}
}
Tarea #2
DEBER DE ESTRUCTURA DE DATOS II
LISTAS ENLAZADAS
CLASES
NUEVALISTA
package PilasyColumnas;
public class NuevaLista {
ClsLista X= new ClsLista();
// INGRESO DE DATOS
X.insert(new String("*MARCOS CUENCA " +" 20 aos " +" 1224 "));
X.insert(new String("/KEVIN MORAN "+ " 19 aos "+ " 2512 "));
X.insert(new String("-KATHERINE BAGUI" +" 18 aos"+ " 3442 "));
// PRESENTACION
X.print(0);
X.print(1);
X.print(2);
}
}
CLSnodos
public class Clsnodos {
private Object info;
private Clsnodos next;
public Clsnodos() {
info = null;
next = null;
}
public Clsnodos(Object o, Clsnodos n) {
setInfo(o);
setNext(n);
}
public void setInfo(Object o) {
info = o;
}
public void setNext(Clsnodos n) {
next = n;
}
public Object getInfo() {
return info;
}
public Clsnodos getNext() {
return next;
}
}
ClsLista
public class ClsLista {

protected Clsnodos first;
// a list is created in an empty state
public ClsLista() {
first = null;
}
// the new element is located before the
// former first node
public void insert(Object o) {
// step by step code. Could be done in less lines
// a node that stores the object and links nowhere
Clsnodos tmp = new Clsnodos(o, null);
// the following sentence has no problem with null values of
"first"
tmp.setNext(first);
// we move the "first" reference
first = tmp;
}
// extracts the first element and returns its object
public Object extract() {
Object out = null;
// if first is null, you cannot call its methods
if (!isEmpty()) {
out = first.getInfo();
first = first.getNext();
}
// if the list is empty, null should be returned, but this
is
// the default value of "out"
return out;
}
public void print(int n) {
// if the list is empty, do nothing
if (!isEmpty()) {
Clsnodos tmp = first;
// iterates until i reaches n or the list is finished.
for (int i = 0; i < n; i++) {
tmp = tmp.getNext();
if (tmp == null)
return; // the list is finished
}
System.out.println(tmp.getInfo());
}
}
public void print() {
// if the list is empty, do nothing
if (!isEmpty()) {
Clsnodos tmp = first;
// iterates until the list is finished

while (tmp != null) {
System.out.println(tmp.getInfo());
tmp = tmp.getNext();
}
}
}
public boolean isEmpty() {
if (first == null)
return true;
else
return false;
}
}
Visualizacin:

Elvis Tapia Curso 4 Grupo 3 - PortafolioEstructuraDatos

Caricato da

Informazioni sul documento

Descrizione originale:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Elvis Tapia Curso 4 Grupo 3 - PortafolioEstructuraDatos

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD DE GUAYAQUIL

PORTAFOLIO DE ESTRUCTURA DE DATOS II

4.2 Ejercicios de colecciones.

Coleccin MAP: Jugadores

Dedico este xito a mi Dios que me da el privilegio de vivir y de seguir

Unidad 1er Parcial

Ordenamiento por insercin directa.

Este metodo realiza comparaciones de todas las posibles parejas de

Consideremos el siguiente arreglo de nmeros enteros

Hemos formado 5 sub-arrays en los cuales los elementos estan separados

variables arreglos menores, arrPivotes, mayores

si la longitud de q es menor o igual que 1

para cada elemento en q excepto el pivote

si el elemento < pivote entonces agregarlo al arreglo menores

si el elemento pivote entones agregarlo al arreglo mayores

agregar el pivote al arrPivotes

Es el algoritmo de ordenacin ms rpido.

mayores a su derecha. A continuacin se aplica el mismo mtodo a cada una

Ejecucin por pasos.

La eleccion del pivote determinara la eficiencia de este algoritmo ya

Ordenamiento por conteo.

Ordenamiento por distribucin.

datos tambien es conocida en otros lenguajes de programacion como

entre los arboles AVL, B, B+ y B* es la forma en la que guardan los

Map<Integer, String> treeMap = new TreeMap<Integer, String>();

Integer key = it.next();

El resultado que tenemos es el siguiente en el que vemos que nos

Map<Integer, String> linkedHashMap = new

Integer key = it.next();

Unidad 2do Parcial

cuando detectemos un parntesis, operando en funcin de si el parntesis ledo es

Listas tipo Pilas.

Insertamos un valor entero en la pila: insertar(10)

Con fines educativos una cola se la puede representar grficamente as:

Una cola puede almacenar lo que nosotros queramos, nmeros, personas,

Estructura de datos: Es un conjunto de informacin.

Operaciones bsicas con la informacin

ndices de una tabla

Qu pasara si una tabla no tiene ndice?

Ordenar de menor a mayor.

Ordenamiento por conteo.

es la conversin que se puede realizar como numero a string

Subclases de la coleccin map.

2do Parcial - Clases

EJERCICIOS CON METODOS DE

Ejemplo con diferentes mtodos

1. COLECCIN MAP: JUGADORES

ColeccionHM.put(8, "Osvaldo Lastra"); //mediocentro izquierdo

2. COLECCIN TREEMAP : ASIGNATURAS

3. COLECCION: DIGITO VERIFICADOR DE LA

//System.out.println("la llave es:"+llave+ "y el valor es:"+valor);

COLECCIN HASHMAP: CIUDADES

public class ejer {

Ciudades.put("09170", "Santa lucia");

Realizar los siguientes metodos:insercin,Shell Sort

CDIGO TALLER GRUPAL: Colecciones

System.out.println("La llave es:" +Contenido+ "y el valor es:"+Provincia.get(Contenido));

System.out.println("El tamao de la Coleccion es:" +Provincia.size());

Ciudades.put("1312", "San Vicente");

Iterator<String> Leer_Masivo_CiudadGuayaquil = CiudadesGuayaquil.keySet().iterator();

CiudadesRios.put("1215", "Buena Fe");

CiudadesManabi.put("1326", "Santa Anas");

int [] k= new int [10];