elvis tapia curso 4 grupo 3 - portafolioestructuradatos

7/23/2019 Elvis Tapia Curso 4 Grupo 3 - PortafolioEstructuraDatos

http://slidepdf.com/reader/full/elvis-tapia-curso-4-grupo-3-portafolioestructuradatos 1/66

UNIVERSIDAD DE GUAYAQUIL

PORTAFOLIO DE ESTRUCTURA DE DATOS II

AUTOR:

Tlgo. Elvis tapia Aparicio DOCENTE:

Ing. Cesar Bustamante Chong

CUARTO SEMESTRE

GRUPO#3 AÑO LECTIVO:

2015-2016

FECHA:

28/08/2015



Índice1. Introduccion

2. Material De Clase

2.1. Unidad 1er Parcial–Algoritmos De Ordenación y Búsqueda

Inserción Directa Burbuja Shellsort Radix Algoritmo Quicksort Ordenamiento Por Conteo Ordenamiento Por Distribucion

2.2. Colecciones

Colección Map

Subclases De La Colección Map:o HashMap

o TreeMap

o LinkedHashMap3. 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.

Colección MAP: Jugadores

Colección TREEMAP: Asignaturas

Colección: Digito Verificador de la cedula

Colección 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: Timer6.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 seguirsuperándome cada día, a mis padres que siempre están apoyándome y guiándomehacia el camino del bien, a mis hermanos que están siempre aconsejándome y

dándome fuerza para seguir siempre adelante y a nuestros profesores que cada díase esfuerzan para que nosotros podamos adquirir nuevos conocimientos.

Por ellos va este éxito, y por las personas que a veces tienen obstáculos y quierenrendirse dejar todo, yo les digo que sigan adelante con sacrificio con esfuerzo, conel apoyo de las personas que nos quieren y con la fe de nuestro señor mi Dios todolo que nos propongamos lo podremos siempre.



Unidad 1er Parcial

MÉTODOS DE ORDENAMIENTO INTERNOS. ORDENACIÓN INTERNA

Algoritmos de ordenamiento por intercambio Burbuja Quicksort Shellsort

Algoritmos de ordenamiento por distribucion Radix

Inserción directa.

Este metodo consiste en buscar el lugar adecuado para cada registrorecorriendo los registros anteriores para dejar un lugar vaco para elnuevo elemento. El proceso de acomodo de cada elemento se repitehasta llegar al u ltimo elemento, los elementos previos al elemento aacomodar se encuentran en orden.

Este es el metodo usado por los jugadores de cartas para acomodarsu juego.

Este ordenamiento parte del principio de que el primer elementoesta ordenado y sucesivamente se van colocando los miembros en laposicion adecuada de acuerdo a que pueden ir antes o despues delprimer miembro.

Para ser mas claros, supongamos que tenemos tarjetas con nombreslos cuales queremos ordenar de forma alfabetica, tomamos laprimer tarjeta, la tarjeta dos y la comparamos con la primera,entonces decidimos si va antes o despues de la primera. Una vezcolocadas ambas tarjetas, seguimos con la tercera, la cualcomparamos con la primera y decidimos si va antes o despues de laprimera, si va despues entonces tendremos que comparar con lasegunda tarjeta, por lo que podra ir en medio de las tarjetas o alfinal de las dos primeras.



Ordenamiento por inserción directa.

https://sites.google.com/site/programacionbasicajava/algoritmos-ordenacion/inserci%C3%B3n.png?attredirects=0



Burbuja (Bubble)

Este metodo realiza comparaciones de todas las posibles parejas dellaves 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 primerpasada la llave mayor queda en la u ltima 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 nu mero de subgrupos se incrementa hasta llegar atener 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 números 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 nu mero de elementos de array, yutilizando 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 separadoutilizando 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 queno 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 nossalgan (recuerda que nos salen k sub-arrays). Cuando lleguemos a k=1

habremos terminado.

Radix.



Algoritmo: QuicksortDescripción.

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-código 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))

Descripción.

Es el algoritmo de ordenación más rápido.

