Lenguaje de programación
Renzo Leonardo Gerónimo Gonzales
Ciclo:III Seccion:A
BÚSQUEDA y ORDENAMIENTO
- Métodos de búsqueda
- Métodos de ordenamiento
- Aplicaciones a la ingeniería
TAREA PROGRAMACION
-BURBUJA MEJORADA
-BUSQUEDA
-INSERCION DIRECTA
-INSERCION BINARIA
#include <iostream>
#include <math.h>
#include <cstdlib>
using namespace std;
int opcion = 0, A[100], n, c, i, j, Aux;
void Busqueda();
void Burbuja();
void InsercionDirecta(); // Cambio de inserciondirecta a InsercionDirecta
void InsercionBinaria(); // Cambio de insercionbinaria a InsercionBinaria
int main()
{
do
{
cout << " M E N U P R I N C I P A L D E M A T R I C E S\n "
<< endl;
cout << " ----------------------------" << endl;
cout << " 1.- BUSQUEDA SECUENCIAL \n " << endl;
cout << " 2.- ORDENAMIENTO DE BURBUJA \n " << endl;
cout << " 3.- Insercion directa\n " << endl;
cout << " 4.- INSERCION BINARIA\n " << endl; // Corrección en el texto de la opción 4
cout << endl;
cout << "\n INGRESE UNA OPCION <0> : ";
cin >> opcion;
cout << " ----------------------------" << endl;
switch (opcion)
{
case 1:
{
cout << " 1.- BUSQUEDA SECUENCIAL " << endl;
cout << " ----------------------------" << endl;
Busqueda();
cout << " ----------------------------" << endl;
break;
}
case 2:
{
cout << " 2.- ORDENAMIENTO DE BURBUJA " << endl;
cout << " ----------------------------" << endl;
Burbuja();
cout << "\n ----------------------------" << endl;
break;
}
case 3:
{
cout << " 3.- INSERCCION DIRECTA " << endl; // Corrección en el texto de la opción 3
cout << " ----------------------------" << endl;
InsercionDirecta(); // Corrección en el nombre de la función
cout << " " << endl;
break;
}
case 4:
{
cout << " 4.- INSERCION BINARIA " << endl; // Corrección en el texto de la opción 4
cout << " ----------------------------" << endl;
InsercionBinaria(); // Corrección en el nombre de la función
cout << " ----------------------------" << endl;
break;
}
}
} while (opcion != 0);
return 0;
}
void Busqueda()
{
for (i = 1; i <= 20; i++)
{
A[i] = rand() % 20;
cout << "A[" << i << "]=" << A[i];
}
cout << "Ingrese el elemento a buscar ";
cin >> n;
cout << "cuenta las veces que se encuentra el elemento \n";
c = 0;
for (i = 1; i <= 20; i++)
{
if (A[i] == n)
{
cout << "A[" << i << "]=" << A[i] << endl;
c = c + 1;
}
}
cout << "\n se repitio: " << c << " veces " << n << endl;
}
void Burbuja()
{
for (i = 1; i <= 20; i++)
{
A[i] = rand() % 20;
cout << "A[" << i << "]=" << A[i];
}
cout << "'n Ordenando el vector A[20] " << endl;
for (i = 1; i <= 20; i++)
{
for (j = 1; j <= 19; j++)
{
if (A[j] > A[j + 1])
{
Aux = A[j];
A[j] = A[j + 1];
A[j + 1] = Aux;
}
}
}
for (i = 1; i <= 20; i++)
{
cout << "A[" << i << "]=" << A[i] << endl;
}
}
void InsercionDirecta() // Cambio de inserciondirecta a InsercionDirecta
{
for (i = 0; i < 5; i++)
{
j = i;
Aux = A[i];
while ((j > 0) && (A[j - 1] > Aux))
{
A[j] = A[j - 1];
j--;
}
A[j] = Aux;
}
cout << "Orden Ascendente: ";
for (i = 0; i < 5; i++)
{
cout << A[i] << " ";
}
cout << "\nOrden Descendente: ";
for (i = 4; i >= 0; i--)
{
cout << A[i] << " ";
}
}
void InsercionBinaria() // Cambio de insercionbinaria a InsercionBinaria
{
int pos, aux; // Declaración de las variables pos y aux
for (i = 0; i < 5; i++)
{
pos = i;
aux = A[i];
while ((pos > 0) && (A[pos - 1] > aux))
{
A[pos] = A[pos - 1];
pos--;
}
A[pos] = aux;
}
cout << "Orden Ascendente: ";
for (i = 0; i < 5; i++)
{
cout << A[i] << " ";
}
cout << "\nOrden Descendente: ";
for (i = 4; i >= 0; i--)
{
cout << A[i] << " ";
}
}
Explicación
void InsercionDirecta(): Este algoritmo es uno de los métodos más simples de ordenamiento. Funciona de la siguiente manera:
1. La función recorre el arreglo, comenzando desde el segundo elemento (índice 1) hasta el último elemento.
2. En cada interacción, toma el elemento actual y lo compara con los elementos anteriores en la parte ya ordenada del arreglo.
3. Si el elemento actual es menor que el elemento anterior, desplaza el elemento anterior una posición hacia la derecha para hacer espacio para el elemento actual.
4. Inserta el elemento actual en la posición correcta.
Al final del proceso, el arreglo estará completamente ordenado de forma ascendente.
Además, la función void InsercionDirecta también muestra el arreglo ordenado tanto en orden ascendente como descendente, después de realizar el proceso de ordenamiento.
void InsercionBinaria(): Esta función implementa el algoritmo de ordenamiento por inserción binaria. El algoritmo de inserción binaria es similar al de inserción directa, pero en lugar de comparar elemento por elemento en la parte no ordenada para encontrar la posición de inserción, utiliza una búsqueda binaria para encontrar la posición de inserción. El proceso de inserción es el mismo que en el algoritmo de inserción directa.
La función comienza recorriendo el arreglo y en cada iteración, toma el elemento actual y lo inserta en su posición correcta dentro de la parte ya ordenada del arreglo, utilizando una búsqueda binaria para encontrar dicha posición. Finalmente, se muestra el arreglo ordenado tanto en orden ascendente como descendente.