Universidad José Gregorio Hernández
Revolución del Poder Popular para la Educación
República Bolivariana de Venezuela
Maracaibo Estado Zulia
Programación
Estructurada
Nombre: José Ramon
Apellido: Avila Melean
Facultad: Ingeniería en Sistemas
C.I: 32.279.684
1.¿Que es un arreglo?:
Un arreglo es una estructura de datos que almacena un conjunto de elementos
ordenados bajo un solo nombre. Cada elemento tiene un índice que lo identifica y que indica
su posición en el arreglo Los elementos pueden ser de cualquier tipo de dato, como
números, letras o objetos Un arreglo se puede representar como una fila de casilleros o una
caja con compartimentos, donde cada uno contiene un dato específico.
Ejemplo:
Declaración de un arreglo unidimensional (vector):
Un arreglo unidimensional (también conocido como vector) es una colección ordenada de
elementos del mismo tipo. Para declarar un arreglo en C++, sigue esta sintaxis:
tipo_de_dato nombre_del_arreglo[tamaño];
Por ejemplo, para crear un arreglo de enteros con 5 elementos:
int mi_arreglo[5];
Inicialización de un arreglo:
Puedes inicializar los elementos de un arreglo al declararlo:
int numeros[3] = {10, 20, 30};
Acceso a los elementos de un arreglo:
Los elementos de un arreglo se numeran desde 0 en adelante. Puedes acceder a un
elemento específico mediante su índice:
int primer_elemento = numeros[0]; // Accede al primer elemento (10)
int segundo_elemento = numeros[1]; // Accede al segundo elemento (20)
Recorriendo un arreglo:
Puedes usar un bucle for para recorrer todos los elementos de un arreglo:
for (int i = 0; i < 3; ++i) {
cout << "Elemento " << i << ": " << numeros[i] << endl;
}
Arreglos dinámicos:
Si no conoces el tamaño del arreglo en tiempo de compilación, puedes usar contenedores
como std::vector:
#include <vector>
// ...
std::vector<int> arreglo_dinamico;
int n;
cout << "Ingrese el tamaño del arreglo: ";
cin >> n;
arreglo_dinamico.resize(n);
2.Tipos de Arreglo (Unidimensional, Bidimensional y Multidimensional):
Los arreglos son estructuras de datos fundamentales en la programación. Permiten
almacenar y manipular conjuntos de elementos del mismo tipo. A continuación, describiré
los tres tipos principales de arreglos:
Arreglos Unidimensionales (Vectores):
También conocidos como vectores, los arreglos unidimensionales son colecciones lineales
de elementos que se acceden mediante un solo índice.
Cada elemento del arreglo se referencia mediante el nombre del arreglo seguido de un
índice entre paréntesis cuadrados.
El índice debe ser un entero no negativo.
En un arreglo de n elementos, los índices van desde 0 hasta n-1.
Ejemplo de declaración en lenguaje C:
int miArreglo[5]; // Declaración de un arreglo de 5 elementos
Los valores de los elementos pueden inicializarse al momento de la declaración.
Ejemplo de inicialización:
int numeros[3] = {10, 20, 30}; // Inicialización con valores
Arreglos Bidimensionales (Matrices):
Los arreglos bidimensionales son matrices con dos índices.
Se utilizan para representar datos en forma de filas y columnas.
Cada elemento se accede mediante dos índices: uno para la fila y otro para la columna.
Ejemplo de declaración en lenguaje C:
int miMatriz[3][4]; // Declaración de una matriz de 3 filas y 4 columnas
Los valores de los elementos también pueden inicializarse al momento de la declaración.
Arreglos Multidimensionales:
Los arreglos multidimensionales tienen más de dos índices.
Se utilizan para representar datos en estructuras más complejas, como tablas o cubos.
Ejemplo de declaración en lenguaje C:
int miCubo[2][3][4]; // Declaración de un cubo de 2x3x4
Los valores de los elementos pueden inicializarse de manera similar a los arreglos
bidimensionales.
En resumen, los arreglos unidimensionales son colecciones lineales de elementos
accedidos mediante un solo índice, mientras que los arreglos bidimensionales y
multidimensionales son matrices de elementos accedidos mediante dos o más índices.
Estas herramientas son poderosas para almacenar y manipular datos de manera eficiente
en la programación.
3. Como se declara un arreglo en Lenguaje C++?:
En C++, puedes declarar un arreglo (también conocido como vector) para almacenar
múltiples valores en una única variable. Los arreglos son útiles cuando necesitas guardar
una colección de elementos del mismo tipo. Aquí tienes algunas formas de declarar arreglos
en C++:
Declaración básica de un arreglo unidimensional: Para crear un arreglo unidimensional,
sigue esta sintaxis:
tipo nombre_arreglo[tamaño];
Por ejemplo, si deseas un arreglo de enteros con 5 elementos, puedes hacer lo siguiente:
int mi_arreglo[5];
Inicialización de un arreglo con valores: Puedes asignar valores iniciales a los elementos
del arreglo al declararlo:
int numeros[3] = {10, 20, 30};
Declaración de un arreglo de cadenas (strings): Si quieres un arreglo de cadenas (strings),
puedes hacerlo así:
#include <string> // Asegúrate de incluir la librería string
std::string libros[5] = {"Cien años de soledad", "Don Quijote", "1984"};
Recorriendo un arreglo: Puedes usar un bucle for para acceder a los elementos del arreglo:
for (int i = 0; i < 5; ++i) {
std::cout << "Libro " << i + 1 << ": " << libros[i] << std::endl;
}
En resumen, los arreglos en C++ te permiten almacenar y manipular conjuntos de datos de
manera eficiente.
4. Qué métodos de ordenamiento y búsqueda se pueden realizar en un arreglo?:
Los **algoritmos de ordenación** son conjuntos de instrucciones que toman un
arreglo o lista como entrada y organizan los elementos en un orden particular. Estas
ordenaciones pueden ser numéricas o alfabéticas (o lexicográficas), y pueden ser en orden
ascendente (AZ, 0-9) o descendente (ZA, 9-0) ¹.
Aquí tienes algunos de los **algoritmos de ordenación más comunes**:
1. **Selección (Selection Sort)**: Este algoritmo selecciona repetidamente el elemento más
pequeño (o más grande) y lo coloca en la posición correcta. Aunque simple, no es muy
eficiente para grandes conjuntos de datos.
2. **Burbuja (Bubble Sort)**: Compara pares de elementos adyacentes y los intercambia si
están en el orden incorrecto. Aunque fácil de entender, no es eficiente para grandes
arreglos.
3. **Inserción (Insertion Sort)**: Construye una lista ordenada uno por uno al insertar
elementos en su posición correcta. Es útil para arreglos pequeños o casi ordenados.
4. **Combinación (Merge Sort)**: Divide el arreglo en mitades, ordena cada mitad por
separado y luego combina las mitades ordenadas. Es eficiente y estable.
5. **Rápida (Quick Sort)**: Divide el arreglo en torno a un pivote y ordena recursivamente
las partes antes y después del pivote. Es rápido y ampliamente utilizado.
6. **Montón (Heap Sort)**: Convierte el arreglo en un montón (heap) y extrae repetidamente
el elemento máximo (o mínimo). Es eficiente y no requiere espacio adicional.
7. **Conteo (Counting Sort)**: Ideal para arreglos con valores discretos. Cuenta el número
de elementos menores o iguales a cada valor y coloca los elementos en su posición
correcta.
8. **Radix (Radix Sort)**: Ordena los elementos basándose en sus dígitos, desde el dígito
menos significativo hasta el más significativo.
9. **Cubo (Bucket Sort)**: Divide el rango de valores en cubetas y luego ordena cada cubeta
individualmente.
Recuerda que la elección del algoritmo de ordenación debe considerar factores como el
tamaño del conjunto, la memoria disponible y las limitaciones del sistema ¹. Si tienes más
preguntas o necesitas detalles sobre alguno de estos algoritmos.
5. Cómo se implementan los métodos de búsqueda, recorrido y ordenamiento de un arreglo
en lenguaje C++?:
En C++, puedes implementar métodos de búsqueda, recorrido y ordenamiento de
arreglos de diversas maneras. A continuación, te proporciono algunos ejemplos y conceptos
clave:
Recorrido de un arreglo: Para recorrer un arreglo, puedes utilizar un bucle for que vaya
desde 0 hasta la longitud del arreglo menos 1. Puedes acceder al elemento actual usando
la notación de corchetes arreglo[índice] o arreglo.at(índice)1. Ejemplo de recorrido de un
arreglo en C++:
#include <iostream>
using namespace std;
int main() {
int miArreglo[] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; ++i) {
cout << "Elemento en la posición " << i << ": " << miArreglo[i] << endl;
}
return 0;
}
Búsqueda secuencial: La búsqueda secuencial implica recorrer el arreglo elemento por
elemento hasta encontrar el valor deseado. Si el elemento se encuentra, se devuelve su
posición; de lo contrario, se indica que no se encontró. Ejemplo de búsqueda secuencial en
C++:
int buscarSecuencial(int arreglo[], int longitud, int valorBuscado) {
for (int i = 0; i < longitud; ++i) {
if (arreglo[i] == valorBuscado) {
return i; // Elemento encontrado en la posición i
}
}
return -1; // Elemento no encontrado
}
Búsqueda binaria: La búsqueda binaria se aplica a arreglos ordenados. Divide el arreglo en
dos mitades y compara el valor buscado con el elemento central. Luego, se descarta una
mitad y se repite el proceso hasta encontrar el elemento o determinar que no está presente.
Ejemplo de búsqueda binaria en C++:
int buscarBinaria(int arreglo[], int longitud, int valorBuscado) {
int inicio = 0;
int fin = longitud - 1;
while (inicio <= fin) {
int medio = inicio + (fin - inicio) / 2;
if (arreglo[medio] == valorBuscado) {
return medio; // Elemento encontrado en la posición medio
} else if (arreglo[medio] < valorBuscado) {
inicio = medio + 1;
} else {
fin = medio - 1;
}
}
return -1; // Elemento no encontrado
}
Ordenamiento: Hay varios algoritmos de ordenamiento, como el método de burbuja, el
quicksort y el mergesort. Estos algoritmos reorganizan los elementos del arreglo en un
orden específico (ascendente o descendente). Ejemplo de ordenamiento por el método de
burbuja en C++:
void ordenarBurbuja(int arreglo[], int longitud) {
for (int i = 0; i < longitud - 1; ++i) {
for (int j = 0; j < longitud - i - 1; ++j) {
if (arreglo[j] > arreglo[j + 1]) {
swap(arreglo[j], arreglo[j + 1]);
}
}
}
}
Recuerda que estos son solo ejemplos básicos. En proyectos más complejos, puedes
modularizar y optimizar aún más tus implementaciones.