Se basa en la técnica divide y vencerás, que consiste en ir subdividiendo elarray en arrays más pequeños, y ordenar éstos.

Para hacer esta división, se toma un valor del array como pivote, y semueven todos los elementos menores que este pivote a su izquierda, y los



mayores a su derecha. A continuación se aplica el mismo método a cada unade las dos partes en las que queda dividido el array.

Después de elegir el pivote se realizan dos búsquedas:

Una de izquierda a derecha, buscando un elemento mayor que elpivote

Otra de derecha a izquierda, buscando un elemento menor que elpivote.

Cuando se han encontrado los dos elementos anteriores, se intercambian, y

se sigue realizando la búsqueda hasta que las dos búsquedas se encuentran. La implementación del método de ordenación Quicksort es claramente

recursiva.

Ejecución 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 algoritmofuncionara de forma eficiente.

Pero si el array esta casi ordenado, elegir el primer elemento comopivote sera una mala solucion ya que obtendramos un subarray muy

pequen o 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 taman o de los subarrays sea lo ma s

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 u ltimo 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 distribución. Este método es bueno aplicarlo cuando existen muchas claves repetidas y

estas se encuentran en un rango pequeño entre u y v.Rango u<=K1..n<=v

Utiliza un arreglo contador con posiciones desde u hasta v, además de un

arreglo para generar la salida.



OLE IONES

COLECCIÓN MAP. La Interface Map (java.io.Map) en Java, nos permite representar una

estructura de datos para almacenar pares “clave/valor”; de tal maneraque 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 tienesus matices. Al igual que dijimos en la entrada de “ArrayList en Java,

con ejemplos” los Maps en java tienen implimentada por debajo todala teora de las estructuras de datos de los Arboles (AVL, B, B+, B*) por

tanto permiten anadir, eliminar y modificar elementos de formatrasparente para el programador.

// Declaración de un Map (un HashMap) con clave "Integer" y Valor"String". Las claves pueden ser de cualquier tipo de objetos, aunque los másutilizados como clave son los objetos predefinidos de Java como String,Integer, Double ... !!!!CUIDADO los Map no permiten datos atómicos

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 yfalse si si los hay nombre

Map.put(K clave, V valor); // Añade un elemento al Map

nombreMap.get(K clave); // Devuelve el valor de la clave que se le pasacomo parámetro 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 parámetro nombreMap.containsKey(K clave); // Devuelve true si en el map hay una

clave que coincide con K nombreMap.containsValue(V valor); // Devuelvetrue 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 (aunqueno lo es tanto como a la hora de trabajar con los ArrayList) son los

“Iteradores” (Iterator). Los Iteradores sirven para recorrer los Map ypoder trabajar con ellos. Los Iteradores solo tienen tres metodos queson el “hasNext()” para comprobar que siguen quedando elementos en

el iterador, el“next()” 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 paratrabajar con los Map ya que la gran ventaja de los Map frente a losArrayList, es que estos tienen una clave asociada al objeto y se les

puede buscar por la clave, aunque nunca esta de mas saber utilizar lositeradores para manejar los Map.

Antes de seguir con ejemplos, os habreis dado cuenta que hemosempezado la entrada diciendo que Map es una Interface y por tanto se

deben de implementar los metodos de la interface. Java ya tieneimplementadas varias “clases Map”. No vamos a explicar todas, pero silas tres que consideramos mas importantes y u tiles para que vea is 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 dearboles (que no vamos a recordar aqu), verais que la gran diferencia

http://jarroba.com/arraylist-en-java-ejemplos/




http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Iterator.html

http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html

http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html

http://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashMap.html

http://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashMap.html

http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html

http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Iterator.html







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

datos para despues optimizar las altas, bajas, modificaciones yconsultas de los “valores”. Pues bien toda esa teora en esta entrada

para nosotros es trasparente, pero esta bien que veamos estas tresclases para que en funcion de vuestro problema elija is 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 menosa 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 bu squedas de loselementos 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 nosordena 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: CapdevilaClave: 14 -> Valor: Xabi Alonso Clave: 16 -> Valor: BusquetsClave: 8 -> Valor: Xavi Hernandez Clave: 18 -> Valor: PedritoClave: 6 -> Valor: Iniesta Clave: 7 -> Valor: Villa



