Punteros a matrices

Ejemplo de punteros a matrices

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int tamaño()
{
int aux;

do{
cin>>aux;
}while(aux<=0 || aux>10);

return aux;
}

int ** crearMatriz(int fil, int col)
{
    int **M=NULL;
    int i, j;
    int mem=1;        /* flag para indicar que hay memoria para todas las filas */

M=(int **)calloc(fil, sizeof(int *));


    /* se reserva memoria para la tabla de punteros intermedia */
    if (M!=NULL)
{
        for (i=0; i<fil && mem; i++)
{
            if ((M[i]=(int *) calloc(col, sizeof(int)))==NULL)
{
                mem=0;
            }
        }

        if (!mem) {
            for(j=0; j<i-1; j++){
                free (M[j]);
            }

            free (M);
            M=NULL;     /* si no hay memoria se devuelve NULL */
        }
    }
    return M;
}

void llenarMatriz(int **p,int fil,int col)
{
for(int i=0;i<fil;i++)
{
cout<<endl;

for(int j=0;j<col;j++)
{
cout<<"V["<<i+1<<"]["<<j+1<<"] = ";
cin>>(*p)[j];
}
p++;
}
}

void mostrarMatriz(int **p,int fil,int col)
{
for(int i=0;i<fil;i++)
{
cout<<endl;

for(int j=0;j<col;j++)
cout<<(*p)[j]<<"   ";
p++;//Tambien podemos aumentar el valor de *p en otra línea de código
}
}

int mayorValor(int **p,int fil,int col)
{
int max=-99999;

for(int i=0;i<fil;i++)
{
for(int j=0;j<col;j++)
if((*p)[j]>max)
max=(*p)[j];
p++;
}

return max;
}

int menorValor(int **p,int fil,int col)
{
int min=99999;

for(int i=0;i<fil;i++)
{
for(int j=0;j<col;j++)
if((*p)[j]<min)
min=(*p)[j];
p++;
}

return min;
}

double promedio(int **p,int fil,int col)
{
double suma=0;

for(int i=0;i<fil;i++)
{
for(int j=0;j<col;j++)
{
suma+=(*p)[j];
}
p++;
}

return suma/(fil*col);
}

void ordenar(int **p,int fil,int col)
{
int aux;

for(int i=0;i<fil;i++)
{
for(int j=0;j<col-1;j++)
{
for(int k=j+1;k<col;k++)
{
if((*p)[j]>(*p)[k])
{
aux=(*p)[j];
(*p)[j]=(*p)[k];
(*p)[k]=aux;
}
}
}
p++;
}
}

void main()
{

int fil,col;

cout<<"Nro de filas: ";
fil=tamaño();

cout<<"Nro de Columnas: ";
col=tamaño();

int **M = crearMatriz(fil,col);

llenarMatriz(M,fil,col);

cout<<endl<<"Esta es su matriz: "<<endl;

mostrarMatriz(M,fil,col);

cout<<endl<<endl<<"Mayor Valor es "<<mayorValor(M,fil,col)<<endl;
cout<<"Menor Valor es "<<menorValor(M,fil,col)<<endl;
cout<<"Promedio es "<<promedio(M,fil,col)<<endl;

ordenar(M,fil,col);
cout<<endl<<"Matriz Ordenada:"<<endl;
mostrarMatriz(M,fil,col);

_getch();
}

Punteros a vectores

Ejemplo de punteros a vectores

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

void tamaño(int *n)
{
cout<<"Numero de elementos: ";cin>>*n;
}

void llenarVector(int *p,int n)//*p sería es la posición de memoria del vector y corresponde al primer elemento
{
for(int i=0;i<n;i++)
{
cout<<"V["<<i+1<<"] = ";
cin>>*(p+i);//Para desplazarnos a los siguientes elementos del vector basta hacer *(p+i) donde i aumenta de 0 a n
}
}

