Suma de elementos de un vector

---

Suma.h

#pragma once

ref class Suma
{
public:
int suma(int[],int);
};

---

Suma.cpp


#include "StdAfx.h"
#include "Suma.h"

int Suma::suma(int V[],int n)
{
if (n==0)
return V[n];
else
return V[n]+suma(V,n-1);
}

---

Descargar toda la solución de Clases en C++ para abrir con Visual Studio 2010

Mayor elemento de un vector

---

Hallar.h

#pragma once

class Hallar
{
private:
int hallarMayorElemento(int[],int,int);
public:
int mayorElemento(int[],int);
};

---

Hallar.cpp


#include "StdAfx.h"
#include "Hallar.h"

int Hallar::mayorElemento(int V[],int n)
{
return hallarMayorElemento(V,n,V[0]);
}

int Hallar::hallarMayorElemento(int V[],int n,int mayor)
{
if(V[n]>mayor)
mayor=V[n];

if(n==0)
return mayor;
else
return hallarMayorElemento(V,n-1,mayor);
}

---

Descargar toda la solución de Clases en C++ para abrir con Visual Studio 2010

Maximo elemento de un vector

Halla el máximo elemento de un vector

---

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

int maximo(int *V,int n,int max)
{
if(V[n]>max)
max=V[n];

return(n==0)?max:maximo(n-1,max); //Sentencia que equivale a un if
}

void main()
{
int n,max;

cout<<"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];
}

cout<<endl<<"El maximo elemento es "<<maximo(V,n,-99999);//(Vector,Numero elementos, un número muy pequeño)

_getch();
}

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();
}

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();
}

Simetria, diagonal y transpuesta de una matriz

Comprueba si una matriz es simétrica y además halla las diagonales y la transpuesta

---

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

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;
}

bool esSimetrica(int **M,int n)
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(M[i][j]!=M[j][i])
return false;
return true;
}

int **transpuesta(int **M,int fil, int col)
{
int **N = crearMatriz(col,fil);

for (int i=0;i<fil;i++)
{
for(int j=0;j<col;j++)
{
N[j][i]=M[i][j];
}
}

return N;
}

void diagonales(int **M,int n)
{
cout<<endl<<endl<<"Diagonal principal:";

for (int i=0;i<n;i++)
{
cout<<endl;

for(int j=0;j<n;j++)
{
if(i==j)
cout<<M[i][j]<<"\t";
else
cout<<"\t";
}
}

cout<<endl<<endl<<"Diagonal sedundaria:";

for (int i=0;i<n;i++)
{
cout<<endl;

for(int j=0;j<n;j++)
{
if(i+j==n-1)
cout<<M[i][j]<<"\t";
else
cout<<"\t";
}
}
}

int **cambiarParesImpares(int **M,int fil,int col)
{
int **N = crearMatriz(fil,col);

for (int i=0;i<fil;i=i+2)
{
for(int j=0;j<col;j++)
{
N[i+1][j]=M[i][j];
N[i][j]=M[i+1][j];
}
}

return N;
}

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

for(int j=0;j<col;j++)
cout<<M[i][j]<<"\t";
}
}

void main()
{
int n;

cout<<"Ingrese orden de matriz (nxn): ";cin>>n;

int **M=crearMatriz(n,n);

for(int i=0;i<n;i++)
{
cout<<endl;

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

mostrarMatriz(M,n,n);

cout<<endl<<endl;

if(esSimetrica(M,n))
cout<<"Matriz SI es simetrica";
else
cout<<"Matriz NO es simetrica";

diagonales(M,n);

cout<<endl<<endl<<"Transpuesta: "<<endl;
mostrarMatriz(transpuesta(M,n,n),n,n);



cout<<endl<<endl<<"Matriz con filas pares e impares cambiadas: "<<endl;
if(n%2==0)
mostrarMatriz(cambiarParesImpares(M,n,n),n,n);
else
cout<<"No hay igual numero de filas pares e impares";

_getch();
}