Unidad 2do Parcial

PilasSTACK

La clase Stack es una clase de las llamadas de tipo LIFO (Last In - First Out, o últimoen entrar - primero en salir). Esta clase hereda de la clase Vector y con 5operaciones permite tratar un vector a modo de pila o stack.Las operaciones

básicas son push (que introduce un elemento en la

pila), pop (que saca un elemento de la pila), peek (consulta el primer elemento dela cima de la pila), empty (que comprueba si la pila está vacía) y search (que buscaun determinado elemento dentro de la pila y devuelve su posición dentro deella).Esta clase es muy sencilla y al crear un objeto de tipo Stack con el

constructor básico evidentemente no contendrá ningún elemento.Un conjunto

mucho más completo y consistente para operaciones de stack LIFO sonproporcionados en la interface De qué y sus implementaciones, pero nosotros demomento vamos a limitarnos al estudio de la clase Stack.

Realizaremos un ejemplo a modo de uso de pila. Uno de los casos más usados eninformática de una pila es cuando queremos verificar si una determinada sentenciao instrucción está equilibrada en cuanto a número de paréntesis, corchetes o llavesde apertura y cierre.

Cuando se escribe código de programación si no existe equilibrio entre signos deapertura (por ejemplo un paréntesis de apertura) y cierre (por ejemplo un

paréntesis de cierre) ni siquiera debería procesarse la sentencia ya que no estaríaformalmente bien construida.

De esto se encargan los analizadores léxicos de los compiladores.Así que vamos a

utilizar esta vez tan solo una clase Programa con el método main, donde vamos a iranalizando una sentencia para verificar si es equilibrada o no en símbolos deparéntesis, recorriendo todos sus caracteres desde el inicio hasta el final.