void mostrarVector(int *p,int n)
{
for(int i=0;i<n;i++)
cout<<endl<<"V["<<i+1<<"] = "<<*(p+i);
}

int mayorValor(int *p,int n)
{
int max=-99999;//Un valor muy bajo

for(int i=0;i<n;i++)
{
if(*(p+i)>max)
max=*(p+i);
}

return max;
}

int menorValor(int *p,int n)
{
int min=99999;//un valor muy alto

for(int i=0;i<n;i++)
{
if(*(p+i)<min)
min=*(p+i);
}

return min;
}

double promedio(int *p,int n)
{
double suma=0;

for(int i=0;i<n;i++)
{
suma+=*(p+i);
}

return suma/n;
}

void ordenar(int *p,int n)
{
int aux;

for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(*(p+i)>*(p+j))
{
aux=*(p+i);
*(p+i)=*(p+j);
*(p+j)=aux;
}
}
}
}

void main()
{
int n;

tamaño(&n); //Le enviamos la posición de memoria de la variable n

int *V = new int [n];

cout<<endl;

llenarVector(V,n);

cout<<endl<<"Mayor Valor es "<<mayorValor(V,n)<<endl;
cout<<"Menor Valor es "<<menorValor(V,n)<<endl;
cout<<"Promedio es "<<promedio(V,n)<<endl;
cout<<"Vector ordenado:"<<endl;
ordenar(V,n);
mostrarVector(V,n);

_getch();
}

Bubble Sort recursivo

Versión recursiva del método de Bubble Sort

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int n;

void intercambio(int vector[],int i,int j)
{
int temp;
temp=vector[i];
vector[i]=vector[j];
vector[j]=temp;
}


void bubbleSortRecursivo(int vector[],int index1,int index2)
{
if(index1<n-1)
{
if(index2<n)
{
if(vector[index1]>vector[index2])
intercambio(vector,index1,index2);

bubbleSortRecursivo(vector,index1,index2+1);
}
else
bubbleSortRecursivo(vector,index1+1,index1+2);
}
}

void mostrarVector(int vector[])
{
for(int i=0;i<n;i++)
cout<<"V["<<i+1<<"] = "<<vector[i]<<endl;
}

void main()
{
cout<<"Ingrese numero de elementos: ";cin>>n;

int *V = new int [n];

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"V["<<i+1<<"] = ";
cin>>V[i];
}

bubbleSortRecursivo(V,0,1);

cout<<endl<<"Vector ordenado: "<<endl<<endl;

mostrarVector(V);

_getch();
}

Combinar vectores ordenados

Combina 2 vectores ordenados de tal manera que la combinación también quede ordenada

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int n;

void leerVector(int vector[])
{
for(int i=0;i<n;i++)
{
cout<<"["<<i+1<<"] = ";
cin>>vector[i];
}
}

void intercambiar(int vector[],int i,int j)
{
int temp;
temp=vector[i];
vector[i]=vector[j];
vector[j]=temp;
}

void ordenarVector(int vector[])
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(vector[i]>vector[j])
intercambiar(vector,i,j);
}
}
}

void mostrarVector(int vector[])
{
for(int i=0;i<n*2;i++)
cout<<endl<<"["<<i+1<<"] = "<<vector[i];
}

void combinarVector(int vector1[],int vector2[],int vector3[])
{
int index1=0,index2=0;

for(int i=0;i<n*2;i++)
{
if(index1==n)//¿Ya se compararon todos los elementos del vector 1?
{
vector3[i]=vector2[index2];
index2++;
}
else
{
if(index2==n)//¿Ya se compararon todos los elementos del vector 2?
{
vector3[i]=vector1[index1];
index1++;
}
else
{
if(vector1[index1]<=vector2[index2])
{
vector3[i]=vector1[index1];
index1++;
}
else
{
vector3[i]=vector2[index2];
index2++;
}
}
}
}
}

