Tarea

Estructura de
Tarea Nº 3
Datos

Algunos Ejercicios son Tomados del Libro Estructuras de Datos-

Capitulo 6 de Joyanes Aguilar

Nombre: Andrés Guerra Medina

Curso: 3 A

Fecha: 25/10/2016

EJERCICIOS
1. ¿Cuál es la diferencia entre ordenación por intercambio y
ordenación por el método de la burbuja?

El algoritmo del ordenamiento por intercambio es uno de los más sencillos, pero con
el rendimiento realmente bajo, se basa en la idea de buscar cada vez el menor
elemento del conjunto y ubicarlo al principio del arreglo, repitiendo este proceso sin
incluir el primero de los datos que ya se encuentra ordenado, hasta llegar a un
conjunto de un elemento que se encuentra ya ordenado.

El algoritmo por ordenamiento de Burbuja es uno de los más conocidos y más usado
por programadores, consiste en comparar pares de elementos adyacentes en un
Array y si están desordenados intercambiarlos hasta que estés ordenados. El
rendimiento de este algoritmo es mucho más eficaz que el algoritmo de
intercambio.

2. Se desea eliminar todos los números duplicados de una lista o vector

(array). Por
ejemplo, si el array toma los valores
4 7 11 4 9 5 11 7 3 5
ha de cambiarse a
4 7 11 9 5 3
Escribir un método que elimine los elementos duplicados de un array.

public void eliminarRepetidos(){

int qtd = 0;
for( int i = 0 ; i < original.length ; i++ ) {
boolean existe = false;
for( int j = 0 ; j < qtd ; j++ ) {
if( unicos[ j ] == original[ i ] ) {
existe = true;
break;
}
}
if( !existe ) {
unicos[ qtd++ ] = original[ i ];
}
}
unicos = Arrays.copyOf( unicos , qtd );
}
 Tarea
Estructura de
Tarea Nº 3
Datos

3. Un vector contiene los elementos mostrados a continuación. Los

primeros dos elementos
se han ordenado utilizando un algoritmo de inserción. ¿Cuál será el valor
de los elementos
del vector después de tres pasadas más del algoritmo?
3 13 8 25 45 23 98 58

package insercsion;
import java.util.*;
public class Insercsion {
Scanner leer = new Scanner(System.in);
public static void main(String[] args) {
int a[]={3 ,13, 8 ,25 ,45 ,23 ,98, 58};
Insercsion op= new Insercsion();
op.ordInsercion(a);
}
public void ordInsercion (int [] a)
{
System.out.println("el vector es:");
for (int i = 0; i <a.length; i++) {
System.out.print(a[i]+"||");
}
int i, j;
int aux;
for (i = 1; i < 3; i++)
{ /*indice j es para explorar la sublista a[i-1]..a[0] buscando la
posicion correcta del elemento destino*/
j = i;
aux = a[i];
// se localiza el punto de inserción explorando hacia abajo
while (j > 0 && aux < a[j-1])
{// desplazar elementos hacia arriba para hacer espacio
a[j] = a[j-1];
j--;
}
a[j] = aux;
}
System.out.println("");
System.out.println("el vector ordenado es:");
for (int k = 0; k <a.length ; k++) {
System.out.print(a[k]+"||");
}
}
}

El vector quedaría así : 3||8||13||25||45||23||98||58||

4. Un array contiene los elementos indicados más abajo. Utilizando el

algoritmo de
ordenación Shell, encuentre las pasadas y los intercambios que se realizan
para su
ordenación.
8 43 17 6 40 16 18 97 11 7
 Tarea
Estructura de
Tarea Nº 3
Datos

package algoritmoshell;

import java.util.Scanner;