Iremos construyendo nuestra pila apilando un símbolo (cada vez que detectemosun símbolo de apertura o desapilando de ella cuando detectemos un símbolo decierre.

Tendremos que ir analizando todos los caracteres de una expresión y actuar



cuando detectemos un paréntesis, operando en función de si el paréntesis leído esde abrir (“(”) o cerrar (“)”). El equilibrio en la escritura vendrá determinado alterminar el análisis en función de si la pila está vacía (hay equilibrio) o contienealgún elemento (no hay equilibrio).

Ejemplo: analizamos la expresión “Hay varios países (México, España) quecomparten el mismo idioma (español o castellano).”

El resultado al finalizar el análisis de la sentencia sería que la pila está vacía, y estoquerrá decir que nuestra sentencia es equilibrada en paréntesis y por tanto elresultado es correcto.

Si analizáramos la expresión “Hay varios países (México, España) que comparten elmismo idioma (español o castellano.”El resultado al finalizar el análisis será que

la pila contiene un paréntesis, lo que quiere decir que la expresión no esequilibrada y no tiene el mismo número de paréntesis abiertos que cerrados.

Listas tipo Pilas.Una lista se comporta como una pila si las inserciones y extracciones las hacemospor un mismo lado de la lista. También 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 información cualquier tipo de valor (int, char, float, vector de caracteres,

un objeto, etc) Para estudiar el mecanismo de utilización de una pila supondremosque en el campo de información almacena un entero.Inicialmente la PILA está



vacía y decimos que el puntero raiz apunta a null (Si apunta a null decimos que notiene una dirección de memoria.

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

Luego de realizar la inserción la lista tipo pila queda de esta manera: un nodo con el valor10 y raíz apunta a dicho nodo. El puntero del nodo apunta a null ya que no hay otro nododespués de este.

Insertamos luego el valor 4: insertar(4)

Ahora el primer nodo de la pila es el que almacena el valor cuatro. raíz apunta adicho nodo. Recordemos que raíz es el puntero externo a la lista que almacena ladirección del primer nodo. El nodo que acabamos de insertar en el campo punteroguarda la dirección del nodo que almacena el valor 10.

EXTRACCION DE NODOS

Ahora qué sucede si extraemos un nodo de la pila. ¿Cuál se extrae? Como sabemosen 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á vacía y no se podrá extraer otros valores (avisar que la pilaestá vacía)



ColasUna cola es simplemente un lugar para almacenar cosas, donde esas cosas se

insertan una detrás de otra y para extraer siempre se lo hace por adelante de lacola donde se encuentra el primer elemento. Una cola funciona como una fila o colade personas, que esperan su turno para ser atendidas, la primera persona atendidaes siempre la primera de la fila y cuando llega una persona y queremosincorporarla a cola o adicionarla debemos hacerlo por detrás de la ultima personaen la cola.

Con fines educativos una cola se la puede representar gráficamente así:

Una cola puede almacenar lo que nosotros queramos, números, personas,documentos, cualquier cosa. Esta estructura de datos tiene muchas aplicaciones enla informática al igual que la pila, por ejemplo cuando mandan a imprimir variosdocumentos a una impresora, existe una cola de impresión que sigue la filosofía, seimprimen los primeros documentos y si quiero imprimir un nuevo documento se

adiciona al final de todos los documentos que están esperando a imprimirse.

Una vez comprendido en concepto ahora veamos como se implementa esto en unlenguaje de programación, por ahora lo implementaremos en Java. Java en suslibrerías ya tiene la forma de implementar Colas (queue), nosotros ahora haremoscomo si no existiera, es decir crearemos nuestra versión, que es lo quegeneralmente se hace cuando se aprende colas en la universidad.

Los métodos de una cola son:

esVacia() : boolean retorna verdad si la cola esta vacía es decir no tiene ningúnelemento, para esto solo se pregunta si inicio es igual afin.

esLlena() : booleanretorna verdad si es que la cola esta llena, pasa cuando se hallenado todo el vector, la cantidad de elemento que permite la cola lo determinalavariable MAXIMO.

adicionar(int a)adiciona un nuevo elemento a la cola, para esto solo se incrementala variable fin y se coloca el elemento en esa posición.

eliminar() : int extrae el primer elemento de la cola, para esto se retorna la

posición inicio + 1 del vector y se incrementa inicio en 1.



tamanio() : intretorna la cantidad de elementos que tiene la cola, para realizar estose realiza la resta fin - inicio.

copiar(Cola B)copia tal cual la cola B a la cola destino, al finalizar cola B quedatotalmente vacía. Este método es muy útil al momento de hacer operaciones con

colas.



Estructura de datos: Es un conjunto de información.

Información: Pasa a ser un dato.

Dato: se forma al momento que se da la información.

Operaciones básicas con la información Ingresar la información Modificar cápsula Eliminar Mostrar la información : Select ∗ from table Pasar información

Ordenar

Comparar y buscar Mover

Filas: Representan un registro

Columnas: Representan campos o atributosOrdenamiento: es mucho mas fácil buscar si la información esta ordenada.

Índices de una tabla

Clave primaria: primer índice que se crea en una tabla.

Clave foránea : segundo índice que se crea en una tabla.

¿Qué pasaría si una tabla no tiene índice? Va a ver registros repetitivos No hubiera ordenamiento

Inserción Directa

Este método consiste en buscar el lugar adecuado para cada registro recorriendolos registros anteriores para dejar un lugar vacío para el nuevo elemento.

a) Ejemplo: 50,20,30,40



Ordenar de menor a mayor.

1) 0 1 2 3 4 5

50

2) 20<5020 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 eintercambios entre ellos.

Quicksort.Es el algoritmo de ordenamiento mas rapido.

Se reubican los elementos respecto al pivote los menores antes, los mayoresatrás.

Ordenamiento por conteo.Poe medio de este método contamos en un arreglo auxiliar cuantas veces seencuentra cada número en el arreglo original. Una vez que tengamos lasveces que aparecen, podemos saber cuantos números son menoressumando las casillas anteriores. Ahora que conocemos la cantidad de datosque son menores, podemos acomodar el dato en la casilla que le