void main()
{
int *V1,*V2,*V3;

cout<<"Elementos de AMBOS arreglos: ";cin>>n;

V1 = new int [n];
V2 = new int [n];

V3 = new int [n*2];//Este vector será la combinación de los elementos de los otros dos vectores!

cout<<endl<<"1er arreglo: "<<endl<<endl;

leerVector(V1);

cout<<endl<<"2do arreglo: "<<endl<<endl;

leerVector(V2);

ordenarVector(V1);
ordenarVector(V2);

combinarVector(V1,V2,V3);

cout<<endl<<endl<<"Combinacion de los arreglos: "<<endl<<endl;

mostrarVector(V3);

_getch();
}

Comparacion de rapidez de algunos algoritmos de ordenamiento

Compara el tiempo que demoran algunos algoritmos en ordenar un vector de 10000 elementos

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"
#include "stdlib.h" //Numeros random
#include "time.h" //Relojes

using namespace std;

const int n=10000;

void generarVector(int vector[])
{
int element = n;

for(int i=0;i<n;i++)
vector[i]=element--;//Asigna el valor de element avector[i] y al terminar esa linea el -- le resta 1 a element
}

void intercambio(int vector[],int i,int j)
{
int t=0;
t=vector[i];
vector[i]=vector[j];
vector[j]=t;
}

void bubbleSort(int vector[])
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(vector[i]>vector[j])
intercambio(vector,i,j);
}
}
}



void seleccionSort(int vector[])
{
int min;

for(int i=0;i<n-1;i++)
{
min=i;

for(int j=i+1;j<n;j++)
{
if(vector[min]>vector[j])
min=j;
intercambio(vector,i,j);
}
}
}

void quickSort(int vector[],int izq, int der )
{
int i,j,x;

i=izq;
j=der;

x=vector[(izq+der)/2];

do{
while((vector[i]<x)&&(j<=der))
{
i++;
}

while((x<vector[j])&&(j>izq))
{
j--;
}
if(i<=j)
{
intercambio(vector,i,j);
i++;
j--;
}
}
while(i<=j);

if(izq<j)
quickSort(vector,izq,j);
if(i<der)
quickSort(vector,i,der);
}

/* Al ordenar vectores pequeños con diferentes métodos de ordenamiento, la diferencia no se nota.
Pero no ocurre lo mismo cuando son gigantes vectores...
Veamos a continuación cuanto tardan con un vector de 10000 elementos
PD: El tiempo de ejecución empieza a correr desde que se ejecutó el programa
*/
void main()
{
clock_t t1,t2;

int V[n];

cout<<"Para cada algoritmo se genero un arreglo de 10000 elementos de mayor a menor"<<endl;
cout<<"estos son los tiempos que los diversos algoritmos de ordenamiento se tardaron en ordenarlo de menor a mayor:"<<endl;
cout<<"ESPERE POR FAVOR..."<<endl<<endl;

//Bubble Sort

generarVector(V);//Generamos vector

t1=clock(); //Capturamos el tiempo de la ejecución

bubbleSort(V);

t2=clock(); //Capturamos el tiempo de la ejecución

cout<<"Bubble Sort: "<<t2-t1<<" Ciclos"<<endl<<endl;//La diferencia entre las capturas hechas es lo que demoró el algoritmo


//Selection Sort

generarVector(V);

t1=clock();

seleccionSort(V);

t2=clock();

cout<<"Seleccion Sort: "<<t2-t1<<" Ciclos"<<endl<<endl;

//Quick Sort

generarVector(V);

t1=clock();

quickSort(V,0,n-1);

t2=clock();

cout<<"Quick Sort: "<<t2-t1<<" Ciclos"<<endl<<endl;

_getch();
}

Frecuencia de un elemento de un vector

Calcula la frecuencia absoluta y relativa de un elemento en un vector

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int n;

void intercambio(int vector[],int i,int j)
{
int temp;

temp=vector[i];
vector[i]=vector[j];
vector[j]=temp;
}

void ordenarVector(int vector[])
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(vector[i]>vector[j])
intercambio(vector,i,j);
}
}
}


