|
 Arreglos de una dimensión o vectores.
Operaciones
fundamentales en arreglos unidimensionales. (Vectores).
Borrar
Insertar
(En vector ordenado, o en
desordenado)
Búsqueda
(Secuencial,
binaria)
ordenar (Burbuja,
burbuja mejorado,
Selección,
Inserción directa o baraja)
Otros códigos sobre
vectores.
Código
ordenación por el método de la burbuja con procedimientos. (Vector).
---------------------------------------------------------
 Arreglos
de una dimensión o vectores.
Un vector es un arreglo donde los
elementos que lo conforman están dispuestos bajo un mismo concepto de
clasificación (fila o columna), es decir, los datos están organizados de una
manera lineal, por lo que para referenciar un elemento del arreglo es necesario
un índice, que indique la posición relativa del elemento en el arreglo.
Cuando el nombre del arreglo se le
adiciona el índice, es tomado como una variable simple, por lo tanto puede estar
involucrada en una expresión, en una entrada o salida de datos, o en una
asignación.
Donde el nombre es el que se ha
escogido para todos los elementos del arreglo, y cada rectángulo representa los
componentes o elementos que lo conforman.
Si los valores 30, 15, 20, 60 y 80
representan las edades de cinco personas y queremos tener almacenada esta
información en memoria para ser utilizada en un proceso por computadora,
perfectamente podemos guardarla en cinco nombres de variables distintas como
EDAD1, EDAD2, EDAD3, EDAD4 y EDAD5; pero ¿qué pasa sino son cinco sino mil
edades, o mas de mil?, sin duda que se convierte en proceso engorroso y difícil
de manejar, pero que se puede solucionar almacenando esta información en un
arreglo, que en este caso sería de una dimensión. Si se escoge el nombre
EDAD como nombre del arreglo para identificar el conjunto de las cinco edades,
internamente en memoria se separan cinco espacios (direcciones de memoria)
adyacentes para almacenar en el momentos oportuno la información requerida.
Si un programa utiliza la variable tipo arreglo EDAD, después de la compilación
sucederá lo siguiente.
Donde cada elemento del vector EDAD
se puede procesar como si fuese una variable simple, al ocupar cada uno una
posición de memoria diferente; esto implica que en los arreglos el acceso a un
elemento se hace en forma directa, es decir, que cualquier elemento se puede
referenciar sin necesidad de accesar los anteriores a él.
Las siguientes dos instrucciones
muestran la independencia que tiene cada una de las variables que pertenecen al
arreglo, al adicionar el índice.
cin>>EDAD[1]>>EDAD[3]>>EDAD[5];
cout<<EDAD[5]<<EDAD[1];
Si los valores de las tres variables
en la instrucción de la lectura son 30, 20 y 80, al ejecutarse las instrucciones
anteriores sucederá lo siguiente:
En general se puede decir que
EDAD[1]hace referencia al contenido que tiene la componente, o elemento ubicado
en la posición i del arreglo EDAD, donde 1<=i<=5.
Los arreglos pueden ser utilizados
como acumuladores o contadores, inicializando cada uno de sus elementos.
Por ejemplo, llevar cero a cada uno de los elementos del arreglo EDAD.
 Ir a inicio de página.
---------------------------------------------------------
Operaciones fundamentales en arreglos
unidimensionales. (Vectores).
Borrar
Insertar (En vector
ordenado, o en
desordenado)
Búsqueda
(Secuencial,
binaria)
ordenar (Burbuja,
burbuja mejorado,
Selección,
Inserción directa o baraja)
ORDENAR:
Consiste
en organizar los elementos de un arreglo en algún orden específico, sea de menor
a mayor o de mayor a menor.
De menor a mayor--->A[1]<A[2]<A[3]<A[4].....<A[N]
De mayor a menor--->A[1]>A[2]>A[3]>A[4].....>A[N]
ORDENACIÓN POR BURBUJA:
Es un método no muy eficiente. Su fundamento es comparar elementos
adyacentes del arreglo e intercambiar los valores, si no están en orden.
Los elementos mas pequeños pasan a formar parte del principio del vector y los
más grandes por el contrario pasan a formar parte de la cola del arreglo.
Ejemplo:
 Código