corresponde.



Colecciones.Es un conjunto de arreglos que pueden crecer en forma dinámica.

Array list

1. ListLinked List

Hash Map

2.

MapHash table

Linked hash map

Tree map

Enum set

3.

setHash set

Linked hash set

Sorted set

Tree set

Cast: es la conversión que se puede realizar como numero a string

Forman parte dearreglos.



COLECCIÓN 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 colección 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, POPeliminar). 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 DATOSint[] ArregloDatos = new int[10];

// GENERAR EL ARREGLO CON LOS DATOS AL RANDOMRandom 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"

/*InicioPara i=2 hasta N incremento 1

v = K(i) //elemento a acomodarj = i

Mientras (j > 1) y (K(j-1) > v)K(j) = K(j-1) //mueve elementosj = j-1

K(j) = v // inserta el elemento actualFin

*}

}



2.

QUICKSORT

3.

CONTEO



Ejemplo con diferentes métodos



1. COLECCIÓN MAP: JUGADORES* 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.Map;import java.util.HashMap;import java.util.TreeMap;import java.util.LinkedHashMap;import java.util.Iterator;public class ColeccionMap {

public static void main(String[] args) {

// 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"); //arqueroColeccionHM.put(2, "Juan Paredes"); //lateral derechoColeccionHM.put(3, "Arturo Mina"); //central derechoColeccionHM.put(4, "Frickson Erazo"); // central izquierdoColeccionHM.put(5, "Oscar Bagui"); // lateral izquierdo

ColeccionHM.put(6, "Christian Noboa"); // mediocentro derechoColeccionHM.put(7, "Jefferson Montero"); //volante de contencion



ColeccionHM.put(8, "Osvaldo Lastra"); //mediocentro izquierdoColeccionHM.put(9, "Fidel Martinez"); //atacante derechoColeccionHM.put(10,"Miller Bolaños"); // centro delanteroColeccionHM.put(11, "Enner Valencia"); //atacante izquierdoColeccionHM.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. COLECCIÓN TREEMAP : ASIGNATURASMap ColeccionTM = new TreeMap<>();

// PRIMERA OPERACION CON LA COLECCION ES INSERTAR// ELEMENTOS A LA COLECCION

// IMPLEMENTAR LAS MATERIAS QUE SE NECESITAN REGISTRAR// EN LA COLECCION MAP, EN SUS DIFERENTES SUBCLASES:// TREEMAP,

ColeccionTM.put(100, "Fundamentos de Programación I");ColeccionTM.put(110, "Fundamentos de Administración I");ColeccionTM.put(120, "Matemáticas I");ColeccionTM.put(200, "Fundamentos de Programación II");ColeccionTM.put(210, "Contabilidad");

ColeccionTM.put(220, "Matemáticas II");ColeccionTM.put(300, "Estructura de Datos I");ColeccionTM.put(310, "Programación II");ColeccionTM.put(320, "Base de Datos I");ColeccionTM.put(400, "Estructura de Datos II");ColeccionTM.put(410, "Programación III");ColeccionTM.put(420, "Base de Datos II");ColeccionTM.put(500, "Programación Web");ColeccionTM.put(510, "Programación Orientada a Objetos I");ColeccionTM.put(520, "Tópicos Especiales");

// 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_TM = ColeccionTM.keySet().iterator();


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<>();// PRIMERA OPERACION CON LA COLECCION ES INSERTAR

// ELEMENTOS A LA COLECCION

// 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");

// 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"M

Iterator<Integer> IndiceC_LHM = ColeccionLHM.keySet().iterator();


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

/*

* 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.*/

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 colección

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 tamaño de la coleccion.

System.out.println("el tamaÒo 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 vacía);

//limpiar de todos los elementos de la colección.

Provincia.clear();

System.out.println("la coleccion es:"+Provincia.size());

boolean SiVacia1= Provincia.isEmpty();System.out.println("la coleccion es:"+SiVacia1);

}}

4.

COLECCIÓN HASHMAP: CIUDADESpublic 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 tamaÒo de la coleccion es :"+Ciudades.size());