void main()
{
double frecAbs[20],frecRel[20];

cout<<"Ingrese el numero de elementos:\t";cin>>n;

int *V = new int [n];

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"V["<<i+1<<"] = ";cin>>V[i];
}

ordenarVector(V);

cout<<endl<<"Frecuencias:"<<endl<<endl;
cout<<"Valor:\tAbs:\tRel:"<<endl;

double contador=1;

for(int i=0;i<n;i++)
{
if(V[i]==V[i+1])
contador++;
else
{
cout<<V[i]<<"\t"<<contador<<"\t"<<contador/n<<endl;
contador = 1;
}
}

_getch();
}

Insertar elemento en vector ordenado

Inserta un elemento en un vector ordenado sin alterar el orden

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int *V;
int n;

void intercambiar(int i,int j)
{
int temp;

temp=V[i];
V[i]=V[j];
V[j]=temp;
}

void ordenarV()
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(V[i]>V[j])
intercambiar(i,j);
}
}
}

void mostrarV()
{
for(int i=0;i<n;i++)
cout<<endl<<"V["<<i+1<<"] = "<<V[i];
}

void insertarV(int newElement)
{
bool agregado=false;

int index=n-1;

while(agregado==false)
{

if(newElement>=V[index])
{
V[index+1]=newElement;
agregado=true;
}
else
{
V[index+1]=V[index];
index--;
}
}

n++;
}

void main()
{

int newElement;

cout<<"Numero de elementos: ";cin>>n;

V = new int [n];

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"V["<<i+1<<"] = ";
cin>>V[i];
}

ordenarV();

cout<<endl<<"Su arreglo ya ordenado:"<<endl;

mostrarV();

cout<<endl<<endl<<"Escriba elemento que desee insertar en el arreglo: ";cin>>newElement;

insertarV(newElement);

cout<<endl<<"Arreglo actualizado:"<<endl;

mostrarV();

_getch();
}

Mediana de un arreglo

La mediana es el valor de la variable que deja el mismo número de datos antes y después que él, una vez ordenados estos.

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int *V,n;

void main()
{
cout<<"Ingrese numero de elementos: ";cin>>n;

V = new int [n];

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"Nro "<<i+1<<" = ";
cin>>V[i];
}

int temp;

for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(V[i]>V[j])
{
temp=V[i];
V[i]=V[j];
V[j]=temp;
}
}
}

cout<<endl<<"Elementos quedan asi: "<<endl<<endl;

for(int i=0;i<n;i++)
cout<<V[i]<<endl;

if(n%2==1)
cout<<endl<<endl<<"Mediana es "<<V[(n-1)/2];
else
cout<<endl<<endl<<"Medianas son "<<V[(n-1)/2]<<" y "<<V[(n-1)/2+1];

_getch();
}

Moda de un arreglo

En estadística, la moda es el valor con una mayor frecuencia en una distribución de datos.

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int n;

struct structFrec
{
int element;
int frecuencia;
};

void ordenarvector(int *V)
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(V[i]>V[j])
{
int temp = V[i];
V[i] = V[j];
V[j] = temp;
}
}
}
}

//Ordenar una estructura
void ordenarStruct(structFrec *S)
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(S[i].frecuencia<S[j].frecuencia)
{
structFrec aux = S[i];
S[i] = S[j];
S[j] = aux;
}
}
}

}

void main()
{
cout<<"Ingrese el numero de elementos: ";cin>>n;

int *V = new int [n];
structFrec *frecuencias = new structFrec[n];

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"Nro "<<i+1<<" = ";
cin>>V[i];
}

ordenarvector(V);

int iFrec = 0;//Indice que recorrerá la estructura de frecuencias

double contador=1;

for(int i=0;i<n;i++)
{
if(V[i]==V[i+1])
contador++;
else
{
frecuencias[iFrec].element=V[i];
frecuencias[iFrec].frecuencia=contador;
iFrec++;
contador = 1;
}
}

