Matriz con punteros.

#include<stdlib.h>
#include<stdio.h>
int main(void)

{
int M1[3][3];
int M2[3][3];
int MT[3][3];
int *Ptr;
int i,j,k;
//En esta parte se meten los valores de la
primera matriz
printf("la matriz 1:\n");
Ptr=&M1[0][0];

for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
printf("\n M1[%i][%i]=",i,j);
scanf("%i",Ptr+i*3+j);
}
}

printf("\n");
//En esta parte se meten los valores de la
segunda matriz
printf("la matriz 2:\n");
Ptr=&M2[0][0];

for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
printf("\n M2[%i][%i]=",i,j);
scanf("%i",Ptr+i*3+j);
}
}
//Aqui se van a mostrar las dos matrices
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf("M1[%i][%i]= %i\t",i,j,M1[i][j]);
}
}
printf("\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf("M2[%i][%i]= %i\t",i,j,M2[i][j]);
}
}
printf("\n\n");

//Esta parte es la multiplicacion

Ptr=&MT[0][0];

for(i=0; i<3 ; i++)
for(j=0; j<3 ; j++)
{
MT[i][j]=0;

for(k=0; k<3; k++)
MT[i][j]=MT[i][j]+M1[i][k]*M2[k][j];
}
printf("\n La matriz resultante es:\n");
for(i=0; i<3; i++)
{
printf("\n");
for(j=0; j<3; j++)
printf("MT[%i][%i]=%i\t",i,j,MT[i][j]);
}

printf("\n\n\n");
system ("\npause");
return 0;
}




























Vector Captura

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <conio.h>

typedef struct{float *datos;
unsigned int vec;
}VECTOR;

void CapturaVector(VECTOR *V);
void MuestraVector(VECTOR *V);
float Promedio(VECTOR *V);
float Desviacion(float P, VECTOR *V);
void Mediana(VECTOR *V);
void Moda(VECTOR *V);
void Frecuencia(VECTOR *V);

int main()
{
unsigned int j;
VECTOR V;
float P,D;
printf("Numero de elementos del VECTOR: ");
scanf("%i",&V.vec);
V.datos=new float[V.vec];
CapturaVector(&V);
MuestraVector(&V);
P=Promedio(&V);
D=Desviacion(P, &V);
printf("\n\n La Varianza es= %g",D*D);
Mediana(&V);
Moda(&V);
Frecuencia(&V);


printf("\n\n");
system("pause");
return 0;
}

void CapturaVector(VECTOR *V)
{
unsigned int j;
for(j=0; j<V->vec; j++)
{
printf("\n V[%i]=",j);
scanf("%f",&V->datos[j]);
}
}

void MuestraVector(VECTOR *V)
{
unsigned char j;
printf("\n El resultado del vector es: \n\n");
for(j=0; j<V->vec; j++)
printf(" %g ",V->datos[j]);

}

float Promedio(VECTOR *V)
{
unsigned char j;
float S,P;
for(j=0; j<V->vec; j++)
S+=V->datos[j];
P=S/(V->vec);
printf("\n\n El resultado promedio es= %g",P);
return P;
}