TreeMap CiudadOrdenada = new TreeMap(Ciudades);

System.out.println("Coleccion TreeMap es Ordenada:" + CiudadOrdenada);}

}



Realizar los siguientes metodos:inserción,Shell Sort



CÓDIGO – TALLER GRUPAL: Colecciones

package ESTRUCTURA;

import java.util.HashMap;import java.util.Scanner;import java.util.Iterator;

public class AppColeccionMap{

public static void main(String[] args){ String Contenido;

String Contenido3 = null;String Contenido4;String Contenido5;int cont=0;

System.out.println("");System.out.println("");HashMap<String, String> Provincia = new HashMap<>();HashMap<String, String> Ciudades = new HashMap<>();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";String Contenido7="04";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 tamaño de la Coleccion es:" +Provincia.size());

System.out.println("");System.out.println("");System.out.println("COLECCION CIUDADES");

System.out.println("");

//GUAYASCiudades.put("09162", "Guayaquil");Ciudades.put("09163", "Duran");Ciudades.put("09164", "Samborondon");Ciudades.put("09165", "Simon Bolivar");Ciudades.put("09166", "Balao");Ciudades.put("09167", "yaguachi");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("1214", "Babahoyo");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", "Cañar");

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("1214", "Babahoyo");



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();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 deciudades 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 deciudades es: "+ cont);}

CiudadesManabi.put("1310", "Cascol");

CiudadesManabi.put("1311", "Cascol");CiudadesManabi.put("1312", "Chone");CiudadesManabi.put("1313", "Manta");CiudadesManabi.put("1314", "Bolivar");CiudadesManabi.put("1315", "Cañar");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 deciudades es: "+ cont);}

}

}



Tarea # 1 :CÓDIGO

package EstructuradeDatos;

public class deber1 {

public static void main(String[] args) {// 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();System.out.println("Datos Ordenados");for (int x= 0; x < k.length ; x++) {

System.out.print( k[x]+"\t");}

System.out.println();}



VISUALIZACIÓN

Tarea #2 :CÓDIGO


import java.util.Random;

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();

System.out.println("Metodo Burbuja");for (int w= 0; w< K.length ; w++) {

System.out.print( K[w]+"\t");

}System.out.println();

}}

VISUALIZACIÓN



Tarea #3: CÓDIGO – INSERCIÓN DIRECTA - TIMER


public class deberTimerInsercion {public static void main(String[] args) {

long inicio=System.nanoTime();// 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");}System.out.println();

System.out.println();long fin=System.nanoTime();

long tiempo=fin-inicio;System.out.println("Tiempo:"+tiempo);



}}

VISUALIZACIÓN

CÓDIGO – BURBUJA – TIMER


import java.util.Random;

public class deberTimerBurbuja {


long inicio=System.nanoTime();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();System.out.println("Datos Ordenados");

for (int w= 0; w< K.length ; w++) {System.out.print( K[w]+"\t");

}System.out.println();long fin=System.nanoTime();




}

}

VISUALIZACIÓN

CÓDIGO – SHELL SORT- TIMER


public class deberTimerShellsort {

private static final long inicio = 0;

public static void main(String args[]){

long inicio=System.nanoTime();int arreglo_dato[]={14,58,96,11,12,45,8,85};shellSort(arreglo_dato);System.out.println("Datos Ordenados");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 < a[ j - k ] ; j -=k ){

a[ j ] = a[ j - k];

}

a[ j ] = auxiliar;}



}

long fin=System.nanoTime();


}

}

VISUALIZACIÓN

Tarea #4 :CÓDIGO – QUICK SORT - TIMER


import java.util.Arrays;

public class debertimerQuickSort {

private static final long inicio = 0;

public static void main(String[] args) {long inicio=System.nanoTime();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));System.out.println("Datos Ordenados");

}

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();long tiempo=fin-inicio;System.out.println("Tiempo:"+ tiempo);

}

}

VISUALIZACIÓN

CÓDIGO – CONTEO – TIMER


