Instituto Tecnológico Superior de

Misantla

Integrantes: Rafael Fernandez Rodriguez

Semestre: 3er Semestre Grupo: 303

Carrera: ISC (Ingeniería en Sistemas Computacionales)

Asignatura: Estructura de datos

Actividad: Documentacion de códigos

Fecha de entrega: 19 de Agosto del 2019

1) Algoritmo de ordenamiento Bubble Sort

import java.io.*;

public class BubbleSort {

//Se declaran las variables a utilizar en el algoritmo de busqueda
static int n;
static int i, j;
static int[] array;
public static void main(String[] args) throws IOException{
//se crea el objeto que servirá para leer datos del usuario
BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
//se pide al usuario el tamaño del arreglo
System.out.println("Ingrese en numero de datos: ");
array = new int[Integer.parseInt(al.readLine())];
/*Se inicia un ciclo el cual por cada vuelta almacena
un dato del usuario, el numero de vueltas será el
mismo que el tamaño del arreglo*/
i = 0;
while (i < array.length) {
System.out.print("Ingrese el dato " + (i + 1) + ": ");
array[i] = Integer.parseInt(al.readLine());
i++;
}

//se imprimen los datos del arreglo

System.out.println("");
imprimirArray();
//se imprimen los datos del arreglo ordenados de manera ascendente
System.out.println("\n\nDATOS ORDENADOS ASCENDENTE\n");
//se ejecuta el metodo para ordenar los datos de manera ascendente
bubbleSortA();
imprimirArray();
//se ejecuta el metodo para ordenar los datos de manera descendente
bubbleSortD();
//se imprimen los datos del arreglo ordenados de manera descendente
System.out.println("\n\nDATOS ORDENADOS DESCENDENTE\n");
imprimirArray();
}

//Metodo para ordenar los datos de un arreglo de manera ascendente

static void bubbleSortA() {
i = 0;
/*Se inicia un ciclo el cual por cada vuelta
compara el un dato del arreglo con el siguiente
 y de ser menor que el siguiente se queda en la misma posicion,
de lo contrario intercambian posiciones.*/
while (i < array.length - 1) {
j = 0;
while(j < array.length-i-1) {
if (array[j] > array[j + 1]) {
int aux = array[j];
array[j] = array[j+1];
array[j+1] = aux;
}
j++;
}
i++;
}
}

static void bubbleSortD() {

i = 0;
/*Se inicia un ciclo el cual por cada vuelta
compara el un dato del arreglo con el siguiente
y de ser mayor que el siguiente se queda en la misma posicion,
de lo contrario intercambian posiciones.*/
while (i < array.length - 1) {
j = 0;
while(j < array.length-i-1) {
if (array[j] < array[j + 1]) {
int aux = array[j];
array[j] = array[j+1];
array[j+1] = aux;
}
j++;
}
i++;
}
}
//Metodo para imprimir un arreglo
static void imprimirArray () {
/*Se inicia un ciclo foreach para imprimir cualquier
arreglo de manera segura y optima*/
for (int x : array) {
System.out.print(" " + x);
}
}
}
2) Algoritmo de ordenamiento por intercambio

import java.io.*;

