Version:0.9
StartHTML:0000000105
EndHTML:0000028350
StartFragment:0000000152
EndFragment:0000028316
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/******************************************************/
/****************** Telematica ************************/
/******************************************************/
/************* Practica 6 Ejercicio 1 *****************/
/******************************************************/
/* Definicion de constantes y tipos */
const int MAX = 10;
typedef int Vector[MAX];
/* Prototipos de las funciones */
void InicializaV (Vector v, int reset);
void GrabarVector(Vector v);
int PosMaximoV(Vector v); // Devuelve la posicion donde se encuentra el valor maximo dentro del vector dado
int PosMinimoV(Vector v);
void InvertirV(Vector v);
void MostrarV(Vector v);
// void OrdenaAscendenteV(Vector v);
void GrabarOrdenado(Vector v1);
void CopiaVector (Vector vaux, Vector v);
void Desplaza (Vector v,int i, int fin);
#include <iostream.h>
#include <stdlib.h>
int main()
{
int opcion, reset, opcionv;
Vector v1, v2;
bool salir = false;
do
{
/* Menu del programa que se mostrara por pantalla */
cout << " ***************** M E N U *******************************"<< endl;
cout << " * 1.- Calculo del max y min de dos vectores *"<< endl;
cout << " * 2.- Invertir el orden de los vectores *"<< endl;
cout << " * 3.- Resetear el vector a un valor dado *"<< endl;
cout << " * 4.- Leer " << MAX << " numeros e insertarlos en orden ascendente *"<< endl;
cout << " * 5.- Salir del programa *"<< endl;
cout << " *********************************************************"<< endl;
cout << endl << " Elige una opcion -> " ;
cin >> opcion;
/* Inicializacion de los vectores para evitar problemas al valor 0 */
InicializaV(v1, 0);
InicializaV(v2, 0);
/* Introduccion de los datos de los vectores */
if (opcion == 1 || opcion == 2)
{
cout << endl << " Introduce " << MAX << " valores para el vector 1 -> ";
GrabarVector (v1);
cout << endl << " Introduce " << MAX << " valores para el vector 2 -> ";
GrabarVector (v2);
}
/* switch de opcion para ejecutar la parte de codigo segun la opcion del menu elegida */
switch (opcion)
{
case 1:
cout << " El valor maximo del vector 1 es " << v1[PosMaximoV(v1)] << " y el minimo es "<< v1[PosMinimoV(v1)] << endl << endl;// Salida por pantalla
cout << " El valor maximo del vector 2 es " << v2[PosMaximoV(v2)] << " y el minimo es "<< v2[PosMinimoV(v2)] << endl << endl;// Salida por pantalla
break;
case 2:
InvertirV(v1); // llamamos a la funcion que nos invertira el vector
InvertirV(v2);
cout << endl << " Vector 1 invertido -> ";
MostrarV(v1); // mostramos el vector por pantalla
cout << endl << endl;
cout << " Vector 2 invertido -> ";
MostrarV(v2);
cout << endl << endl;
break;
case 3:
cout << endl << " Introduce el valor al que quieres resetear el vector -> ";
cin >> reset ;
opcionv = 0; // Iniciamos esta variable que se usara para seleccionar uno de los dos vectores
do // inicio de bucle do..while para control de errores de entrada de datos
{
cout << endl << " Que vector quieres resetear ? (1/2) -> " ;// Eleccion del vector a resetear
cin >> opcionv;
if (opcionv != 1 && opcionv != 2) // La opcion solo puede ser 1 o 2, de lo contrario mostramos mensaje de error
cout << endl << " Error, la opcion debe ser 1 o 2 y has puesto "<< opcionv << endl;
}
while (opcionv !=1 && opcionv != 2 ); // Control de errores, pediremos introducir datos mientras no sea 1 o 2
if (opcionv == 1) // Si el vector elegido es el 1 iniciamos el vector al valor de reset
InicializaV(v1, reset);
else
InicializaV(v2, reset); // en caso contrario el vector es el 2 y lo iniciamos al valor de reset
cout << endl<< " Vector "<< opcionv << " inicializado con el valor " << reset << endl; // Mostramos mensaje de verificacion por pantalla
cout << endl << " El vector completo reseteado es -> " ;
if (opcionv == 1)
MostrarV(v1); // Mostramos por pantalla v1 para verificar que esta reseteado
else
MostrarV(v2); // Mostramos por pantalla v2 para verificar que esta reseteado
cout << endl << endl;
break;
case 4:
cout << " Introduce " << MAX << " valores que se insertaran en orden ascendente (positivos y > 0) -> ";
GrabarOrdenado(v1); // Grabamos en vector con los datos de entrada
// OrdenaAscendenteV(v1); // Llamamos a la funcion que nos ordena en orden ascendente el vector
cout << " El vector ordenado es " ;
MostrarV(v1);
cout << endl << endl;
break;
case 5:
salir = true;
break;
default:
cout << "\n Opcion no valida \n";
break;
}
if (opcion !=5)// Usamos esto para pausar la salida y poder verla y borrar despues pantalla y mostrar menu de nuevo
{
system("PAUSE");
system("cls");
}
}
while (!salir);
cout << endl << " Fin del Programa -> Isidro Pastor Jorda 2002 <- " << endl << endl;
system("PAUSE");
return 0;
}
/******************************************************************
* Funcion: GrabarVector
* Descripcion: Funcion que graba los datos introducidos en el vector
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E/S Vector de entrada para modificarlo
*
*
* Valor devuelto:
* La funcion solo devuelve el vector modificado. void
*******************************************************************/
void GrabarVector(Vector v)
{
for (int i=0; i < MAX; i++)
cin >> v[i];
return;
}
/******************************************************************
* Funcion: InicializaV
* Descripcion: Funcion que inicializa el vector a un valor dado
* Introducimos el valor de reset en todas las posiciones del vector
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E/S
* reset E Valor al que inicializaremos el vector
*
* Valor devuelto:
* Funcion void, no devuelve ningun valor
*******************************************************************/
void InicializaV (Vector v, int reset)
{
for (int i=0; i<MAX; i++)
v[i] = reset;
return;
}
/******************************************************************
* Funcion: PosMaximoV
* Descripcion: Funcion que nos devuelve la posicion donde se encuentra
* el valor maximo almacenado en un vector.
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E Vector a recorrer para encontrar el maximo
*
*
* Valor devuelto:
* La funcion devuelve un entero que es la posicion donde se encuentra
* almacenada en el vector el dato de mayor valor
*******************************************************************/
int PosMaximoV(Vector v)
{
int pos; // variable auxiliar para almacenar la posicion del dato mas alto
pos = 0;
for (int i=1; i<MAX; i++)
{
if (v[pos] < v[i]) // Comparamos el vector numero a numero, si es mas grande que nuestro maximo almacenamos su posicion
pos = i;
}
return pos;
}
/******************************************************************
* Funcion: PosMinimoV
* Descripcion: Funcion que nos devuelve la posicion donde se encuentra
* el valor minimo almacenado en un vector.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E Vector a recorrer para encontrar el minimo
*
*
* Valor devuelto:
* La funcion devuelve un entero que es la posicion donde se encuentra
* almacenada en el vector el dato de menor valor
*******************************************************************/
int PosMinimoV(Vector v) // Similar a la funcion PosMaximoV
{
int pos; // variable auxiliar para almacenar la posicion del dato mas pequenyo
pos = 0;
for (int i=1; i<MAX; i++)
{
if (v[pos] > v[i])
pos = i;
}
return pos;
}
/******************************************************************
* Funcion: InvertirV
* Descripcion: Funcion que invierte el orden de los contenidos almacenados
* en un vector.
*
*
* Parametros:
* Nombre E/S Descripcion
* ------ ----- -----------
* v E/S Vector que sera modificado para obtener el vector invertido
*
*
* Valor devuelto:
* La funcion es de tipo void, no devuelve nada pero se modifica
* el contenido del vector v dentro de la funcion
*
*******************************************************************/
void InvertirV(Vector v)
{
int i, j, aux; // declaramos dos indices y una variable auxiliar para almacenar datos intermedios
i = 0; // Contador inferior
j = MAX - 1; // Contador superior
while ( i < j ) // repetimos hasta que el indice inferior sea mayor que el indice superior
{
aux = v[i]; // guardamos en nuestra variable auxiliar el valor almacenado en v[i]
v[i] = v[j]; // guardamos en v[i] el valor de v[j] que estara por el final del vector
v[j] = aux; // guardamos en v[j] el valor que tenia antes v[i] y habremos intercambiado los valores
i++; // aumentamos el indice inferior
j--; // decrementamos el indice superor
}
}
/***********************************************************************************
* Funcion: MostrarV
* Descripcion: Funcion que unicamente muestra por pantalla el contenido
* de nuestro vector.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E Vector a mostrar por pantalla, no se modifica en la funcion
*
*
* Valor devuelto:
* La funcion solo muestra por pantalla, es void y no se modifica nada
***********************************************************************************/
void MostrarV(Vector v)
{
for (int i = 0; i < MAX; i++)
cout << " " << v[i];
return;
}
/***********************************************************************************
* Funcion: OrdenaAscendenteV
* Descripcion: Funcion que ordena de manera ascendente los datos almacenados
* en el vector de entrada
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* v E vector que se piensa ordenar
*
*
* Valor devuelto:
* void, la funcion no devuelve el valor pero modifica el vector.
***********************************************************************************/
/* void OrdenaAscendenteV(Vector v) eliminamos esta funcion que ordena el vector ya introducido
{
Vector vaux; // Vector auxiliar para ir ordenandolo ahi
int pmax; // variable para ir almacenando la posicion donse se encuentra el maximo del vector
/* Vamos a recorrer el vector en orden inverso, buscaremos maximos
dentro de ese vector y los iremos guardando en el vector auxiliar
empezando desde la posicion mas alta del vector.
El hecho de hacerlo mientras i > MAX - (MAX + 1) es simplemente
indicar que el bucle se repite mientras que i sea mayor que -1
for (int i = MAX -1;i > MAX - (MAX + 1); i-- )
{
pmax = PosMaximoV(v);// llamamos a PosMaximoV y nos dara la posicion donde esta el maximo del vector
vaux[i] = v[pmax] ; // Copiamos en vaux el valor del maximo numero del vector dado
v[pmax] = 0; // Sobreescribimos este valor para eliminarlo del vector y volver a llamar a la funcion
}
/* Llamamos a una funcion que nos copia el contenido de un vector en otro
en nuestro caso queremo copiar el contenido de vaux en v
CopiaVector(vaux, v);
return;
} */
/***********************************************************************************
* Funcion: CopiaVector
* Descripcion: Funcion que copia el contenido del vector vaux en el vector v
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* vaux E Vector del que queremos hacer una copia
* v E/S Vector al cual copiaremos el contenido de vaux
*
* Valor devuelto:
* Funcion void que no devuelve nada, copia el contenido de vaux en v
***********************************************************************************/
void CopiaVector (Vector vaux, Vector v)
{
for (int i = 0; i < MAX; i++)
v[i] = vaux[i];
return;
}
/***********************************************************************************
* Funcion: GrabarOrdenado
* Descripcion: Funcion que graba los valores introducidos de forma ordenada directamente en el vector
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
* v E/S Vector en el que iremos introduciendo los datos
*
* Valor devuelto:
* Funcion void que no devuelve nada, va introduciendo valores en el vector y ordenandolos
***********************************************************************************/
void GrabarOrdenado(Vector v)// esta funcion ira grabando ordenadamente el vector conforme se introduzca
{
int aux, insertar;
cin >> v[0]; // leemos el primer caracter introducido
for (int i=1; i < MAX ; i++)
{
cin >> aux; // leeremos el siguiente
insertar = i; // el punto a insertar ahora sera el valor inicial de insercion
if ( aux < v[insertar-1] ) // Comparamos si el valor anterior es menor al introducido
{
while ( aux < v[insertar-1] && insertar >= 0 ) // mientras que el anterior sea menos e insertar mayor que cero
{
insertar--; // iremos reduciendo en uno la posicion donde insertaremos nuestro valor
}
Desplaza(v, insertar, i ) ; // una vez sepamos donde insertar el valor desplazaremos los valores del vector
v[insertar] = aux; // y a continuacion insertaremos el valor leido
}
else
v[i] = aux;
}
return;
}
/***********************************************************************************
* Funcion: Desplaza
* Descripcion: Funcion que graba los valores introducidos de forma ordenada directamente en el vector
*
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* insertar E Punto de nuestro vector hasta donde tenemos que desplazar
* v E/S Vector donde haremos los desplazamientos
* fin E Posicion que ocupa el ultimo elemento introducido hasta el momento
*
* Valor devuelto:
* Funcion void que no devuelve nada, desplaza los valores del vector un lugar desde insertar hasta el final
****************************************************************************************************************/
void Desplaza (Vector v,int insertar, int fin)
{
for (fin; fin > insertar; fin--) // repetiremos el desplazamiento mientras que fin sea mayor que la posicion donde vamos a insertar
v[fin] = v[fin-1]; // copiamos el valor de la casilla anterior en la casilla actual
}