Anda di halaman 1dari 13

}

UNIVERSIDAD NACIONAL TORIBIO RODRÍGUEZ DE


MENDOZA

FACULTAD DE INGENIERÍA DE SISTEMAS Y


MECÁNICA ELÉCTRICA

Trabajo
Práctico.

Docente : Mag. LOBATON ARENAS, CARLOS LUIS


Integrantes : RODRIGUEZ SOPLA, Angel Isaac
LLAGUENTO CARLOS, Cesar Uribe
JARAMILLO MALCA, Oscar

Curso : Estructura de Datos y Programación


Tema : Desarrollo de Laboratorio
Ciclo : II

Bagua-Amazonas
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.

package practica_01;

import java.util.Scanner;

public class Practica_01 {

public static void main(String[] args) {

Scanner tc = new Scanner(System.in);

int arreglo[]={4, 7, 11, 4, 9, 5, 11, 7, 3, 5};

for(int i=0;i<arreglo.length;i++){

for(int j=0;j<arreglo.length-1;j++){

if(i!=j){

if(arreglo[i]==arreglo[j]){

// eliminamos su valor

arreglo[i]=0;

}
}

// mostramos unicamente los que tienen valor

int n=arreglo.length;

for (int k=0;k<=n-1;k++){

if(arreglo[k]!=0){

System.out.print( arreglo[k]+",");

2) Un array contiene los elementos indicados más abajo. Utilizando el algoritmo de


búsqueda binaria, trazar las etapas necesarias para encontrar el número 88.
8 13 17 26 44 56 88 9
Hacer la misma búsqueda pero para el número 20.
int arreglo[]={8, 13, 17, 26, 44, 56, 88, 97};

int dato = Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese el numero a


buscar"));
int bbinaria=bbinaria(arreglo,dato);

if(bbinaria!=-1){
int pos= bbinaria+1;
JOptionPane.showMessageDialog(null,"El dato se encuetra en el arreglo, en la posicion
" +pos);
}else{
JOptionPane.showMessageDialog(null,"El dato no se encuentra en el arreglo");
}
}

private static int bbinaria(int[] arreglo, int dato) {


int inferior=0,superior=arreglo.length-1,centro;
while(inferior <= superior){
centro = (superior+inferior)/2;
if( arreglo[centro] == dato){
return centro;
}else if(dato < arreglo[centro]){
superior= centro -1;
}else if(dato > centro){
inferior=centro+1;
}
}
return -1;
}

}
3) Escribir una función de búsqueda binaria aplicado a un array ordenado
descendentemente.

int n = Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese el
tamaño del arreglo"));

int arreglo[]= new int[n];

for (int i = 0; i < n; i++) {

arreglo[i]= Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese
el numero ("+i+")"));

int dato= Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el


numero a buscar"));

for (int i = 0; i < n -1; i++){

for (int j = 0; j <n -1; j++) {


if(arreglo[j]< arreglo[j+1]){

int aux = arreglo[j];

arreglo[j]=arreglo[j+1];

arreglo[j+1]= aux;

JOptionPane.showMessageDialog(null,Arrays.toString(arreglo));

int bBinaria=bBinaria(arreglo,dato);

if( bBinaria != -1){

int pos = bBinaria+1;

JOptionPane.showMessageDialog(null,

"el dato esta en el arreglo, en la posiscion "+ pos);

}else{

JOptionPane.showMessageDialog(null,

"el dato no esta en el arreglo");

private static int bBinaria(int[] arreglo, int dato) {

int inferior = 0,superior=arreglo.length-1,centro;


while(inferior<= superior){

centro=(inferior+superior)/2;

if(arreglo[centro] == dato){

return centro;

}else if(dato >arreglo[centro]){

superior = centro -1;

}else {

inferior = centro +1;

return -1;

4. 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||

6. 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
7. Partiendo del mismo array que en el Ejercicio 6.6,
encuentre las particiones e intercambios que realiza el
algoritmo de ordenación Quicksort para su ordenación.

package provando;

import java.util.Arrays;

import java.util.Random;

public class Provando {

public static void main(String[] args) {

int arreglo[] = {8, 43, 17, 6, 40, 16, 18, 97, 11, 7};

Shell(arreglo);

System.out.println(Arrays.toString(arreglo));

QuickSort(arreglo,0,arreglo.length-1);

System.out.println(Arrays.toString(arreglo));

private static void Shell(int[] arreglo){

int i, j, k, intervalo;

int numero = arreglo.length;


intervalo = numero/2;

while(intervalo > 0){

for(i = intervalo; i < numero; i++){

j = i - intervalo;

while(j >= 0){

k = j + intervalo;

if(arreglo[j] <= arreglo[k])

j = -1;

else

j -= intervalo;

intervalo = intervalo/2;

private static void QuickSort(int[] arreglo, int izq, int der) {

int i = izq;

int j = der;

int pivote = arreglo[(i+j)/2];

do{

while(arreglo[i] < pivote){

i++;

while(arreglo[j] > pivote){


j--;

if(i <= j){

int aux = arreglo[i];

arreglo[i] = arreglo[j];

arreglo[j] = aux;

i++;

j--;

}while(i <= j);

if(izq < j){

QuickSort(arreglo,izq,j);

if(i < der){

QuickSort(arreglo,i,der);

8. Se dispone de dos vectores, Maestro y Esclavo, del mismo tipo y número de


elementos.
Se deben imprimir en dos columnas adyacentes. Se ordena el vector Maestro,
pero siempre que un elemento de Maestro se mueva, el elemento
correspondiente
de Esclavo debe moverse también; es decir, cualquier cosa que se haga a
Maestro[i]
debe hacerse a Esclavo[i]. Después de realizar la ordenación, se imprimen de
nuevo
los vectores. Escribir un programa que realice esta tarea.
Nota: utilizar como algoritmo de ordenación el método Quicksort.

package javaapplication106;
public class JavaApplication106 {

public static void main(String[] args) {


int Maestro[]= {2,4,46,65,23,11,2};
int Esclavo[]= {56,34,21,-2,-145,11,56};

System.out.println("MAESTRO ESCLAVO");
for (int i = 0; i < 7; i++) {
System.out.println(Maestro[i]+" "+ Esclavo[i]);

System.out.println("");
System.out.println("ORDENANDO EN QUICKSORT");
OrdenarQuicSort(Maestro,0,Maestro.length-1 );
OrdenarQuicSortEsclavo(Esclavo,0,Esclavo.length-1 );
System.out.println("MAESTRO ESCLAVO");
for (int i = 0; i < Maestro.length; i++) {
System.out.println(Maestro[i]+" "+Esclavo[i]);
}

private static void OrdenarQuicSort(int[] Maestro, int pri, int ulti) {


int i=pri;
int j=ulti;
int pivote= Maestro[(i+j)/2];
do {

while(Maestro[i]<pivote){
i++;
}
while(Maestro[j]>pivote){
j--;
}
if(i<=j){
int aux =Maestro[i];
Maestro[i]=Maestro[j];
Maestro[j]=aux;
i++;
j--;
}
} while (i<=j);
if(pri<j){
OrdenarQuicSort(Maestro, pri,j);
}
if(i<ulti){
OrdenarQuicSort(Maestro, i, ulti);
}

private static void OrdenarQuicSortEsclavo(int[] Esclavo, int pri, int ulti) {


int i=pri;
int j=ulti;
int pivote= Esclavo[(i+j)/2];
do {

while(Esclavo[i]<pivote){
i++;
}
while(Esclavo[j]>pivote){
j--;
}
if(i<=j){
int aux =Esclavo[i];
Esclavo[i]=Esclavo[j];
Esclavo[j]=aux;
i++;
j--;
}

} while (i<=j);
if(pri<j){
OrdenarQuicSort(Esclavo, pri,j);
}
if(i<ulti){
OrdenarQuicSort(Esclavo, i, ulti);
}

12. Supongamos que se tiene una secuencia de n números que deben ser
clasificados:
*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
}

}
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).