public class Intercambio {

//se declaran las variables a utilizar en el algoritmo
static int[] a;
//se crea el objeto para leer datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
static int dim;
public static void main(String[] args) throws IOException {
//se le pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
//se ejecuta el algoritmo para llenar el arreglo
llenar(Integer.parseInt(al.readLine()));
//se imprimen los datos del arreglo
mostrar(a);
//se ejecuta el metodo para ordenar los datos del arreglo
ordenar(a);
//se vuelven a imprimir los datos ya ordenados
mostrar(a);
}
//Metodo para llenar el arreglo con los datos del usuario
public static void llenar(int dim) throws IOException{
int i = 0;
//se declara un arreglo con tamaño proporcionado por el usuario
a = new int[dim];
/*Se inicia el ciclo y por cada vuelta almacena en el arreglo
un dato cualquiera proporcionado por el usuario*/
while (i < dim) {
System.out.print("Ingrese el dato" + (i+1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}
//Metodo para intercambiar dos datos del arreglo
public static void intercambiar(int[] a, int i, int j) {
/*se intercambian de posicion dos datos
seleccionados por el algoritmo de ordenamiento*/
int aux = a[i];
a[i] = a[j];
a[j] = aux;
}
//Metodo para ordenar los datos del arreglo
public static void ordenar(int[] a) {
int i, j;
 i = 0;
/*Se inicia el ciclo que por cada vuelta
compara el dato en la posicion actual con el siguiente
y de ser mayor que el siguiente dato, se ejecuta el metodo
intercambiar para intercambiar a dichos datos de manera que
los datos quedarán ordenados de manera ascendente.*/
while (i < a.length - 1){
j = i + 1;
while (j < a.length) {
if (a[i] > a[j]) {
intercambiar(a, i, j);
}
j++;
}
i++;
}
}
//Metodo para imprimir el arreglo
public static void mostrar(int[] a) {
/*Se inicia un ciclo foreach para imprimir el arreglo
de manera segura y optima*/
for (int x : a) {
System.out.print("| " + x);
}
System.out.println("");
}
}
3) Algoritmo de ordenamiento por selección

import java.io.*;

public class Seleccion {

//se declaran las variables a utilizar en el algoritmo
static int i, j, indiceMenor;
static int[] a;
//se crea el objeto para leer datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throws IOException{
//se pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
llenar(Integer.parseInt(al.readLine()));
//se imprimen los datos del arreglo con el metodo mostrar
System.out.println("\n<<<<< Arreglo >>>>>>\n");
mostrar(a);
//se ejecuta el metodo ordenar
ordenar(a);
//se imprimen los datos del arreglo ya ordenados
System.out.println("\n<<<<< Arreglo ordenado >>>>>\n");
mostrar(a);
}
//Metodo para llenar el arreglo
public static void llenar (int dim) throws IOException{
i = 0;
a = new int[dim];
/*se inicia un ciclo el cual por cada vuelta almacena un dato
proporcionado por el usuario al arreglo*/
while (i < a.length) {
System.out.print("Ingrese el dato " + (i + 1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}
//Metodo para mostrar los datos del arreglo
public static void mostrar(int[] a) {
/*se inicia un ciclo foreach para imprimir
los datos del arreglo de manera segura y optima*/
for (int x : a) {
System.out.print("| " + x + " ");
}
System.out.println("|");
}
//Metodo para ordenar los datos del arreglo
public static void ordenar(int[] a) {
 i = 0;
/*se inicia un ciclo que por cada vuelta busca el elemento mas pequeño
mediante un indice, el cotador de se diferente al indice se ejecuta el
metodo intercambiar para intercambiar la posicion de los dos datos mediante
el indice.*/
while (i < a.length - 1) {
indiceMenor = i;
j = i + 1;
while (j < a.length) {
if (a[j] < a[indiceMenor]) {
indiceMenor = j;
}
j++;
}

if (i != indiceMenor) {
intercambiar(a, i, indiceMenor);
}
i++;
}
}
//Metodon para intercambiar dos datos mediante un indice
public static void intercambiar(int[] a, int i, int indiceMenor) {
int aux = a[i];
a[i] = a[indiceMenor];
a[indiceMenor] = aux;
}
}
4) Algoritmo de ordenamiento por inserción

import java.io.*;

public class Insercion {

//se crea un objeto para leer los datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
//se declaran las variables a utilizar en el algoritmo
static int i, j, aux;
static int[] a;
public static void main(String[] args) throws IOException{
//se pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
a = new int[Integer.parseInt(al.readLine())];
//se ejecuta el metodo llenar para almacenar los datos en el arreglo
llenar(a);
//se imprimen los datos del arreglo
System.out.println("\n<<<<<< Arreglo >>>>>>\n");
mostrar(a);
//se ejecuta el metodo ordenar
ordenar(a);
//se imprimen los datos del arreglo ya ordenados
System.out.println("\n<<<<<< Arreglo ordenado >>>>>>\n");
mostrar(a);
}
//Metodo para llenar el arreglo
public static void llenar (int[] a) throws IOException{
i = 0;
/*inicia un ciclo que por cada vuelta almacena un dato
proporcionado por el usuario en el arreglo*/
while (i < a.length) {
System.out.print("Ingrese el dato " + (i + 1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}
//Metodo para mostrar los datos del arreglo
public static void mostrar(int[] a) {
/*se inicia un ciclo foreach para imprimir los
datos de un arreglo de manera segura y optima*/
for (int x : a) {
System.out.print(" | " + x);
}
System.out.println(" |");
}
//Metodo para ordenar los datos del arreglo
 public static void ordenar(int[] a) {
i = 1;
/*se inicia un ciclo que por cada vuelta compara dos posiciones en el arreglo
, se asume que el primer dato esta ordenado y se cambia de posicion dependiendo
de si es menor o mayor al siguiente, de ahi solo se analizan las posiciones
siguientes, ya no se analalizan las que fueron ordenadas*/
while (i < a.length) {
j = i;
aux = a[i];
while (j > 0 && aux < a[j - 1]) {
a[j] = a[j-1];
j--;
}
a[j] = aux;
i++;
}
}
}
5) Algoritmo de ordenamiento Shell

import java.io.*;

public class Shell {

//se crea un objeto para leer los datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
//se declaran las variables a utilizar en el algoritmo
static int i, j, k;
static int[] a;
public static void main(String[] args) throws IOException{
//se le pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
a = new int[Integer.parseInt(al.readLine())];
//se ejecuta el metodo llenar para llenar el arreglo
llenar(a);
//se imprimen los datos del arreglo
System.out.println("\n<<<<<< Arreglo >>>>>>\n");
mostrar(a);
System.out.println("\n<<<<<< Arreglo ordenado >>>>>>\n");
//se ejecuta el metodo ordenar
ordenar(a);
//se imprimen los datos del arreglo ya ordenados
mostrar(a);
}
//Metodo para llenar el arreglo con datos
public static void llenar(int[] a) throws IOException{
i = 0;
/*inicia el ciclo que por cada vuelta almacena un dato proporcionado
por el usuario en el arreglo*/
while (i < a.length) {
System.out.print("Ingrese el dato " + (i + 1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}
//Metodo para imprimir los datos del arreglo
public static void mostrar(int[] a) {
/*inicia un ciclo foreach para imprimir los datos
del arreglo de manera segura y optima*/
for (int x : a) {
System.out.print("| " + x + " ");
}
System.out.println(" |");
}
//metodo para intercambiar dos datos de posicion
 public static void intercambiar(int[] a, int j, int jIncremento ) {
int aux = a[j];
a[j] = a[jIncremento];
a[jIncremento] = aux;
}
//Metodo para ordenar los datos del arreglo
public static void ordenar(int[] a) {
int intervalo = a.length/2;
System.out.println(intervalo);
/*Se inicia un ciclo con el arreglo en dos para hacer más facil
el ordenamiento de los datos, de ahi en adelante se hace exactamen
lo mismo que en el algoritmo de inserción*/
while (intervalo > 0) {
i = intervalo;
while (i < a.length) {
j = i - intervalo;
while (j >= 0) {
k = j + intervalo;
if (a[j] <= a[k]) {
j = -1;
}
else {
intercambiar(a, j, j+1);
j -= intervalo;
}
}
i++;
}
intervalo = intervalo / 2;
}
}
}
6) Algoritmo de búsqueda lineal

import java.io.*;

public class Busqueda {

//se crea un objeto para leer los datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
//se declaran las variables a utilizar en el algoritmo
static int i, dato;
static int[] a;
public static void main(String[] args) throws IOException{
//se pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
a = new int[Integer.parseInt(al.readLine())];
//se ejecuta el metodo llenar
llenar(a);
//se imprimen los datos del arreglo
System.out.print("\n<<<<<< Arreglo >>>>>>\n");
mostrar(a);
//se pide al usuario que indique el dato a buscar en el arreglo
System.out.print("\n\nIngrese el numero a buscar: ");
dato = Integer.parseInt(al.readLine());
buscar(dato);

public static void llenar (int[] a) throws IOException{

i = 0;
/*se inicia el ciclo y con cada vuelta se almacena un dato
proporcionado por el usuario en el arreglo*/
while (i < a.length) {
System.out.print("\nIngrese el dato " + (i + 1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}

public static void mostrar (int[] a) {

/*se inicia un ciclo foreach para imprimir los datos
del arreglo de manera segura y optima*/
for (int x : a) {
System.out.print("| " + x + " ");
}
System.out.print("|");
}
//Metodo para buscar un dato
 public static void buscar(int dato) {
i = 0;
/*se inicia un ciclo foreach y con cada vuelta
compara el dato a buscar con cada dato almacenado
en el arreglo, y de ser igual al dato buscado se
detiene el ciclo con la instruccion break*/
for (int x : a) {
if(x == dato) {
System.out.println("Dato encontrado: a[" + i +"] = " + x);
break;
}
i++;
}
}
}
7) Algoritmo de búsqueda binaria

import java.io.*;

public class BusBin {

//se crea un objeto para leer los datos del usuario
static BufferedReader al = new BufferedReader(new InputStreamReader(System.in));
//se declaran las variables a utilizar en el algoritmo
static int[] a;
static int i;
public static void main(String[] args) throws IOException{
//se pide al usuario el tamaño del arreglo
System.out.print("Ingrese el numero de datos: ");
a = new int[Integer.parseInt(al.readLine())];
//se ejecuta el metodo llenar
llenar(a);
//se imprimen los datos del arreglo
System.out.print("\n<<<<<< Arreglo >>>>>>\n");
mostrar(a);
//se pide al usuario que indique el dato a buscar en el arreglo
System.out.print("\n\nIngrese el numero a buscar: ");
buscar(a, Integer.parseInt(al.readLine()));
}
//Metodo para llenar el arreglo
public static void llenar (int[] a) throws IOException{
i = 0;
/*se inicia el ciclo y con cada vuelta se almacena un dato
proporcionado por el usuario en el arreglo*/
while (i < a.length) {
System.out.print("Ingrese el dato " + (i + 1) + ": ");
a[i] = Integer.parseInt(al.readLine());
i++;
}
}
//Metodo para mostrar datos del arreglo
public static void mostrar(int[] a) {
/*se inicia un ciclo foreach para imprimir los datos
del arreglo de manera segura y optima*/
for (int x : a) {
System.out.print("| " + x + " ");
}
System.out.print("|");
}
//Metodo para buscar el dato
public static int buscar(int[] a, int clave) {
int central, bajo, alto;
 int valorCentral;
bajo = 0;
alto = a.length - 1;
/*inicia el ciclo para buscar el dato, en cada vuelta parte a la mitad
el arreglo y analiza ambas partes, y solo sigue haciendo particiones
en las partes en donde podria estar hasta encontrarlo*/
while (bajo <= alto) {
central = (bajo + alto) / 2;
valorCentral = a[central];

if (clave == valorCentral) {
System.out.println("\nEl numero que busca esta en la posicion: " + (centr
al + 1));
break;
}
else if (clave < valorCentral) {
alto = central - 1;
}
else {
bajo = central + 1;
}
}
return -1;
}
}