//Ordenamos las frecuencias de MAYOR a MENOR
ordenarStruct(frecuencias);

//El primer elemento será el de mayor frecuencia
int maxFrec = frecuencias[0].frecuencia;

//Los que tengan esa frecuencia son las modas (incluyendo al primer elemento)
cout<<endl<<"MODA(S):"<<endl<<endl;

for(int i=0;i<iFrec;i++)
if(frecuencias[i].frecuencia==maxFrec)
cout<<"Nro: "<<frecuencias[i].element<<" ("<<frecuencias[i].frecuencia<<") veces"<<endl;

_getch();
}

Numero igual a la suma de dos elementos

Al ingresar un número cualquiera este algoritmo busca todos los pares de elementos en el arreglo que sumados den el número ingresado.

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"

using namespace std;

int *V;
int n;

void intercambio(int i,int j)
{
int temp;
temp=V[i];
V[i]=V[j];
V[j]=temp;
}

void ordenarV()
{
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(V[i]>V[j])
intercambio(i,j);
}
}
}

void mostrarV()
{
for(int i=0;i<n;i++)
cout<<"V["<<i+1<<"] = "<<V[i]<<endl;
}

void main()
{
cout<<"Numero de elementos: ";cin>>n;

cout<<endl;

V = new int [n];

for(int i=0;i<n;i++)
{
cout<<"V["<<i+1<<"] = ";
cin>>V[i];
}

ordenarV();

cout<<endl<<"V ordenado: "<<endl<<endl;

mostrarV();

int number;
cout<<endl<<"Numero igual a la suma de dos elementos cualquiera: ";cin>>number;

cout<<endl;

bool coincidencias=false;

for(int i=0;number>=V[i] && i<n-1;i++)//Si el elemento actual "V[i]" es mayor que "number" ya no es necesario analizarlo
{
for(int j=i+1;number>=V[j] && j<n;j++)//Si el elemento actual "V[j]" es mayor que "number" ya no es necesario analizarlo
{
if(V[i]+V[j]==number)
{
cout<<V[i]<<" + "<<V[j]<<" = "<<number<<endl;
coincidencias=true;
}
}
}

if(coincidencias==false)
cout<<"No hubieron coincidencias";

_getch();
}

Ordenar baraja

Genera una baraja aleatoriamente y la ordena

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"
#include "string"
#include "stdlib.h" //Para usar la función Random!

using namespace std;

const int fil = 4;
const int col = 13;

int baraja[fil][col];

//Se generará aleatoriamente la baraja!
void generarBaraja()
{
for(int i=0;i<fil;i++)
{
for(int j=0;j<col;j++)
{
bool OK = false;

while(OK == false)
{
baraja[i][j] = 1 + rand() % 13;

bool repetido = false;

for(int k=j-1;k>=0;k--)
{
if(baraja[i][j]==baraja[i][k])//Verifica si la actual carta generada ya existe!
{
repetido = true;
}
}

if(repetido == false)
OK = true;
}
}
}
}

void mostrarBaraja(string palo[])
{
for(int i=0;i<fil;i++)
{
cout<<endl<<palo[i]<<endl;

for(int j=0;j<col;j++)
{
cout<<baraja[i][j]<<"  ";
}
}
}

//Metodo bubble sort
void ordenarBaraja()
{
int temp;

for(int i=0;i<fil;i++)//Para cada palo
{
for(int j=0;j<col-1;j++)
{
for(int k=j+1;k<col;k++)
{
if(baraja[i][j]>baraja[i][k])
{
temp=baraja[i][j];
baraja[i][j]=baraja[i][k];
baraja[i][k]=temp;
}
}
}
}
}