public class AlgoritmoShell {

public static void Shellsort (int[] a) {

int salto=a.length/2;//salto es igual a el tamaño del vector dividido para dos
int x = 0, y = 0;
while(salto>=1){//mientras el tamaño del salto sea mayor a 1 se realizara lo
siguiente
for(int rec=salto;rec<a.length;rec++){//para el recorrido igual al salto; mientras
recorrido sea menor al tamaño del vector; el recorrido aumenta de 1 en 1
int temp=a[rec];
int j=rec-salto;
while(j>=0&&a[j]>temp){
a[j+salto]=a[j];
j=j-salto;
x += 1;
}
a[j+salto]=temp;
}
salto/=2;
y +=1;
}
System.out.printf("\nx es igual a: %d",x);
System.out.printf("\ny es igual a: %d",y);
}

public static void imprime(int []a){

String sal="";
for(int i=0;i<a.length;i++){
if(a[i]<10)
sal+=" "+a[i]+" ";
else
sal+=a[i]+" ";
}
System.out.println(sal);
}

public static void main (String[] args) {

int a[]={8, 43, 17, 6, 40, 16, 18, 97 ,11 ,7};
Shellsort(a);
System.out.println("\nVector ordenado");
imprime(a);
}

Realizó: 12 cambios
Realizó: 3 pasadas
 Tarea
Estructura de
Tarea Nº 3
Datos

5. Supongamos que se tiene una secuencia de n números que deben ser

clasificados:
1. Utilizando el método de Shell, ¿cuántas comparaciones y cuántos
intercambios se
requieren para clasificar la secuencia si
• ya está clasificado?

package algoritmoshell;

import java.util.Scanner;

public class AlgoritmoShell {

public static void Shellsort (int[] a) {

int salto=a.length/2;//salto es igual a el tamaño del vector dividido para dos
int x = 0, y = 0;
while(salto>=1){//mientras el tamaño del salto sea mayor a 1 se realizara lo
siguiente
for(int rec=salto;rec<a.length;rec++){//para el recorrido igual al salto; mientras
recorrido sea menor al tamaño del vector; el recorrido aumenta de 1 en 1
int temp=a[rec];
y +=1;
int j=rec-salto;
while(j>=0&&a[j]>temp){
a[j+salto]=a[j];
j=j-salto;
x += 1;
}
a[j+salto]=temp;
}
salto/=2;
}
System.out.printf("\nx es igual a: %d",x);
System.out.printf("\ny es igual a: %d",y);
}

public static void imprime(int []a){

String sal="";
for(int i=0;i<a.length;i++){
if(a[i]<10)
sal+=" "+a[i]+" ";
else
sal+=a[i]+" ";
}
System.out.println(sal);
}

public static void main (String[] args) {

int a[]={1,2,3,4,5,6,7,8,9,10,11,12};
Shellsort(a);
System.out.println("\nVector ordenado");
imprime(a);
 Tarea
Estructura de
Tarea Nº 3
Datos

Se requieren (n*2) + 2 comparaciones si el n es par y se requiere (n*2) + 3 si n es

impar y no se realiza ningún intercambio.

• está en orden inverso?

Se requieren (n*2) + 2 comparaciones si el n es par y se requiere (n*2) + 3 si n es

impar, en el caso de los intercambios entre menos datos se tengan menos
intercambios hará, pero conforme añadamos datos a nuestro arreglo crecen los
intercambios de una manera bastante alta.

2. Repetir el paso 1 para el método de Quicksort.

package ordenamientoquicksort;

public class quicksort {

int x = 0, y = 0;
public void quicksort(int A[], int izq, int der) {
int pivote = A[izq]; // tomamos primer elemento como pivote
int i = izq; // i realiza la búsqueda de izquierda a derecha
int j = der; // j realiza la búsqueda de derecha a izquierda
int aux;

while (i < j) { // mientras no se crucen las búsquedas

while (A[i] <= pivote && i < j) {
y =+ 1;
i++; // busca elemento mayor que pivote
}
while (A[j] > pivote) {
y =+ 1;
j--; // busca elemento menor que pivote
}
if (i < j) { // si no se han cruzado
aux = A[i]; // los intercambia
A[i] = A[j];
A[j] = aux;
x += 1;
}
}

A[izq] = A[j]; // se coloca el pivote en su lugar de forma que tendremos

A[j] = pivote; // los menores a su izquierda y los mayores a su derecha
if (izq < j - 1) {
quicksort(A, izq, j - 1); // ordenamos subarray izquierdo
}
if (j + 1 < der) {
quicksort(A, j + 1, der); // ordenamos subarray derecho
 Tarea
Estructura de
Tarea Nº 3
Datos

}
public void imprimir(int A[]){
for (int k = 0; k < A.length; k++) {
System.out.print(A[k]);
}
System.out.println(" ");
System.out.printf("Comparaciones totales : %d",y);
System.out.printf("Cambios totales : %d",x);
}
}

Cuando se encuentra ordenado hace una sola pasada y ningún intercambio,

por eso quicksort es uno de los mejores algoritmos de ordenación.

Cuando se encuentra en orden inverso se realiza T(n)=2T(n/2)+ n-1 donde T

es el pivote y para el numero de intercambios nos basamos en el orden del
quicksort T(n) - 0(n lg n).

PROBLEMAS

1. Un método de ordenación muy simple, pero no muy eficiente, de elementos x1,

x2,
x3,...xn en orden ascendente es el siguiente:
Paso 1: Localizar el elemento más pequeño de la lista x1 a xn; intercambiarlo con x1.
Paso 2: Localizar el elemento más pequeño de la lista x2 a xn, intercambiarlo con x2.
Paso 3: Localizar el elemento más pequeño de la lista x3 a xn, intercambiarlo con xn.
En el último paso, los dos últimos elementos se comparan e intercambian, si es
necesario,
y la ordenación se termina. Escribir un programa para ordenar una lista de
elementos, siguiendo este método.

2. Se trata de resolver el siguiente problema escolar: dadas las notas de los

alumnos de un colegio en el primer curso de bachillerato en las diferentes
asignaturas (5, por comodidad), se trata de calcular la media de cada alumno, la
media de cada asignatura, la media total de la clase y ordenar los alumnos por
orden decreciente de notas medias individuales.
Nota: utilizar como algoritmo de ordenación el método Shell.

5. Programa Java que lea 10 números enteros por teclado y los guarde en un array.
Calcula y muestra la media de los números que estén en las posiciones pares del
array.
Declara un array tipo int (entero) denominado numerodecoches que contenga 24
variables. Declara una variable tipo int (entero) que se llame r. Establece el valor de
r en 2 y el valor de numerodecoches para un localizador de valor r en 23. Procede a
mostrar en pantalla un mensaje que indique cuál es la hora r y el número de coches
para la hora r. Finalmente, modifica únicamente la asignación de valor a r de modo
que en vez de 2 sea 21 y ejecuta de nuevo el programa
 Tarea
Estructura de
Tarea Nº 3
Datos

7. Se desea realizar un programa que realice las siguientes tareas:

a) Generar, aleatoriamente, una lista de 9.999 de números reales en el rango de 0 a
2000.
b) Ordenar en modo creciente por el método de la burbuja.
c) Ordenar en modo creciente por el método Shell.
d) Ordenar en modo creciente por el método Radixsort.

8. Construir un método que permita ordenar por fechas y de mayor a menor un

vector
de n elementos que contiene datos de contratos (n <= 50). Cada elemento del
vector
debe ser un objeto con los campos día, mes, año y número de contrato. Pueden
existir
diversos contratos con la misma fecha, pero no números de contrato repetidos.
Nota. Presentar un Menu para el método a utilizar para ordenar será el de Quicksort,
Shell o Burbuja