float Desviacion(float P, VECTOR *V)
{
unsigned char j;
float S,D;
for(j=0; j<V->vec; j++)
S+=((V->datos[j]-P)*(V->datos[j]-P));
D=sqrt(S/V->vec);
printf("\n\n El resultado de la desviacion estandard es=
%g ",D);
return D;
}

void Mediana(VECTOR *V)
{
unsigned char j,y;
float m,me;


for(int j=0; j<V->vec; j++)
{
for(int y=0; y<V->vec; y++)
{
if(V->datos[j]>V->datos[y])
{
m=V->datos[j];
V->datos[j]=V->datos[y];
V->datos[y]=m;
}

}
}

printf("\n\n El vector descendentemente es;\n");
for(int j=0; j<V->vec; j++)
{
printf(" %g ",V->datos[j]);
}
printf("\n\n");
for(int j=0; j<=(V->vec)/2; j++)
{
me=V->datos[j];
}
printf("El resultado de la media es: %g",me);
}

void Moda(VECTOR *V)
{

}

void Frecuencia(VECTOR *V)
{

}













Hecho en clase matrices falta
moda

#include<stdio.h>

typedef struct{ int *dat;
unsigned int n;
}VECTOR;

void MuestraVector(VECTOR *ptr);
float Media(VECTOR *ptr);
float Mediana(VECTOR *ptr);
void Moda(VECTOR *ptr);
int main(void)
{ VECTOR u;
const int datos[]={3,8,-4,8,7,6,9,-1,12,5,-10};
int i;

u.n=11;
u.dat=new int[u.n];
for(i=0; i<u.n; i++) //numera y acomoda
*(u.dat+i)=datos[i]; //seala
MuestraVector(&u);
printf("\n La Media es: %g",Media(&u)); // se imprime
solo lo que guardas en &u
printf("\n La Mediana es: %g",Mediana(&u));
delete [] u.dat;
return 0;
}

void MuestraVector(VECTOR *ptr)
{ int i;
for(i=0; i<ptr->n; i++)
printf("%i, ",ptr->dat[i]);
}
float Media(VECTOR *ptr)
{ int i;
float suma=0;
for(i=0; i<ptr->n; i++)
suma+=ptr->dat[i];
return(suma/ptr->n);
}
float Mediana(VECTOR *ptr)
{ int i,k,mayor,tmp;
VECTOR aux;
float mediana;

aux.n=ptr->n;
aux.dat=new int[ptr->n];
for(i=0; i<ptr->n; i++)
*(aux.dat+i)=ptr->dat[i];

for(i=0; i<ptr->n; i++)
{ mayor=*(aux.dat+i);
for(k=i+1; k<ptr->n; k++)
{ if(mayor<*(aux.dat+k))
{ tmp=mayor;

mayor=*(aux.dat+k);

*(aux.dat+k)=tmp; } }
*(aux.dat+i)=mayor;
}
printf("\n");
MuestraVector(&aux);
if((ptr->n%2)==0)
{//par
i=ptr->n/2;
k=i-1;
mediana=*(aux.dat+k)+*(aux.dat+i);
mediana/=2;
}
else
{//impar
i=ptr->n/2;
mediana=*(aux.dat+i);
}
delete [] aux.dat;
return(mediana);
}
void Moda(VECTOR *ptr)
{ int i;
VECTOR aux;

}






















































Matrices tarea

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
int nRows;
int nCols;
float **M;
} matrix;

matrix *matrixGet(int rows, int cols);
matrix *matrixSum(matrix *A, matrix *B);
int matrixSet(matrix *m);
int matrixDisplay(matrix *m);
int matrixFree(matrix *m);

int main(void)
{
matrix *A, *B, *C;
int rows, cols;
char cad[80];

printf("\nPrograma para manejo de matrices.");

do
{
printf("\nNumero de renglones: ");
rows = atoi(gets(cad));
} while(rows < 1);

do
{
printf("\nNumero de columnas: ");
cols = atoi(gets(cad));
} while(cols < 1);

A = matrixGet(rows, cols);
matrixSet(A);
B = matrixGet(rows, cols);
matrixSet(B);
C = matrixSum(A, B);
matrixDisplay(C);

matrixFree(A);
matrixFree(B);
matrixFree(C);

getchar();

return 0;
}

matrix *matrixGet(int rows, int cols)
{
matrix *m;
int y;

m = (matrix*)calloc(1, sizeof(matrix));

m->nRows = rows;
m->nCols = cols;

m->M = (float**)calloc(rows, sizeof(float*));

for(y = 0; y < rows; y++)
{
m->M[y] = (float*)calloc(cols,
sizeof(float));
}

return m;
}

int matrixSet(matrix *m)
{
int x, y;
char cad[80];

printf("\n");

for(x = 0; x < m->nRows; x++)
{
for(y = 0; y < m->nCols; y++)
{
printf("m[%d][%d] = ", x, y);
m->M[x][y] = atof(gets(cad));
}
}

return 0;
}

int matrixDisplay(matrix *m)
{
int x, y;

printf("\n");

for(x = 0; x < m->nRows; x++)
{
for(y = 0; y < m->nCols; y++)
{
printf("%10.2f", m->M[x][y]);
}
printf("\n");
}

return 0;
}

int matrixFree(matrix *m)
{
int y;

for(y = 0; y < m->nCols; y++)
{
free(m->M[y]);
}

free(m->M);
free(m);

return 0;
}

matrix *matrixSum(matrix *A, matrix *B)
{
int x, y;
matrix *C;

C = matrixGet(A->nRows, A->nCols);

for(x = 0; x < C->nRows; x++)
{
for(y = 0; y < C->nCols; y++)
{
C->M[x][y] = A->M[x][y]+B->M[x][y];
}
}

return C;
}


Captura matriz
#include<stdio.h>
#include<stdlib.h>