public class deberTimerConteo {private static final long inicio = 0;public static class CountingSort {

static int minimo, maximo;public static void main(String[] args){

long inicio=System.nanoTime();



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 deordenamiento

mostrar(Arreglo_orden);//imprimir ordenado}

public static void mostrar(int[] arreglo){//imprimir arreglo System.out.println("");

System.out.println("Datos Ordenados");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 tamaño 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){//kdiferencia entre max y min

int[] auxiliar = new int[k+1];//Array aux servira paracontar 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 queaparece el num A[x]=i+ minimo;

x++;//siguiente posicion del arreglo ordenado long fin =System.nanoTime();

long tiempo=fin-inicio;System.out.println("Tiempo:"+ tiempo);

}}

}}}



VISUALIZACIÓN

Tarea #5 :CÓDIGO – REMOVE

package ESTRUCTURA;import java.util.Map;import java.util.HashMap;import java.util.Iterator;public class COLECCIONMAP {public static void main(String[]args){

// 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 Bolaños"); //centro delantero ColeccionHM.put(11,"Enner Valencia"); //atacante izquierdo ColeccionHM.put(0,"Gustavo Quintero"); //director tecnico // SEGUNDA OPERACION CON LA COLECCION QUE ES LA DE //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

}}



VISUALIZACIÓN

Tarea #6 :CÓDIGO – TALLER GRUPAL

package ESTRUCTURA;

import java.util.HashMap;import java.util.Scanner;import java.util.Iterator;

public class AppColeccionMap{

public static void main(String[] args){String Contenido;

String Contenido3 = null;String Contenido4;String Contenido5;int cont=0;

System.out.println("");System.out.println("");HashMap<String, String> Provincia = new HashMap<>();HashMap<String, String> Ciudades = new HashMap<>();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";String Contenido7="04";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 valores:"+Provincia.get(Contenido));}

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

System.out.println("");System.out.println("");System.out.println("COLECCION CIUDADES");System.out.println("");

//GUAYASCiudades.put("09162", "Guayaquil");Ciudades.put("09163", "Duran");Ciudades.put("09164", "Samborondon");Ciudades.put("09165", "Simon Bolivar");Ciudades.put("09166", "Balao");Ciudades.put("09167", "yaguachi");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("1214", "Babahoyo");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", "Cañar");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 valores:"+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("1214", "Babahoyo");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();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 lacantidad 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)+ "yla cantidad de ciudades es: "+ cont);}

CiudadesManabi.put("1310", "Cascol");CiudadesManabi.put("1311", "Cascol");CiudadesManabi.put("1312", "Chone");CiudadesManabi.put("1313", "Manta");CiudadesManabi.put("1314", "Bolivar");CiudadesManabi.put("1315", "Cañar");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)+ "yla cantidad de ciudades es: "+ cont);}

}

}VISUALIZACIÓN

Tareas Grupales: 2do

Parcial

Tarea #11. crear una colección Map,llamada “número y letras” 2.

ingresar en la colección los primeros 25 números con su respectivadenominación en letras.

3. general al rango 15 números que estén entre 1y 25 realizar4. leer el arreglo de la colección si existe la llave numgenerado

“mostrar el valor de la colección”

import java.util.Iterator;

import java.util.Map;import java.util.HashMap;import java.util.Random;public class ESTRUCTURA_DEBER {

public static void main(String[]args){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();System.out.println(" la colección 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 valores : " + valor);

}}

}



Tarea #2

DEBER DE ESTRUCTURA DE DATOS II

LISTAS ENLAZADAS

CLASES

NUEVALISTA

package PilasyColumnas;

public class NuevaLista {

public static void main(String[] args) {

ClsLista X= new ClsLista();// INGRESO DE DATOS



X.insert(new String("*MARCOS CUENCA " +" 20 años " +" 1224 "));X.insert(new String("/KEVIN MORAN "+ " 19 años "+ " 2512 "));X.insert(new String("-KATHERINE BAGUI" +" 18 años"+ " 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 thisis

// 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;}

}

Visualización:

elvis tapia curso 4 grupo 3 - portafolioestructuradatos

Documents