ordenación por el método de la burbuja sin procedimientos (sencillo).
#include<conio.h>
#include<iostream.h>
void main()
{
int n,v[20],columna=3;/*n--->para el número de elementos a
entrar en el vector, v[20]--->declaración del vector de
20 posiciones, o sea que n
no debe ser mayor a 20., columna=3--->para especificar posición de
aparición de elemento*/
clrscr();/*borra pantalla*/
int i,j,aux;/*variables: "i" y "j" son para los índices.
la "i" es solo para
leer y mostrar los elementos del vector. la "i" y la "j" se necesitan para
controlar los índices en el ordenamiento de la burbuja, la "i" es para el
n£mero de comparaciones que se tienen que hacer (siempre es n-1) y la "j"
para las comparaciones internas (para identificar si el elemento uno es
mayor a el elemento 2) si esto es cierto el uno pasa a una variable aux
el dos pasa para donde estaba el uno, y lo que se paso a la variable aux
pasa a donde estaba el dos-----> así mas o menos es el procedimiento
aux=1;
1=2;
2=aux;
estas asignaciones se hacen n-1 veces.*/
gotoxy(1,1);/*para especificar la posición en que se
quiere que salga el
mensaje de "ingrese la cantid.........."*/
cout<<"Ingrese la cantidad de n£meros a introducir en el vector, ";
cout<<endl<<"(No mayor a 18)----->";
cin>>n;/*lee n. (número de elementos a entrar)*/
for(i=0;i<n;i++)/*la variable i es un índice de posición
de memoria de v[]
y aumenta de a uno (i++)en ves de i++ se puede i=i+1.*/
{
gotoxy(columna+i,11);/*para que el cursor se sitúe en la
posición a recibir
el elemento del vector*/
cin>>v[i];
columna+=3;/*en ves de esta línea se puede también-->
columna=columna+3;*/
}
/*las líneas anteriores fueron para ingresar el numero de
elementos a leer
en el vector, y para ingresar los valores al vector.*/
clrscr();/*borra pantalla.*/
gotoxy(3,5);/*Para posicionar mensaje, sino se suprime el
gotoxy, el mensaje
saldrá en la posición (0,0) o sea que la primera letra del mensaje saldrá en
la esquina superior izquierda.*/
cout<<"Este es el vector leído.";
columna=3;
for(i=0;i<n;i++)
{
gotoxy(columna+i,11); //Estas líneas muestran el vector
leído.
cout<<v[i];
columna+=3;
}
getch(); //Para detener progreso de ejecución.
//ESTE ES EL METODO DE LA BURBUJA.
for(i=0;i<n-1;i++)/*Número de comparaciones que deben
hacerse (n-1)*/
{
for(j=0;j<n-1;j++)/*Comparaciones internas.*/
{
if(v[j]>v[j+1])/*Identifica si el elemento de la posición
[j] es mayor que
el elemento en la posición [j+1]*/
{
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
}
//LAS LINEAS SIGUIENTES MUESTRAN EL VECTOR ORDENADO.
clrscr();
gotoxy(3,5);
columna=3;
cout<<"Este es el vector ordenado.";
for(i=0;i<n;i++)
{
gotoxy(columna+i,11);
cout<<v[i];
columna+=3;
}
getch();
}
 Código ordenación
por el método de la burbuja sin procedimientos (sencillo). (Vector).
Código ordenación
por el método de al burbuja con procedimientos. (Vector).
Ir a inicio de página.
ORDENACIÓN POR BURBUJA
MEJORADO: Es un método mucho más eficaz que el de burbuja, si
en una pasada no se realizan cambios, termina la ejecución. Es eficiente
cuando el vector está ordenado o semiordenado.
Código
ordenación por el método de la burbuja mejorado.
#include<conio.h>/*getch
y clrsrc.*/
#include<iostream.h>/*cout y cin.*/
void main()
{
int a[21],i,j,aux,ban,tama;
clrscr();
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)/*for que lee el vector.*/
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<endl<<endl<<"Presione una tecla para continuar...";
getch();/*Se detiene la ejecución del programa hasta que
se presione una
tecla.*/
i=0;
do
{/*Instrucción que repite el procedimiento, hasta que no
se detecten
intercambios en una pasada, la encargada de el detectamiento es la variable
ban, esta se mantiene con un valor de uno mientras no hayan intercambios, si
ocurre un intercambio la bandera tendrá un cero, y el ciclo se repite
mientras la bandera sea diferente de uno.*/
ban=1;
for(j=0; j<tama-(i+1); j++)
{
if(a[j]>a[j+1])
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
ban=0;
}
}
i++;
}
while(ban!=1);/*Instrucción que determina si se repite el
ciclo.*/
clrscr();
cout<<"El vector ordenado es:"<<endl<<endl;
/*Las líneas siguientes muestran el vector ordenado.*/
for(i=0;i<tama;i++)
{
cout<<"Elemento "<<i+1<<": "<<a[i]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();/*Detiene la ejecución del programa.*/
}
Código
ordenación por el método de la burbuja mejorado.
Ir a inicio de página.
ORDENACIÓN POR SELECCIÓN:
Es un método que consiste en buscar el elemento menor del vector y llevarlo a la
primera posición. Se debe hacer un ciclo que empiece en la posición dos
del vector, pero anteriormente se tiene que asumir que el elemento menor es el
que esta en la posición uno y cuando se encuentre un número menor a este
supuesto, se lleva el nuevo número menor a esta variable. Después se
buscará el segundo menor asumiendo que es el que está en la segunda posición y
se recorre el arreglo a partir de la posición tres, haciendo su respectivo
intercambio cuando se encuentre un menor. Este procedimiento se hace
tamaño-1 veces. Cada ves que se encuentre un menor es necesario guardar la
posición de este menor en una variable.
Ejemplo: Si tenemos un vector
4 5 2 3 1 sucederá lo siguiente:
Después del cuarto paso el elemento
ubicado en el quinto lugar queda ordenado, y por otra parte no habrán más
elementos para comparar, se hacen tamaño-1 intercambios para terminar el
proceso.
Código, ordena los
elementos de un vector por el método de selección.
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();
int a[21],i,j,menor,posicion,aux,tama;
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)/*for para ingresar elementos al
vector.*/
{
cout<<"El elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();
for(i=0; i<tama-1; i++)
{
menor=a[i];
posicion=i;
for(j=i+1; j<tama; j++)
{
if(menor > a[j])
{
menor=a[j];
posicion=j;
}
}
aux=a[i];
a[i]=menor;
a[posicion]=aux;
}
clrscr();
cout<<"Este es el vector ordenado:"<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"Elemento "<<i+1<<": "<<a[i]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para continuar...";
getch();
}
Código, ordena los
elementos de un vector por el método de selección.
Ir a inicio de página.
ORDENACIÓN POR INSERCIÓN
DIRECTA (BARAJA): Este método se fundamenta en la táctica que
emplean los jugadores de baraja. El jugador va ubicando cada carta en la
ubicación correcta. El jugador empieza a ordenar sus cartas a partir de la
segunda carta que le llega. Si tiene las cartas Q, J, las coloca como J, Q
(hace le intercambio). La técnica usada para el ordenamiento es ir
insertando cada uno de los elementos a partir del elemento dos en el lugar que
le corresponde por su valor, lo que implica correr todos los valores de la
derecha una posición para dejar espacio. El valor que se inserta se hace
en el lugar que tenía el último valor desplazado, y para no borrar su contenido
se guarda en una variable auxiliar.
Ordenación de los
elementos de un vector mediante el método de la inserción directa o baraja.
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();
int a[20],i,j,auxiliar,bandera,tama;
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<endl<<endl<<"Presione una tecla para continuar...";
getch();
for(j=1; j<tama; j++)
{
i=j;
auxiliar=a[j];
bandera=0;
while((i > 0)&&(bandera==0))
{
if(a[i-1] > auxiliar)
{
a[i]=a[i-1];
i--;
}
else
bandera=1;
}
a[i]=auxiliar;
}
clrscr();
cout<<"El vector ordenado es:"<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"Elementos "<<i+1<<": "<<a[i]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();
}/*Fin del main.*/
Programa,
Ordenación de los elementos de un vector mediante el método de la inserción
directa o baraja.
Ir a inicio de página.
BORRAR:
Esta operación se puede hacer estando o no el vector ordenado. Es
necesario tener en cuenta--->
Darnos por enterados que el vector
no este vacío mediante una verificación (aspecto a tener en cuenta si se trabaja
con procedimientos), explorar la posición en la cual está
ubicado el elementos a ser borrado, correr los elementos una posición hacia la
izquierda, a partir de la posición siguiente donde se encuentra el valor a
borrar, decrementar la cantidad de elementos del vector en uno y por último,
será mas eficaz el programa si se hace que salga por pantalla un mensaje
indicando que el elemento a buscar no se encuentra en el vector.
Código que elimina un
elemento de un vector ingresado.
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();/*Borra pantalla.*/
int a[20],tama,valorborrar,i,k;/*a[20]--->Declaración de
vector de hasta 20
enteros. tama--->Almacenar el tamaño del vector. valorborrar--->
Almacenar el elemento a borrar. "i" y "k"--->Indices para posiciones del
vector y para controlar ciclos.*/
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)/*Para leer el vector.*/
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<"Cúal es el elemento a borrar?---> ";
cin>>valorborrar;
i=0;
if(tama > 0)
{
while((i < tama) && (valorborrar != a[i]))
i++;
if(i < tama)
{
for(k=i; k < (tama-1); k++)
{
a[k]=a[k+1];
}
tama--;/*Se hace un decremento en uno a la variable
"tama".*/
}
else
{
clrscr();
cout<<valorborrar;
cout<<" NO ESTA EN EL ARREGLO";
}
}
cout<<endl<<endl;
cout<<"Presione una tecla para continuar... ";
getch();/*Detiene la ejecución del programa.*/
clrscr();
cout<<"El vector después del intento de borrado es:"<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"El elemento "<<i+1<<": "<<a[i]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();/*Detiene la ejecución del programa.*/
}/*Fin main.*/
Código que elimina
un elemento de un vector ingresado.
Ir a inicio de página.
BÚSQUEDA:
Este proceso consiste en localizar un valor específico dentro de un arreglo,
para buscar alguna información.
BÚSQUEDA SECUENCIAL:
Es un procedimiento muy sencillo que consiste en caminar todo el arreglo en
busca del valor, si esto es posible el programa devolverá la posición en donde
se encuentra dicho elemento, de no ser así se enviará un mensaje diciendo que el
valor buscado no se encuentra en el vector.
Código que busca un
valor en forma secuencial.
#include<conio.h>
#include<iostream.h>
void main()/*Inicia el main.*/
{
clrscr();/*Se limpia la pantalla.*/
int i,j,tama,a[21],valorbuscar,posicion;/*i y j--->Indices
para recorrer el
vector. tama--->Variable que almacenar el tamaño del vector.
a[21]--->Declaración del vector de hasta 20 enteros. valorbuscar--->obvio.
posicion--->Cuando se encuentra el valor a buscar, a la variable posición se
le asigna el índice, o sea la posición en que est en valor.*/
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)/*for para leer el vector.*/
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<endl<<"Digite el valor a buscar---> ";
cin>>valorbuscar;
clrscr();
i=0;/*Se incializa a cero para empezar a comparar valor
buscar con los
elementos del vector.*/
while(i<tama&&valorbuscar!=a[i])
i++;/*Si el valor no está en el vector la i se
incrementará hasta ser igual
que tama, y permitir así que no se cumpla la siguiente instrucción.*/
if(i<tama)/*Si no se cumple esto es porque no se encontró
el valor.*/
posicion=i;
else
posicion=0;
if(posicion!=0)
cout<<"El valor "<<valorbuscar<<" está en la posición "<<posicion+1<<".";
else
cout<<"El valor "<<valorbuscar<<" no est en el vector.";
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();/*Se detiene la ejecución del programa hasta que
el usuario digite
alguna tecla.*/
}/*Fin del main.*/
Programa, busca un
valor en forma secuencial.
Ir a inicio de página.
BÚSQUEDA BINARIA:
En este caso es necesario ordenar el vector antes de aplicar el proceso de
búsqueda binaria, sino se hace la ordenación, éste método es obsoleto. A
comparación de la búsqueda secuencial, en este método no es necesario recorrer
todo el arreglo, esto quiere decir que ésta aplicación es más eficiente cuando
se trate de arreglos demasiado grandes. Ya lo veremos. En éste
método dividiremos el arreglo en dos partes y compararemos el valor a buscar con
el elemento que se encuentra en la mitad del vector, si son iguales aquí se
acaba el proceso, sino es así; se determinará en cual de las dos mitades se
encuentra el elemento, descartando de una ves la búsqueda en la otra mitad.
En la mitad con que contaremos, haremos lo mismo que lo arriba mencionado,
dividiremos en dos el pedazo de vector, el proceso continúa hasta que se
presente un hallazgo o hasta que el programa pueda determinar que el elemento no
se encontró en el arreglo.
Código que busca un
valor en forma binaria.
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();
int a[21],i,j,tama,auxiliar,bandera,p,u,sw,mitad,valorbuscado,verificacion;
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)/*for para ingresar elementos al
vector.*/
{
cout<<"El elemento "<<i+1<<": ";
cin>>a[i];
}
/*Aquí empieza el ordenamiento, (método de la baraja).*/
for(j=1; j<tama; j++)
{
i=j;
auxiliar=a[j];
bandera=0;
while((i > 0)&&(bandera==0))
{
if(a[i-1] > auxiliar)
{
a[i]=a[i-1];
i--;
}
else
{
bandera=1;
}
}
a[i]=auxiliar;
}
/*Se muestra el vector ordenado.*/
clrscr();
cout<<"Este es el vector ordenado: "<<endl<<endl;
for(i=0;i<tama;i++)
cout<<"Elemento "<<i+1<<": "<<a[i]<<endl;
cout<<endl<<endl<<endl<<"Digite el valor a buscar---> ";
cin>>valorbuscado;
/*Aquí empieza la búsqueda binaria.*/
p=0;
u=tama-1;
sw=0;
while((p <= u) && (sw==0))
{
mitad=(p + u)/2;
if(a[mitad] == valorbuscado)
sw=1;
else
if(valorbuscado < a[mitad])
u=mitad-1;
else
p=mitad+1;
}
if(valorbuscado==a[mitad])
cout<<endl<<endl<<endl;
cout<<"El valor "<<valorbuscar<<" está en la posición "<<mitad+1<<".";
else
cout<<endl<<endl<<endl<<"El valor "<<valorbuscar<<" no está en el vector.";
/*Aquí termina el método binario.*/
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();
}/*Fin del main.*/
Programa, busca un
valor en forma binaria.
Ir a inicio de página.
INSERTAR:
Esta operación consiste en adicionar un nuevo elemento al vector. Hay que
tener presente que no se sobrepase el tamaño declarado del
vector.
INSERTAR EN VECTOR DESORDENADO:
Si el arreglo está de una forma ordenada la operación se tornará mas sencilla,
se aumenta en una unidad el número de elementos y en la posición n+1 se añadirá
el nuevo elemento. Esta operación puede hacerse en un vector ordenado o
desordenado.
Código, para insertar
elemento a vector desordenado.
#include<conio.h>/*Para
getch y clrscr.*/
#include<iostream.h>/*Para cout y cin.*/
void main()
{
clrscr();/*Borra pantalla.*/
int a[21],i,k,valorinsertar,tama;/*a[21]--->Declara vector
de enteros de
hasta 20 posiciones. i--->Indice que se desplazar de uno en uno para
llenar el vector. k--->Índice que se desplazar de uno en uno para mostrar
el vector después de la inserción. valorinsertar--->Almacenar el valor a
ser insertado. tama--->Almacenar el tamaño del vector.*/
cout<<"Ingresar el tama¤o del vector, no mayor a 20---> ";
cin>>tama;
cout<<endl<<endl;/*endl--->Cada endl deja un renglón.*/
for(i=0;i<tama;i++)/*for para llenar el vector.*/
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
cout<<endl<<endl<<"Qué elemento desea insertar?: ";
cin>>valorinsertar;
clrscr();/*Borra pantalla.*/
cout<<"Este es el vector después de haber ingresado el nuevo elemento:";
cout<<endl<<endl;
a[tama]=valorinsertar;/*Se asigna el nuevo elemento a la
posición tama+1, en
este caso solo es tama, pues el índice empieza en cero.*/
for(k=0;k<tama+1;k++)/*for para mostrar el vector después
de la inserción.*/
{
cout<<"Elemento "<<k+1<<": "<<a[k]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();/*Detiene la ejecución del programa.*/
}/*Fin main.*/
Programa, para
insertar elemento a vector desordenado.
Ir a inicio de página.
INSERTAR EN VECTOR ORDENADO:
Es necesario tener en cuenta---> Encontrar el lugar donde debe insertarse el
elemento nuevo para que el arreglo continúe ordenado, deben correrse todos
los elementos un lugar hacia la izquierda para abrirle espacio al nuevo
elemento, del lugar donde se debe ingresar el elemento en adelante y debe
ingresarse el nuevo elemento en el lugar correspondiente.
Código, se ingresa un
nuevo elemento a un vector ordenado.
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();
int a[21],i,tama,valorinsertar,j,menor,posicion,aux;
cout<<"Ingrese el tamaño del vector---> ";
cin>>tama;
cout<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"Elemento "<<i+1<<": ";
cin>>a[i];
}
/*Para aplicar el método de inserción a un vector
ordenado. Obviamente se debe ordenar el arreglo para después ingresar el nuevo
elemento. En este caso se utilizó el método de selección para ordenar el vector,
se pudo haber
trabajado con cualquiera de los otros métodos, ya sean burbuja, burbuja,
mejorado o baraja.*/
/*Aquí empieza el ordenamiento.*/
for(i=0; i<tama-1; i++)
{
menor=a[i];
posicion=i;
for(j=i+1; j<tama; j++)
{
if(menor > a[j])
{
menor=a[j];
posicion=j;
}
}
aux=a[i];
a[i]=menor;
a[posicion]=aux;
}
/*Aquí termina el ordenamiento.*/
cout<<endl<<endl<<"Digite el nuevo número a ingresar---> ";
cin>>valorinsertar;
/*Aquí comienza la inserción del nuevo número al arreglo
ordenado.*/
i=0;
if(tama<21)/*Esta verificación es para saber si al
vector le caben más números, de no ser así se mostrará un mensaje diciendo que
el vector está lleno.*/
{
while((i< tama) && (valorinsertar > a[i]))
i++;
tama++;
for(j=(tama-1); j > i; j--)
a[j]=a[j-1];
a[i]=valorinsertar;
}
else
{
clrscr();/*Borra la pantalla, la deja limpia.*/
cout<<"EL VECTOR ESTA LLENO";
cout<<endl<<endl<<endl<<"Presione una tecla para continuar...";
getch();/*Se detiene la ejecución del programa.*/
}
/*Aquí termina el proceso de inserción.*/
clrscr();
/*Las siguientes líneas mostrarán el vector después de la
o no inserción.*/
cout<<"Este es el vector después del intento de inserción:"<<endl<<endl;
for(i=0;i<tama;i++)
{
cout<<"Elemento "<<i+1<<": "<<a[i]<<endl;
}
cout<<endl<<endl<<endl<<"Presione una tecla para terminar...";
getch();/*Detiene la ejecución del programa.*/
}/*Fin del main.*/
Programa, se
ingresa un nuevo elemento a un vector ordenado.
Ir a inicio de página.
-----------------------------------------------------------
OTROS EJEMPLOS SOBRE VECTORES.
Código que lee un
vector, y muestra la suma y el promedio de los elementos que se encuentran en
las posiciones impares. Además se utiliza y se trata de explicar la
utilidad del operador "%". (módulo).
#include<conio.h>
#include<iostream.h>
void main()
{
clrscr();/*Borra pantalla.*/
int i,n,v[50],residuo,cont=0;/*i->Indice. n->Número de
elementos a ingresarle al vector. v[50]->Vector de hasta 50 elementos.
residuo->La variable residuo tendrá almacenado un uno o un cero según el número
de la
posición. cont=0->Se necesita un contador para sacar el promedio.*/
float promedio,suma=0;/*suma=0->Acumular la suma de los
elementos que se
encuentran en las posiciones impares del vector.*/
cout<<"Ingrese el número de elementos para el vector: ";
cin>>n;/*Lee el número de elementos a ingresar.*/
for(i=1;i<=n;i++)
{
cout<<"v [ "<<i<<" ] = ";
cin>>v[i];
residuo=i%2;/*En la variable según la posición (índice),
quedar almacenado un uno o un cero, si el número de la posición es por ejemplo
un dos o un seis, siendo estos pares entonces en "residuo" quedar un cero.
2%2=0, 6%2=0. Recuérdese que el "%" es para devolver el residuo, y no para
devolver un resultado.*/
if(residuo==1)
{
suma+=v[i];
cont++;
}
}
cout<<endl<<"La suma de los elementos ubicados en las posiciones ";/*El
"<<endl", es para saltar una línea, deja un renglón.*/
cout<<"impares es: "<<suma;
promedio=suma/cont;
cout<<endl<<"El promedio de los elementos ubicados en las posiciones ";
cout<<"impares es: "<<promedio;
getch();
}/*Fin main.*/
Código que lee un
vector, y muestra la suma y el promedio de los elementos que se encuentran en
las posiciones impares. Además se utiliza y se trata de explicar la
utilidad del operador "%". (módulo).
Ir a inicio de página.
---------------------------------------------------------
OTROS CÓDIGOS.
Código que calcula
el promedio, la varianza y la desviación típica de un grupo de número positivos,
dispuestos de a uno por registro. Se utiliza un esquema cualitativo, pues
no se sabe cuantos elementos se van a ingresar al vector. Tiene un ejemplo
de la formulita mágica---> ios::fixed ios::showpoint
setprecision(#). Se trabaja la función pow y sqrt.
Une dos vectores
ingresados, pero elimina los elementos del segundo que están en el primero.
Se lee un vector y
se determina en que posición está el número mayor.
Determina el número
mayor de un vector.
Se
ingresará un número y a partir de este saldrán sus 10 pares o impares
siguientes.
Se muestra el
cuadrado de los primeros 20 números.
Operaciones
con vectores (borrar, ingresar, mostrar, buscar, agregar, etc).
Programa
que genera 10 números de forma aleatoria entre 50 y 100, luego se guardan en un
vector de 10 posiciones. Por último los imprime.
Se
ingresan dos vectores. El programa muestra la unión, la intersección y la
adición de los dos vectores.
Se ingresa un vector,
se reemplaza un elemento (nro) el cual lo ingresa el usuario, luego se pregunta
por cual número se va a cambiar.
-----------------------------------------------------------
Si encuentras algún error en la
página web, te rogamos el favor nos lo hagas saber.
-----------------------------------------------------------
Empresa amiga-->
TECSICOM ®
|