void CapturaMatriz(float M[][256],unsigned
char m, unsigned char n);
void MuestraMatriz(float M[][256],unsigned
char m, unsigned char n);
void MultiplicaAB(float M[][256],unsigned char
mr, unsigned char nr,
float M1[][256],unsigned char m1,
unsigned char n1,
float M2[][256],unsigned char m2,
unsigned char n2);

int main(void)
{unsigned char m1,m2,n1,n2,i,j,mr,nr;
float R[256][256],M1[256][256],M2[256][256];

printf("No. de filas de M1: ");
scanf("%i",&m1);
printf("No. de columnas de M1: ");
scanf("%i",&n1);
printf("No. de filas de M2: ");
scanf("%i",&m2);
printf("No. de columnas de M2: ");
scanf("%i",&n2);
CapturaMatriz(M1,m1,n1);
CapturaMatriz(M2,m2,n2);
MultiplicaAB(R,mr,nr,M1,m1,n1,M2,m2,n2);
MuestraMatriz(R,mr,nr);
return 0;
}


void MultiplicaAB(float R[][256],unsigned char
mr, unsigned char nr,
float M1[][256],unsigned char m1,
unsigned char n1,
float M2[][256],unsigned char m2,
unsigned char n2)

{ unsigned char i,j,k;
if(n1 !=m2)
{printf("No corresponden columnas y final
para el producto");
exit(1); }
for(i=0;i<m1;i++)
for(j=0;j<n2;j++)
{R[i][j]=0;
for(k=0;k<n1;k++)
R[i][j]=M1[i][k]*M2[k][j]+R[i][j];}
mr=m1;
nr=n2;
}
void CapturaMatriz(float M[][256],unsigned
char m, unsigned char n)
{ unsigned char i,j;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("\n M[%i][%i]=",i,j);
scanf("%f",&M[i][j]);}
}

void MuestraMatriz(float M[][256],unsigned
char m, unsigned char n)
{ unsigned char i,j;
for(i=0;i<m;i++)
{
printf("\n");
for(j=0;j<n;j++)
printf("\n M[%i][%j]=%g",i,j,M[i][j]);}}



















Multiplicacion Matriz
#include<stdio.h>
#include<stdlib.h>

typedef struct{float *datos;
unsigned int fil;
unsigned int col;
}MATRIZ;

void CapturaMatriz(MATRIZ *Mx);
void MuestraMatriz(MATRIZ *Ms);
void MultiplicaAB(MATRIZ *Re,MATRIZ
*Ma,MATRIZ *Mb);
int main(void)
{unsigned int i,j;
MATRIZ R,M1,M2;

printf("No. de filas de M1: ");
scanf("%i",&M1.fil);
printf("No. de columnas de M1: ");
scanf("%i",&M1.col);
M1.datos=new float[M1.fil*M1.col];
CapturaMatriz(&M1);
printf("No. de filas de M2: ");
scanf("%i",&M2.fil);
printf("No. de columnas de M2: ");
scanf("%i",&M2.col);
M2.datos=new float[M2.fil*M2.col];
CapturaMatriz(&M2);
R.fil=M1.fil;
R.col=M2.col;
R.datos=new float[R.fil*R.col];
MultiplicaAB(&R,&M1,&M2);
//printf("\n Matriz 1 \n");
//MuestraMatriz(&M1);
//printf("\n Matriz 2 \n");
//MuestraMatriz(&M2);
printf("\n PRODUCTO: \n");
MuestraMatriz(&R);
delete [] M1.datos;
delete [] M2.datos;
delete [] R.datos;
system("pause");
return 0;
}

void CapturaMatriz(MATRIZ *Mx)
{ unsigned int i,j;
for(i=0;i<Mx->fil;i++)
for(j=0;j<Mx->col;j++)
{printf("\n M[%i][%i]=",i,j);
scanf("%f",&Mx->datos[(i*Mx->col)+j]);}
}


void MuestraMatriz(MATRIZ *Ms)
{ unsigned int i,j;
for(i=0;i<Ms->fil;i++)
{printf("\n");
for(j=0;j<Ms->col;j++)
printf(" M[%i][%i]=%g",i,j,Ms->datos[(i*Ms-
>col)+j]);}}

