Vectores

Vista previa del material en texto

VECTORES
ARRAYS
O ARREGLOS 
UNIDIMENSIONALES
• Definición, características, declaración.
• Carga, Lectura e impresión.
• Operaciones.
• Vectores paralelos.
• Métodos de búsqueda.
• Método de ordenamiento con un vector y
con vectores paralelos.
• Intercalación de vectores.
• Representación en un lenguaje C.
Un vector o arreglo unidimensional, es un conjunto
de datos con un numero fijo de componentes, todos
del mismo tipo.
DEFINICION
V 7 8 9 10
V[0] V[1] V[2] V[3]
REPRESENTACION GRAFICA
En un arreglo, el primer elemento siempre comienza en la
posición 0 y el ultimo elemento es el n-1. En el ejemplo
tenemos un arreglo de 4 elementos por lo tanto la ultima
posición es 3.
N=4
ORDEN
SUBINDICE
NOMBRE
• Almacenan los elementos en posiciones
contiguas de memoria.
• Tienen un mismo nombre de variable que
representa a todos los elementos.
• Se puede acceder a ellos de manera directa
mediante un índice (0,1,2,3) encerrado entre
corchetes[ ].
• Los elementos se almacenan en memoria RAM
CARACTERISTICAS
DECLARACION DE UN ARREGLO
tipo Nombre [ Tamaño] ;
Donde
Tipo: es el tipo de datos de los elementos del arreglo.
Nombre: es el nombre asignado al arreglo.
Tamaño: es la cantidad de elementos que puede soportar el arreglo.
EJEMPLOS
float numero[10]; Arreglo de 10 números reales 
int edad[45]; Arreglo de 45 enteros 
char ch[30]; Cadena de 30 caracteres 
INICIALIZACION DE UN VECTOR EN SU DEFINICION
int Numero [ ]= {2,6,1,8,9} ;
int legajo [10 ] ;
2 6 1 8 9
0 1 2 3 4
Si quisiéramos mostrar un elemento determinado del
vector, bastaría con poner los siguiente:
Mostrar numero[1] lo que visualizaría sería el numero 6.
Numero
UN VECTOR DE CARACTERES
char letras [ ]= {‘a’, ’e’, ’i’, ’o’, ’u’} ;
a e i o u
0 1 2 3 4
Si quisiéramos mostrar un elemento determinado del
vector, bastaría con poner los siguiente:
Mostrar letras[1] lo que visualizaría sería la letra e.
letras
•Unidimensionales (Vectores) 
•Bidimensionales (Matrices) 
•De 3 dimensiones(Tridimensionales) 
•De mas de 3 dimensiones 
(Multidimensionales)
CLASIFICACION DE LOS ARREGLOS
Tanto su lectura como su impresión se realizan con
una estructura de iteración cuyo corte de control
será i < N (orden del vector), siempre que se utilice
una estructura while y la variable contador
correspondiente al subíndice se inicialice con el
valor 0.
LECTURA E IMPRESIÓN DE UN VECTOR
i=0; i<N; i=i+1
PROC 
N
V[i]
i=0; i<N; i=i+1
PROC 3
S=S+V[i]
CARGA LECTURA
i=0; i<N; i=i+1
PROC 3
V[i]
IMPRESION
VECTORES CON 
FOR
i<N
i=0
i=i+1
PROC 
S
N
N
V[i]
VECTORES CON 
WHILE
i<N
i=0
i=i+1
PROC 
S
N
S=S+V[i]
i<N
i=0
i=i+1
PROC 
S
N
V[i]
CARGA
LECTURA
IMPRESION
Con vectores se pueden realizar las siguientes operaciones:
1. Suma de dos o más vectores.
2. Resta de dos o más vectores.
3. Multiplicación de dos o más vectores. 
4. División de dos vectores.
5. Multiplicación de un vector por un escalar. 
OPERACIONES CON UN VECTOR
Para sumar, restar o multiplicar dos o más vectores, los mismos deben ser del
mismo orden, es decir deben tener la misma cantidad de elementos.
En forma genérica: C[i]=A[i]+B[i] C[i]=A[i]-B[i] C[i]=A[i]*B[i]
En la división a parte de ser del mismo orden, es condición
necesaria que el vector B no tenga elementos nulos, ya que no es
posible la división por cero.
SUMA,RESTA,MULTIPLICACION yDIVISION DE DOS O MÁS VECTORES
Para multiplicar un vector A por un escalar k, se debe realizar el
producto de cada elemento del vector A por el escalar k.
En forma genérica: C[i]=A[i]*k
MULTIPLICACIÓN DE UN ESCALAR POR UN VECTOR
Dos o más arreglos que utilizan el mismo subíndice para acceder a elementos de
distintos arreglos, se denominan arreglos paralelos. Estos arreglos pueden
procesarse simultáneamente.
En los vectores paralelos la información se corresponde por posición y todos tienen
el mismo orden.
VECTORES PARALELOS
Por ejemplo supongamos que se registra la información de los productos en 3
vectores:
1. Vector cod: contiene los códigos de los productos.
2. Vector can: contiene la cantidad que hay en stock de cada producto.
3. Vector pre: contiene el precio de cada producto.
MÉTODOS DE ORDENAMIENTO
Aunque a lo largo de los años se han desarrollado muchos algoritmos
de ordenamiento, los usados con mas frecuencia son: método de la
burbuja, de selección, de la burbuja mejorada, shell.
Todos ellos realizan el ordenamiento en memoria RAM, por ello se
denominan métodos de ordenamiento interno.
2 6 1 8 9
0 1 2 3 4
1 2 6 8 9
0 1 2 3 4
Vector Original
Vector Ordenado
PRINCIPIOS GENERALES DEL ORDENAMIENTO
Los algoritmos que se presentan comparan elementos de un mismo vector, y, si los
dos elementos están desordenados se realiza una transferencia bidireccional
entre estos valores.
if (A [ i ] > A[i+1] )
{
AUX=A[i];
A[i] = A [i+1];
A[i+1]= AUX;
}
En la condición anterior, se debe incluir el operador de relación:
> si quiere realizar un ordenamiento en forma ascendente.
< si quiere realizar un ordenamiento en forma descendente.
El método es muy clásico y sencillo, pero poco eficiente. Se basa en la comparación
de elementos adyacentes en el vector, e intercambiando sus valores si están
desordenados.
Análisis:
Comienza de izquierda a derecha, comparando a[0] con a[1], si están desordenados
se intercambian entre si.
A continuación se compara a[1] con a[2] y así sucesivamente.
2 6 1 9 8
SI
Numero Actual > Numero Siguiente
CAMBIO
MÉTODO DE LA BURBUJA
2 6 1 9 82 6 1 9 82 1 6 9 82 1 6 9 82 1 6 8 92 1 6 8 91 2 6 8 91 2 6 8 91 2 6 8 91 2 6 8 9
SI
Numero Actual > Numero Siguiente
CAMBIO
MÉTODO DE LA BURBUJA 
Con DO WHILE
void ordenar(int N, int V[50])
{
int i,b,aux;
do
{
b=0;
for (i=0;i<N-1;i++)
{
if (V[i]>V[i+1])
{
aux=V[i];
V[i]=V[i+1];
V[i+1]=aux;
b=1;
}
}
}
while (b==1);
}
A
ordenar(5,A);
2 6 1 9 8
0 1 2 3 4
N b i for V(i) V(i+1)
V(i) > 
V(i+1)
aux
5 0 0 0<4 2 6 2>6 no
1 1<4 6 1 6>1 6 si
1 1 6
2 2<4 6 9 6>9 no
3 3<4 9 8 9>8 9 si
8 9
4 4<4
0 0 0<4 2 1 2>1 2 Si
1 1 2
1 1<4 2 6 2>6 No
2 2<4 6 8 No
3 3<4 8 9 No
4 4<4
void ordenar(int N, int V[50])
{
int i,b,aux;
do
{
b=0;
for (i=0;i<N-1;i++)
{
if (V[i]>V[i+1])
{
aux=V[i];
V[i]=V[i+1];
V[i+1]=aux;
b=1;
}
}
}
while (b==1);
}
A N=5
2 1 6 8 9
0 1 2 3 4
ORDENAMIENTO EN VECTORES PARALELOS
Para poder ordenar los vectores paralelos, se debe:
• en primer lugar, ingresar todos los vectores,
• en segundo lugar se debe tener en claro por cuál o cuáles
de los vectores se realizará el ordenamiento; siendo el
primer vector la clave principal de ordenamiento y los
demás se denominan claves secundarias.
ordenar(N,cod,can,pre);
void ordenar(int N, int A[50], int B[50], float C[50])
{
int i,b,aux,aux2,aux3;
do
{
b=0;
for (i=0;i<N-1;i++)
{
if (A[i]>A[i+1])
{
aux=A[i];
A[i]=A[i+1];
A[i+1]=aux;
aux2=B[i];
B[i]=B[i+1];
B[i+1]=aux2;
aux3=C[i];
C[i]=C[i+1];
C[i+1]=aux3;
b=1;
}
}
}
while (b==1);
}
ORDENA EL 
VECTOR A
ORDENA EL 
VECTOR B
ORDENA EL 
VECTOR C
Los métodos de búsquedas, tratan de determinar si un
determinado elemento se encuentra dentro de un vector o
no.
La búsqueda de un elemento dentro de un arreglo es una de
las operaciones más importantes en el procesamiento de la
información, y permite la recuperación de datos
previamente almacenados.
Todos los algoritmos de búsqueda tienen dos finalidades:
• Determinar si el elemento buscado se encuentra en el
conjunto en el que se busca.
• Si el elemento está en el conjunto, hallar la posición en la
que se encuentra.
MÉTODOS DE BÚSQUEDA
El vector puede estar o no ordenado.
Determina si el elemento k está o no en el vector, para lo
cual debe recorrer indefectiblemente el vector completo.
En este método se utiliza una variable bandera (b) a la cual
se le definen dos valores posibles, en este caso b=0
significa que el elemento k no está en el vector; en cambio
b=1 significa que k está.
MÉTODOS DE BÚSQUEDA SECUENCIAL
#include<stdio.h>
#include<stdlib.h>
#include<locale.h>
main ()
{ setlocale(LC_CTYPE,"Spanish");system("cls");
int n,i,v[50],k,b; 
printf("Ingrese el orden del vector: ");
scanf("%d",&n); 
printf("Ingrese el elemento k que desea buscar: ");
scanf("%d",&k); 
for (i=0;i<n;i++)
{
printf("\n v[%d]= ",i+1);
scanf("%d",&v[i]);
}
for(i=0;i<n;i++) //Recorre el vector buscando k
{
if (v[i]==k) //Si lo encuentra
{
printf("\n %d está en la posición %d",k,i+1);
b=1;
}
} 
if (b==0)
printf("%d no está en el vector",k);
printf("\n\n");
system("pause"); 
} 
Para usar este método el vector tiene que estar ordenado
en forma ascendente.
La búsqueda binaria consiste en dividir el arreglo por su
elemento medio en dos subarreglos más pequeños, y
comparar el elemento con el del centro. Si coinciden, la
búsqueda termina. Si el elemento es menor, debe estar (si
está) en el primer subarray, y si es mayor está en el
segundo; se descarta la mitad en la que no está y
nuevamente en la mitad en la que se puede encontrar el
valor k se encuentra el valor medio y se repite el trabajo.
MÉTODOS DE BÚSQUEDA BINARIA
iz=0;
de=n-1;
b=0;
while (iz<=de && b==0)
{
c=(iz+de)/2;
if (v[c]==k)
b=1; 
else
{ 
if (k>v[c]) 
iz=c+1;
else
de=c-1; 
}
} // Fin del while
if (b==1)
printf("El elemento se encontró en la posición %d",c+1);
else
printf("El elemento no se encontró");
Algoritmo DE BÚSQUEDA BINARIA
INTERCALACIÓN DE VECTORES
Este método se utiliza para generar un vector ordenado de
datos a partir de otros vectores también ordenados.
El proceso consiste en seleccionar sucesivamente los
elementos de cada uno de los vectores primitivos y
compararlos.
En el presente programa se emplean dos vectores A y B de
orden N y M respectivamente, ambos ordenados; a partir
de ellos se genera un tercer vector C, también ordenado, en
el cual figuran lo elementos de A y de B.
// PROCESO DE INTERCALACION
i=0;
j=0;
k=0;
while (i<n && j<m)
{
if (a[i]==b[j])
{ 
c[k]=a[i];
i=i+1;
j=j+1; 
}
else
{ 
if (a[i]<b[j])
{ 
c[k]=a[i];
i=i+1; 
}
else
{ 
c[k]=b[j];
j=j+1; 
}
} 
k=k+1;
} 
while (i<n)
{
c[k]=a[i];
i=i+1;
k=k+1;
} 
while (j<m)
{
c[k]=b[j];
j=j+1;
k=k+1;
} 
p=k; //p es el nuevo orden del vector intercalado
#include <stdio.h>
#include <stdlib.h>
main() 
{ 
int vector[25], i,N; 
printf("\nIngrese la cantidad de elementos: ");
scanf("%d",&N);
//CARGA DEL VECTOR
for(i=0;i<N;i++)
{ 
printf("Ingrese el elemento %d: ",i+1);
scanf("%d",&vector[i]); 
}
//VISUALIZACION DEL VECTOR
for(i=0;i<N;i++)
{ 
printf("\nElemento %d: %d",i+1,vector[i]);
}
system("pause");
}
CARGA Y MUESTRA DE UN VECTOR
CARGA Y MUESTRA DE UN VECTOR CON FUNCION
#include <stdio.h>
#include <stdlib.h>
void carga(int Orden, int vec[50]);
void mostrar(int Orden, int vec[50]);
main() 
{ 
int vector[25],N; 
printf("\nIngrese la cantidad de elementos: ");
scanf("%d",&N);
carga(N,vector);
mostrar(N,vector);
printf("\n");
system("pause");
}
void carga(int Orden, int vec[50]) //CARGA DEL VECTOR
{
int i;
for(i=0;i<Orden;i++)
{ 
printf("Ingrese el elemento %d: ",i+1);
scanf("%d",&vec[i]); 
}
}
void mostrar(int Orden, int vec[50]) //VISUALIZACION DEL VECTOR
{
int i;
printf("\nCONTENIDO DEL VECTOR");
for(i=0;i<Orden;i++)
{ 
printf("\nElemento %d: %d",i+1,vec[i]);
}
}
1)  Se tiene un arreglo de N posiciones, donde cada celda contiene un
números entero.
Se pide
a. En una función sin tipo, Registrar la carga del arreglo.
b. Usando una función con tipo, obtener y devolver el menor valor ingresado a la 
función main(), y mostrar dicho valor.
c. Usando una función con tipo, obtener el promedio del arreglo y mostrar en la 
función main. 
Ejemplo – Arreglos Unidimensionales
#include <stdio.h>
#include <stdlib.h>
void carga(int Orden, int vec[50]);
int menor(int Orden, int vec[50]);
float promedio(int Orden, int vec[50]);
void ordenar(int Orden, int vec[50]);
void mostrar(int Orden, int vec[50]);
main() 
{ 
int vector[25],N,men; 
float prome;
printf("\nIngrese la cantidad de elementos: ");
scanf("%d",&N);
carga(N,vector);
men=menor(N,vector);
printf("\nEl Elemento menor del vector es: %d",men);
printf("\n");
system("pause");
prome=promedio(N,vector);
printf("\nEl Promedio del vector es: %.2f",prome);
printf("\n");
system("pause");
printf("\nLos Elementos del vector es:");
mostrar(N,vector);
printf("\n");
system("pause");
ordenar(N,vector);
printf("\nEl Vector Ordenado es:");
mostrar(N,vector);
printf("\n");
system("pause");
}
//CARGA DEL VECTOR
void carga(int Orden, int vec[50])
{
int i;
for(i=0;i<Orden;i++)
{ 
printf("Ingrese el elemento %d: ",i+1);
scanf("%d",&vec[i]); 
}
}
//ELEMENTO MENOR DEL VECTOR
int menor(int Orden, int vec[50])
{
int i,menval=vec[0];
for(i=1;i<Orden;i++)
{ 
if (vec[i]<menval)
menval=vec[i];
}
return menval;
}
//MOSTRAR VECTOR
void mostrar(int Orden, int vec[50])
{
int i;
printf("\nSe mostraran los Elementos del Vector");
printf("\n***********************************
**\n");
for(i=0;i<Orden;i++)
{
printf("\nElemento vector(%d) ---> %d",i+1,vec[i]);
} 
}
//PROMEDIO DEL VECTOR
float promedio(int Orden, int
vec[50])
{
int i,s;
float promval;
for(i=0;i<Orden;i++)
{ 
s=s+vec[i];
}
promval= float (s)/float (Orden);
return promval;
}
//ORDENAR VECTOR
void ordenar(int Orden, int vec[50])
{
int i,b,aux;
do
{
b=0;
for (i=0;i<Orden-1;i++)
{
if (vec[i]>vec[i+1])
{
aux=vec[i];
vec[i]=vec[i+1];
vec[i+1]=aux;
b=1;
}
}
}
while (b==1);
}
1) Dado un vector A de números enteros de orden N y un valor K entero; genere un
vector B con los elementos de A que sean múltiplos de k. Realice la lectura del
vector a través de una función.
2) Dado un vector de N elementos, calcular a través de una función sin tipo, la
suma de los valores que se encuentren en una posición par, y la suma de los
valores impares. Mostrar el resultado en main().