void main()
{
string palo[] = {"Espadas","Treboles","Corazones","Cocos"};

generarBaraja();

cout<<"Baraja Generada:"<<endl;

mostrarBaraja(palo);

cout<<endl<<endl<<"Presione una tecla para ordenar su baraja..."<<endl;

_getch();

ordenarBaraja();

cout<<endl<<"Baraja Ordenada:"<<endl;

mostrarBaraja(palo);

_getch();
}

Ordenar por nombre o promedio

Ordena una estructura de 2 diferentes maneras según el tipo de elementos que la componen.

---

#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;

struct datos
{
int carnet;
string name;
double promedio;
}*alumno;

void intercambio(int i, int j)
{
datos aux=alumno[i];
alumno[i]=alumno[j];
alumno[j]=aux;
}

void main()
{
int n,modo;

cout<<"Ingrese numero de alumnos: ";cin>>n;

alumno = new datos [n];

for(int i=0;i<n;i++)
{
cout<<endl<<"Nro de carnet:\t";cin>>alumno[i].carnet;
cout<<"Nombre: ";cin>>alumno[i].name;
cout<<"Promedio: ";cin>>alumno[i].promedio;
}

int repeat;


do{
do{
cout<<endl<<endl<<"MODO DE ORDENAMIENTO: (0) Alfabetico; (1) Promedios ";cin>>modo;
}while(modo<0 || modo>1);

for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(modo)
{
if(alumno[i].promedio<alumno[j].promedio)
intercambio(i,j);
}
else
{
if(alumno[i].name>alumno[j].name)
intercambio(i,j);
}
}
}

cout<<endl<<"Carnet\tNombre\tPromedio"<<endl;

for(int i=0;i<n;i++)
cout<<alumno[i].carnet<<"\t"<<alumno[i].name<<"\t"<<alumno[i].promedio<<endl;

do{
cout<<endl<<"Ordenar de nuevo (1 SI, 0 NO)";cin>>repeat;
}while(repeat<0 || repeat>1);

}while(repeat);
}

Ordenar cadenas

Ordena un arreglo de cadenas de caracteres

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"
#include "cstring"
using namespace std;

void main()
{
char cad[20][100];//20 cadenas de 100 caracteres cada una!

int n;

cout<<"ORDENAMIENTO DE CADENAS"<<endl<<endl;

do{
cout<<"Cantidad de cadenas (hasta 20): ";cin>>n;
}while(n<=0 || n>20);

cout<<endl;

for(int i=0;i<n;i++)
{
cout<<"Cad "<<i+1<<": ";cin>>cad[i];
}

//Método de la Burbuja
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
//Comparar caracter por caracter para determinar qué cadena es mayor
if(strcmp(cad[i],cad[j])>0)//Si la condicion se cumple retorna 1, sino 0
{
//Esta funcion copia una cadena en otra
char cadTemp[100];
strcpy_s(cadTemp,cad[i]);
strcpy_s(cad[i],cad[j]);
strcpy_s(cad[j],cadTemp);
}
}
}

cout<<endl<<"Listado ordenado alfabeticamente:"<<endl<<endl;

for(int i=0;i<n;i++)
cout<<"Cad["<<i+1<<"] : "<<cad[i]<<endl;

_getch();
}

Ordenar cadenas (string's)

Ordena un arreglo de cadenas tipo string

---

#include "stdafx.h"
#include "iostream"
#include "conio.h"
#include "string"
using namespace std;

void main()
{
int n;

cout<<"Cantidad de nombres: ";cin>>n;

string *cad = new string [n];

cout<<endl;

//Ingresamos las cadenas
for(int i=0;i<n;i++)
{
cout<<"Cad["<<i+1<<"]: ";
cin>>cad[i];
}

//Ordenamos el vector

string temp;

for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(cad[i]>cad[j])
{
temp=cad[i];
cad[i]=cad[j];
cad[j]=temp;
}
}
}

//Mostramos el vector ordenado

cout<<endl<<"Vector ordenado"<<endl<<endl;

for(int i=0;i<n;i++)
cout<<"Nombre "<<i+1<<": "<<cad[i]<<endl;

_getch();
}