REPÚBLICA BOLIVARIANA DE VENEZUELA

UNIVERSIDAD POLITÉCNICA TERRITORIAL

ALONSO GAMERO
CORO – ESTADO FALCÓN
INFORMÁTICA
ALGORÍTMICA Y PROGRAMACIÓN I
SECCION 05

ARREGLOS

Docente: Bachiller:

Prof. Iván Castillo Jesús Morillo

C.I. 30.295.629

Santa Ana de Coro, Mayo de 2022.

 ARREGLOS

Un arreglo (vector, array, matriz) es un conjunto de datos o una estructura de

datos homogéneos que se encuentran ubicados en forma consecutiva en la
memoria RAM y sirven para almacenar datos en forma temporal. Los arreglos
pueden ser de los siguientes tipos:

• De una dimensión.
• De dos dimensiones.
• De tres o más dimensiones.

Clasificación de los arreglos:

• Unidimensionales

Es un tipo de datos estructurado que está formado de una colección finita y

ordenada de datos del mismo tipo. Es la estructura natural para modelar listas
de elementos iguales. Están formados por un conjunto de elementos de un
mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian
por la posición que tiene cada elemento dentro del arreglo de datos. Al declarar
un arreglo, se debe inicializar sus elementos antes de utilizarlos. Para declarar
un arreglo tiene que indicar su tipo, un nombre único y la cantidad de elementos
que va a contener.

• Multidimensionales

Es un tipo de dato estructurado, que está compuesto por dimensiones. Para

hacer referencia a cada componente del arreglo es necesario utilizar n índices,
uno para cada dimensión. El término dimensión representa el número de índices
utilizados para referirse a un elemento particular en el arreglo. Los arreglos de
más de una dimensión se llaman arreglos multidimensionales.

• Con múltiples subíndices

 Es la representación de tablas de valores, consistiendo de información
arreglada en renglones y columnas. Para identificar un elemento particular de la
tabla, deberemos de especificar dos subíndices; el primero identifica el renglón
del elemento y el segundo identifica la columna del elemento. A los arreglos que
requieren dos subíndices para identificar un elemento en particular se conocen
como arreglo de doble subíndice. Note que los arreglos de múltiples subíndices
pueden tener más de dos subíndices. El estándar ANSI indica que un sistema
ANSI C debe soportar por lo menos 12 subíndices de arreglo.

Operaciones con arreglos

Las limitaciones que tienen los arreglos respecto de las listas son
compensadas por la cantidad de operaciones convenientes que permiten
realizar sobre ellos.
Las operaciones aritméticas entre arreglos se aplican elemento a elemento:

>>> a = array([55, 21, 19, 11, 9])

>>> b = array([12, -9, 0, 22, -9])

# sumar los dos arreglos elemento a elemento

>>> a + b

array([67, 12, 19, 33, 0])

# multiplicar elemento a elemento

>>> a * b

array([ 660, -189, 0, 242, -81])

# restar elemento a elemento

>>> a - b

array([ 43, 30, 19, -11, 18])

 Las operaciones entre un arreglo y un valor simple funcionan aplicando la
operación a todos los elementos del arreglo, usando el valor simple como
operando todas las veces:

>>> a

array([55, 21, 19, 11, 9])

# multiplicar por 0.1 todos los elementos

>>> 0.1 * a

array([ 5.5, 2.1, 1.9, 1.1, 0.9])

# restar 9.0 a todos los elementos

>>> a - 9.0

array([ 46., 12., 10., 2., 0.])

Si quisiéramos hacer estas operaciones usando listas, necesitaríamos usar

un ciclo para hacer las operaciones elemento a elemento.
Las operaciones relacionales también se aplican elemento a elemento, y
retornan un arreglo de valores booleanos:

>>> a = array([5.1, 2.4, 3.8, 3.9])

>>> b = array([4.2, 8.7, 3.9, 0.3])

>>> c = array([5, 2, 4, 4]) +array([1, 4, -2, -1]) / 10.0

>>> a < b

array([False, True, True, False], dtype=bool)

>>> a == c

array([ True, True, True, True], dtype=bool)

 Para reducir el arreglo de booleanos a un único valor, se puede usar las
funciones any y all. anyretorna True si al menos uno de los elementos es
verdadero, mientras que all retorna True sólo si todos lo son (en
inglés, any signfica «alguno», y all significa «todos»):

>>> any(a < b)

True

>>> any(a == b)

False

>>> all(a == c)

True

Métodos de ordenamiento

La ordenación o clasificación es el proceso de organizar datos en algún orden