void MultiplicaAB(MATRIZ
*Re,MATRIZ *Ma,MATRIZ *Mb)
{ unsigned char i,j,k;
if(Ma->col !=Mb->fil)
{printf("No corresponden columnas y filas
para el producto");
exit(1); }
for(i=0;i<Ma->fil;i++)
for(j=0;j<Mb->col;j++)
{Re->datos[i*Re->col+j]=0;
for(k=0;k<Ma->col;k++)
Re->datos[i*Re->col+j]=Ma->datos[i*Ma-
>col+k]*Mb->datos[k*Mb->col+j]+Re-
>datos[i*Re->col+j];}
}


































Numeros complejos
#include<stdio.h>
#include<stdlib.h>

typedef struct{ float Real;
float Img;
}COMPLEJO;
COMPLEJO* SumaComplex(COMPLEJO *a,
COMPLEJO *b);
COMPLEJO* MultComplex(COMPLEJO *a,
COMPLEJO *b);
void ShowComplex(COMPLEJO *S);


int main(void)
{COMPLEJO y,z,*r;
y.Real=3;
y.Img=2;
z.Real=2;
z.Img=-3;

r=SumaComplex(&y,&z);
ShowComplex(r);
delete r;
r=MultComplex(&y,&z);
printf("\n");
ShowComplex(r);
delete r;
system ("\npause");
return 0;
}

COMPLEJO* SumaComplex(COMPLEJO *a,
COMPLEJO *b)
{COMPLEJO *r;

r=new COMPLEJO;

//r=(COMPLEJO *)calloc(1,sizeof (COMPLEJO));

r->Real=a->Real+b->Real;
r->Img=a->Img+b->Img;
return (r);
}

void ShowComplex(COMPLEJO *s)
{printf("%g%+gi",s->Real,s->Img);
}
COMPLEJO* MultComplex(COMPLEJO *a,
COMPLEJO *b)
{COMPLEJO *r;

r=new COMPLEJO;
r->Real=a->Real*b->Real-a->Img*b->Img;
r->Img=a->Real*b->Img+a->Img*b->Real;
return(r);
}





Punteros

#include<stdio.h>
#include<stdlib.h>
int main(void)
{ float vector[10];
float *Ptr;
int i;
Ptr=&vector[0];
for(i=0; i<10; i++)
{printf("\n V[%i]=",i);
scanf("%f",(Ptr+i));
}
*(Ptr+4)=3.14;

for(i=0; i<10; i++)
printf("\n V[%i]= %f",i,vector[i]);
system("pause");
return 0;
}










































Acomodamiento tipo matriz
#include<stdio.h>
#include<stdlib.h>
int main(void)
{int M[3][3];
int *Ptr;
int i,j;
Ptr=&M[0][0];
for(i=0; i<9; i++)
{ printf("\n M[%i]=",i);
scanf("%i",Ptr+i);}
for(i=0; i<3; i++)
{printf("\n");
for(j=0; j<3; j++)
printf(" M[%i][%i]=%i",i,j,M[i][j]);}
system("pause");
return 0;
}

Ejemplo punteros normales
#include <stdio.h>

int main(void)

{
int Entero;
char Byte;
float Flotante;
int *ptr2Entero;
char *ptr2Byte;
float *ptr2Flotante;

Entero=5;
Byte=-2;
Flotante=3.141596;

printf("\n \n a=%i b=%i
c=%f", Entero, Byte, Flotante);

//INICIALIZACION DE UN
PUNTERO
ptr2Entero=&Entero;
ptr2Byte=&Byte;
ptr2Flotante=&Flotante;
//MODIFICAR LAS VARIABLES
REFERENCIADAS A TRAVES DE LOS
PUNTEROS
*ptr2Entero=20;
*ptr2Byte=-19;
*ptr2Flotante=0.1;

printf("\n \n a=%i b=%i
c=%f", Entero, Byte, Flotante);
return 0;}
//paso por referencia

#include <stdio.h>
#include <stdlib.h>

void FuncPasoPorValor(int A,
int B)
{ int d1,d2;
printf("\n A=%i B=%i",
A,B);
printf ("\n Escribe el
valor de A:");
scanf("%i",&d1);
printf ("\n Escribe el
valor de B:");
scanf ("%i",&d2);
A=d1;
B=d2;
printf("\n A=%i B=%i",A,B);
}

void FuncPasoPorReferencia(int
*X, int *Y)
{ int d1,d2;
printf ("\n Escribe el
valor de A:");
scanf("%i",&d1);
printf ("\n Escribe el
valor de B:");
scanf ("%i",&d2);
*X=d1;
*Y=d2;
printf("\n A=%i
B=%i",*X,*Y);
}

int main (void)
{ int A,B;
A=0;
B=0;
FuncPasoPorValor(A,B);
printf("\n Dentro de Main()
A=%i B=%i",A,B);
FuncPasoPorReferencia(&A,&B);
printf("\n Dentro de Main()
A=%i B=%i",A,B);
system ("pause");
return 0;
}