o secuencia específica, tal como creciente o decreciente, para datos numéricos,
o alfabéticos, para datos de caracteres. Los métodos de ordenación más directos
son los que se realizan en el espacio ocupado por el array. Los más populares
son:

• Método de Intercambio o de Burbuja

Se basa en el principio de comparar pares de elementos adyacentes e

intercambiarlos entre si hasta que estén todos ordenados. Supongamos que se
desea clasificar en orden ascendente el vector o lista:

9, 8, 0, 2, 5, 1, 3, 2, 9

A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

Los pasos a dar son:

- Comparar A[1] y A[2] si están en orden, se mantienen como están, en caso

contrario se intercambian entre si.

- A continuación se comparan los elementos 2 y 3; de nuevo se intercambian si

es necesario.

- El proceso continua hasta que cada elemento del vector ha sido comparado
con sus elementos adyacentes y se han realizado los intercambios necesarios.
 /*Ordenamiento Burbuja */

#include <stdio.h>
#include <conio.h>
#define TAM 9

int main()
{
int a[TAM] = { 9, 8, 0, 2, 5, 1, 3, 2, 9};
int i, pasada, aux;

printf("Datos en el orden inicial:\n\n");

for(i=0;i<=TAM-1;i++)
printf("%4d",a[i]);
for (pasada=1;pasada<=TAM-1;pasada++) /*pasadas*/
for (i=0;i<=TAM-2;i++)
if (a[i]>a[i+1]) /*comparación */
{
/*intercambio*/
aux=a[i];
a[i] = a[i+1];
a[i+1] = aux;
}
printf( "\n\nDatos ordenados en sentido ascendente:\n\n" );
for (i=0;i<=TAM-1;i++ )
printf("%4d", a[i]);
printf("\n");
getch();
return 0;
}

• Ordenamiento por inserción (Insertion Sort)

Consiste en insertar un elemento en el vector en una parte ya ordenada de

este vector y comenzar de nuevo con los elementos restantes. Por ser utilizado
generalmente por los jugadores de cartas se le conoce también por el método
de la baraja. Por ejemplo, supóngase que se tiene la lista desordenada;

5 14 24 39 43 65 84 45

Para insertar el elemento 45, habrá que insertar entre 43 y 65, lo que supone
desplazar a la derecha todos aquellos números de valor superior a 45, es decir,
saltar sobre 65 y 84.

5 14 24 39 43 65 84 45

El método se basa en comparaciones y desplazamientos sucesivos. El

algoritmo de clasificaciones de un vector X para N elementos se realiza con un
recorrido de todo el vector y la inserción del elemento correspondiente en el lugar
adecuado. El recorrido se realiza desde el segundo elemento al enésimo.
#include <stdio.h>
int arreglo[10] = {3,10,1,8,15,5,12,6,5,4}; /*Declaracion e inicialización
del arreglo. */

/*imprimearreglo - Funcion que muestra por pantalla

el contenido de un arreglo.*/
void imprimearreglo() {
int i; for (i=0;i<10;i++)
printf("Elemento %d: %d \n",i,arreglo[i]);
}

void main() /*Funcion Principal del Programa*/

{
int i,j,k;
imprimearreglo();
for (i=1; i<10; i++) {
j=i;
while (j>=0 && arreglo[j]<arreglo[j-1]) {
k=arreglo[j];
arreglo[j]=arreglo[j-1];
arreglo[j-1]=k;
j--;
}
}
printf("\n\nArreglo ordenado \n\n");
imprimearreglo();
}

• Ordenamiento Rápido (Quicksort)

El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la

técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en
un tiempo proporcional a n log n. Esta es la técnica de ordenamiento más rápida
conocida. El algoritmo fundamental es el siguiente:

❖ Elegir un elemento de la lista de elementos a ordenar, al que llamaremos

pivote.
❖ Resituar los demás elementos de la lista a cada lado del pivote, de manera
que a un lado queden todos los menores que él, y al otro los mayores. En
este momento, el pivote ocupa exactamente el lugar que le corresponderá
en la lista ordenada.
❖ La lista queda separada en dos sublistas, una formada por los elementos
a la izquierda del pivote, y otra por los elementos a su derecha.
❖ Repetir este proceso de forma recursiva para cada sublista mientras éstas
contengan más de un elemento. Una vez terminado este proceso todos
los elementos estarán ordenados. Como se puede suponer, la eficiencia
del algoritmo depende de la posición en la que termine el pivote elegido.
Pseudocódigo QuickSort:

Nombre Función: OrdRap

Parámetros:
lista a ordenar (lista)
índice inferior (inf)
índice superior (sup)

// Inicialización de variables
1. elem_div = lista[sup];
2. i = inf - 1;
3. j = sup;
4. cont = 1;

// Verificamos que no se crucen los límites

5. if (inf >= sup)
6. retornar;

// Clasificamos la sublista
7. while (cont)
8. while (lista[++i] < elem_div);
9. while (lista[--j] > elem_div);
10. if (i < j)
11. temp = lista[i];
12. lista[i] = lista[j];
13. lista[j] = temp;
14. else
15. cont = 0;

// Copiamos el elemento de división

// en su posición final
16. temp = lista[i];
17. lista[i] = lista[sup];
18. lista[sup] = temp;

// Aplicamos la función
19. OrdRap (lista, inf, i - 1);
20. OrdRap (lista, i + 1, sup);

Ejemplo de Implementación de Quicksort en C:

void SortArray (int array[],int first,int last)

{
int i,j,p,t;

// i se hace igual al índice del primer elemento

i= first;
// y j igual al índice del último elemento
j= last;
// p se hace igual al elemento pivote del arreglo
p= array[(first+last)/2];

do {
 // se hace la partición del arreglo
while (array[i]<p) i++;
while (p<array[j]) j--;
if (i<=j) {

// se intercambian los elementos i-esimo y j-esimo del

arreglo
t= array[i];
array[i]= array[j];
array[j]= t;
i++; j--;
}
} while (i<=j);
if (first<j) SortArray(array,first,j);
if (i<last) SortArray(array,i,last);
}

Métodos de búsqueda

La búsqueda es una operación que tiene por objeto la localización de un

elemento dentro de la estructura de datos (arreglo). A menudo un programador
estará trabajando con grandes cantidades de datos almacenados en arreglos y
pudiera resultar necesario determinar si un arreglo contiene un valor que coincide
con algún valor clave o buscado.

• Búsqueda secuencial

Este algoritmo compara uno a uno los elementos del arreglo hasta recorrerlo
por completo indicando si el número buscado existe.

Su implementación es la siguiente:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define TAM 10

void main() {
int a[TAM], temp, i, j, num;

randomize(); //Inicializa el generador de numeros aleatorios

printf ("Llenando arreglo con números aleatorios\n");
for (i=0; i< TAM; i++)
a[i]=random(100);
printf ("Numero a buscar? ");
scanf ("%d", &num);
for (i=0; i< TAM; i++)
if (a[i] == num){
printf ("\nValor encontrado");
printf ("\nPosicion: %d", i);
 }
else
printf ("\nNo existe");
printf ("El arreglo era:\n");
for (i=0; i< TAM; i++)
printf ("%d ", a[i]);
getch();
}

• Búsqueda binaria

Este algoritmo permite buscar de una manera más eficiente un dato dentro
de un arreglo, para hacer esto se determina el elemento central del arreglo y se
compara con el valor que se esta buscando, si coincide termina la búsqueda y
en caso de no ser así se determina si el dato es mayor o menor que el elemento
central, de esta forma se elimina una mitad del arreglo junto con el elemento
central para repetir el proceso hasta encontrarlo o tener solo un elemento en el
arreglo.

Para poder aplicar este algoritmo se requiere que el arreglo este ordenado.
Su implementación es la siguiente:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define TAM 15

void main(){
int a[TAM], busca, temp, bajo, alto, central;

printf("Llenando el arreglo con números aleatorios\n");

randomize(); //Inicializa el generador de aleatorios
for (int i=0; i< TAM; i++)
a[i]=random(100);
//Implementacion de Ordenamiento por burbuja de menor a mayor
printf ("Ordenando arreglo...\n");
for (int j=1; j <= TAM; j++)
for (i=0; i< TAM-1; i++)
if (a[i] > a[i+1]){
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}

//Implementacion de busqueda binaria

printf ("\nIntroduce un numero a buscar: ");
scanf ("%d", &busca);

bajo = 0;
alto = TAM-1;
central = (bajo+alto)/2;
while (bajo < alto && busca != a[central]){
 if(busca > a[central])
bajo = central+1;
else
alto = central-1;
central=(bajo+alto)/2;
}

if (busca == a[central])
printf("\n%d encontrado en posicion %d", busca, central);
else
printf("\n%d no existe", busca);
printf ("\n\nEl arreglo ordenado era\n\n");
for (i=0; i< TAM; i++)
printf ("%d ", a[i]);
getch();
}