int - Cobre 2 Software

Fundamentos de
programación
Punteros y Arrays
Punteros
Un puntero es una variable que puede contener la
dirección de otra variable.
<tipo> * <variable> ;
int a, b, *p;
··· ··· ···
p = &a;
*p = 5;
p = &b;
*p = a + 1 ;
/* p es un puntero a un entero */
/* p contiene la dirección de a */
/* a toma el valor 5 */
/* p contiene ahora la dirección de b */
/* b toma el valor 6 */
Punteros
Errores comunes con punteros
int a, b, *p;
··· ··· ···
p = &17;
p = &(a + 1);
&b = p;
p = 4783 ;
/* p es un puntero a un entero */
/* Las constantes no tienen dirección */
/* Una expresión tampoco tiene dirección */
/* Las direcciones no se pueden cambiar */
/* Tendría que ser p = (int *) 4783 */
Además para imprimir punteros con printf() hay que
usar los formatos %u y %p.
Punteros
No se recomienda realizar asignaciones directas
(sin casting) entre punteros que apuntan a distintos
tipos de variables, excepto el tipo genérico void * .
int * a;
char * b;
void * c;
··· ··· ···
b = a; a = b; /* genera un aviso por tipos diferentes */
b = (char *) a; /* Correcto */
a = c = b;
/* Correcto, se usa c como un comodín */
Aritmética de punteros
No están permitidas las operaciones que no tienen
sentido con direcciones de variables, como multiplicar y/o
dividir, pero sí otras como sumar y restar.
int a, b, *p;
··· ··· ···
a = 10;
p = &a;
/* p toma la dirección de a, &a */
*p = *p + 5; /* a tiene el valor 15 */
*p += 1;
/* Ahora el valor de a es 16 */
(*p)++;
/* a es 17, los paréntesis son necesarios */
++*p;
/* a toma el valor 18 */
b = *p++;
/* b vale 18, pero p ya no contiene &a */
*p-- = 4;
/* p es de nuevo &a */
b = *++p; /* ¿Cuánto vale b y quién es p? */
Declaraciones complicadas con punteros
char **argv
argv: array de punteros a char. Lo mismo que char *argv[ ].
int (*tabladias) [13]
tabladias: puntero a un array de 13 enteros.
int *tabladias [13]
tabladias: array de 13 punteros a entero.
int *fun ( )
fun: función sin parámetros que retorna un puntero a entero.
int (*fun) ( )
fun: puntero a una función que retorna un entero.
char (* (*A( ) ) [ ] ) ( )
A: función que retorna un puntero a un array de punteros a
función, que retornan cada una de ellas un char.
char (* (*A[3] ) ( ) ) [5]
A: array de 3 punteros a funciones que retornan un puntero a
un array de caracteres con 5 componentes.
Declaraciones complicadas con punteros
typedef char (*Pfc) (int);
Pfc p; /* es equivalente a char (*p) (int) */
Pfc denota un puntero a una función que admite un
parámetro entero y retorna un char.
typedef long (*(*(*FPUNT) ( ) ) [3] ) ( );
FPUNT fun;
Se define el identificador FPUNT como un puntero
a función que no recibe argumentos y devuelve un
puntero a un array de 3 punteros a función, que no
reciben ningún parámetro y devuelven long.
Un ejemplo de puntero a función
Modo alternativo de usar sin(x) y cos(x)
#include <stdio.h>
#include <math.h>
const double PI = 3.141592654;
void main(void)
{
double (*pfun) (double);
pfun = sin;
printf(“%lf\n”, (*pfun)(PI/2));
pfun = cos;
printf(“%lf\n”, (*pfun)(PI/2));
}
Arrays - vectores
Un vector o array unidimensional es una colección
finita de elementos, todos del mismo tipo, con las
siguientes características:
¾ El número de elementos del vector es finito y prefijado
de antemano.
¾ El acceso a cada elemento del vector se realiza
mediante un nombre y un índice. El nombre es común a
todos los elementos y el índice indica la posición del un
elemento (componente) dentro de la colección.
¾ Los elementos del vector se almacenan en posiciones
consecutivas de memoria.
Arrays - vectores
<tipo> <nombre> [ <tamaño> ] ;
<tipo>
: Tipo de los elementos del vector.
<nombre> : Identificador para el vector y sus elementos.
<tamaño> : Expresión constante que indica el número de
elementos del vector.
int meses [12];
char letras [26], notas [40];
unsigned long elementos [45];
double medias [NMAX + 1];
Arrays - vectores
Acceso a un vector de 20 componentes
int A [20]; componentes indizadas entre 0 y 19.
A[0]
A[1]
A[2]
··· ··· ··· A[18]
A[19]
A[0] = A[6] = A[18] = 3;
A[1] = 54; A[2] = 4 * A[1];
for(i = 0; i < 20; A[i++] = 5);
for(i = 0; i < 9; A[2 * i] = i++);
for(i = 0; i < 20; i++)
printf(“A[%d] = %d ;”,i,A[i]);
Arrays - vectores
Recordar que:
¾ No se puede comparar un vector con otro, incluso
siendo del mismo tipo, ni tampoco copiar o asignar
un vector a otro directamente. Las operaciones
siempre se efectúan elemento a elemento.
¾ C permite asignar valores fuera de rango a los
subíndices de un array. Debe controlarse esta
circunstancia, debido a que podría producirse una
sobreescritura de datos o código.
Arrays - vectores
Lectura de un vector
#include <stdio.h>
#define MAX 5
void main ()
{
int i, A[MAX];
/* inicializar A */
for (i = 0; i < MAX; i++)
scanf(“%d”, &A[i]);
··· ··· ···
}
Arrays - vectores
Comparar dos vectores
#define LONG_MAX 10
int A[LONG_MAX], B[LONG_MAX];
··· ··· ···
for(i = 0; i < LONG_MAX; i++)
if (A[i] != B[i])
break;
/* A == B si i == LONG_MAX */
Reescribir el código anterior con bucle while sin usar
la sentencia break.
Arrays - vectores
Multiplicar dos polinomios
#include <stdio.h>
#define N 20
typedef int POL[N + 1];
void leerpol(POL p)
{
int ex;
for(ex = 0; ex <= N; p[ex++] = 0);
for(;;)
{
scanf(“%d”, &ex);
if(ex >= 0) scanf(“%d”,&p[ex]);
else return;
}
}
Arrays - vectores
Multiplicar dos polinomios
void escpol(POL p)
{
int i;
if(p[0]) printf(“%d”,p[0]);
for(i = 1; i <= N; i++)
if(p[i])
{
printf(“%c”,p[i] > 0 ? ‘+’ : ‘-’);
if(abs(p[i]) != 1) printf(“%d”,abs(p[i]));
if(i == 1)
printf(“x”);
else printf(“x^%d”,i);
}
printf(“\n”);
}
Arrays - vectores
Multiplicar dos polinomios
void sumapol(POL p, POL q, POL r)
{
int ex;
for(ex = 0; ex <= N; ex++) r[ex] = p[ex] + q[ex];
}
void multmon(int co, int ex, POL p)
{
int i, j;
for(i = 0; i <= N && p[i] == 0; i++);
for(j = N; j >= 0 && p[j] == 0; j--);
while(j >= i)
{
p[j + ex] = co * p[j];
j--;
}
for(j = i; j <= i + ex - 1; p[j++] = 0);
}
Arrays - vectores
Multiplicar dos polinomios
void multpol(POL p, POL q, POL r)
{
POL s;
int i, j;
for(i = 0; i <= N; r[i++] = 0);
for(i = 0; i <= N; i++)
if(p[i])
{
for(j = 0; j <= N; j++)
s[j] = q[j];
multmon(p[i],i,s);
sumapol(r,s,r)
}
}
Arrays - vectores
Multiplicar dos polinomios
void main(void)
{
POL p, q, r; /* grado(p) + grado(q) <= N */
leerpol(p);
printf(“p(x) = ”);
escpol(p);
leerpol(q);
printf(“q(x) = ”);
escpol(q);
multpol(p,q,r);
printf(“p(x) * q(x) = ”);
escpol(r);
}
Arrays - vectores
Un vector es en realidad una dirección
(... y en consecuencia el nombre de un array NO es una variable)
int A[10];
int i, *p;
p = A; p = &A[0]; /* Asignaciones equivalentes */
*p = 2;
/* A[0] = 2 */
A[6] = 72;
*(p + 6) == 72
/* Cierto, *(p + i) == A[i] */
for(i = 0; i < 10; A[i++] = 1);
p = &A[3]; p++;
for(i = 1; i < 5; *(p + i) = i, i += 2);
printf(“%d”, *p); /* ¿Qué imprime esta sentencia? */
printf(“%c”,(char) *++p); /* ¿Y ésta otra? */
Arrays - vectores
Lectura de un vector (versión con puntero)
#include <stdio.h>
#define MAX 5
void main ()
{
int A[MAX];
Leer(A);
··· ··· ···
}
void Leer (int *vector)
{
int i;
for (i = 0; i < MAX; i++)
scanf(“%d”, vector + i);
}
Arrays - vectores
Inicialización de vectores
int contador[3] = {3,4,5};
char vocales[5] = {‘a’,‘e’,‘i’,‘o’,‘u’};
int vect[4] = {0,1,2,3,4}; /* Incorrecto, ¿por qué? */
/* El tamaño se asigna con la inicialización */
char nombre[ ] = {‘J’,‘a’,‘i’,‘m’,‘e’};
unsigned short int marcas[] = {3,5,6,1};
int A[ ];
/* Incorrecto, falta inicializar array */
int lista[100] = {0}; /* Todas las componentes cero */
char *tiempo[3] = {“hora”,“minuto”,“segundo”};
unsigned char R[] = {1,‘\\’,‘\x56’,‘y’};
Arrays - vectores
Búsqueda secuencial en vectores
/*
Devuelve la posición de x dentro del array
en su caso, N si x no ha sido encontrado
*/
int busca (int A[ ], int x) /* N elementos */
{
int i;
for(i = 0; i < N; i++)
if(A[i] == x)
break;
return i; /* return (i < N) ? i : -1; */
}
Arrays - vectores
Búsqueda secuencial: versión con indicador
int busca (int A[ ], int x) /* N elementos */
{
int
i = 0;
char enc = 0; /* enc es el indicador */
while(i < N && !enc)
if(A[i] == x)
enc = 1;
else i++;
return enc ? i : N; /* return i; */
}
Arrays - vectores
Ordenar un vector: método de la burbuja
void burbuja (int A[ ]) /* N elementos */
{
int i, j;
for(i = 0; i < N - 1; i++)
for(j = i + 1; j < N; j++)
if(A[i] > A[j])
intercambia(A,i,j);
}
void intercambia (int A[], int i, int j)
{
int z;
z = A[i]; A[i] = A[j]; A[j] = z;
}
Arrays - vectores
Ordenar un vector: método quicksort
void quicksort(int A[], int inf, int sup)
{
int p;
if(inf < sup) {
p = particion(A,inf,sup);
quicksort(A,inf,p - 1);
quicksort(A,p + 1,sup);
}
}
Arrays - vectores
Ordenar un vector: método quicksort
int particion(int A[], int inf, int sup)
{
int pivot, i, j, temp;
pivot = A[inf]; i = inf; j = sup + 1;
for(;;) {
do ++i; while (A[i] <= pivot && i <= sup);
do --j; while (A[j] > pivot);
if(i >= j) break;
temp = A[i]; A[i] = A[j]; A[j] = temp;
}
temp = A[inf]; A[inf] = A[j]; A[j] = temp;
return j;
}
Arrays - vectores
Búsqueda secuencial en vectores ordenados
A[0] < A[1] < A[2] < ··· < A[N-1]
int busca (int A[ ], int x) /* N elementos */
{
int i;
for(i = 0; i < N; i++)
if(A[i] == x)
break;
else if(A[i] > x)
return N;
return i;
}
Arrays - vectores
Búsqueda secuencial en vectores ordenados (ver. 2)
int busca (int A[ ], int x) /* N elementos */
{
int i = 0, fin = 0;
while(i < N && ! fin)
if(A[i] == x)
fin = 1;
else if(A[i] > x)
{
fin = 1;
i = N;
}
else ++i;
return i; /* return fin ? -1 : i; */
}
Arrays - vectores
Búsqueda binaria (dicotómica, bipartición)
A[0] < A[1] < A[2] < ··· < A[N - 1]
int busca (int A[ ], int x) /* N elementos */
{
int inf = 0, sup = N - 1, med;
while(inf <= sup) {
med = (inf + sup) / 2;
if(x < A[med])
sup = med - 1
else if(x > A[med])
inf = med + 1
else return med;
}
return -1;
}
Arrays - vectores
Búsqueda binaria: versión recursiva
int busca (int A[], int x)
{
return buscabin(A,x,0,N - 1);
}
int buscabin (int A[ ], int x, int inf, int sup)
{
int med;
if(inf <= sup) {
med = (inf + sup) / 2;
if(x == A[med]) return med;
else if(x < A[med])
return buscabin(A,x,inf,med - 1);
else
return buscabin(A,x,med + 1,sup);
}
return -1;
}
Arrays - listas
Listas de elementos
Una lista de elementos es una estructura de datos que está
formada conjuntamente por un vector y un índice. El índice
representa el número de elementos válidos en el vector.
#define MaxElem 40
typedef int TLista [MaxElem];
TLista Mi_lista; /* Mi_lista es un array de 40 enteros */
int NElem;
/* NElem es el número de elementos válidos */
··· ··· ···
#define MaxElem 100
typedef char * TLista [MaxElem];
/* TLista es ahora un array de 100 punteros a char */
Arrays - listas
Operaciones con listas
#define MaxElem 100
/* Por ejemplo */
typedef <Tipo_base> TElem; /* A definir
*/
typedef TElem TLista [MaxElem];
TLista Lista; /* Variable de lista con índice */
··· ··· ···
void inicializar_lista (TLista L, int * NElem)
{
*NElem = 0;
}
int lista_vacia (TLista L, int NElem)
{
return ! NElem; /* Número de elementos nulo */
}
Arrays - listas
Operaciones con listas
int lista_llena (TLista L, int NElem)
{
return NElem == MaxElem;
}
TElem pos_lista (int pos, TLista L, int NElem)
{
/*
posición = 1 , 2 ,...,
NElem
*/
/* Elementos válidos L[0],L[1],...,L[NElem - 1] */
if(pos < 1 || pos > NElem)
return (TElem) -1;
else return L[pos - 1];
}
/* error */
Arrays - listas
Operaciones con listas
void eliminar_lista (TElem x, TLista L, int *NElem)
{
int i;
/* Elementos válidos L[0],L[1],...,L[NElem - 1] */
for(i = 0; i < *NElem; i++)
if(L[i] == x) {
for(i++; i < *NElem; i++)
L[i - 1] = L[i];
--*NElem; /* (*NElem)--, *NElem -= 1 */
break; /* en realidad es innecesario,
al final siempre i >= *NElem */
}
}
Arrays - listas
Operaciones con listas
int insertar_lista (int pos, TElem x,
TLista L, int *NElem)
{
int i;
if(*NElem == MaxElem ||
/* lista llena */
pos < 1 || pos > *NElem + 1) return -1; /* error */
/*
/*
posición = 1 , 2 ,...,
NElem
Elementos válidos L[0],L[1],...,L[NElem - 1]
*/
*/
for(i = *NElem; i >= pos; i--)
L[i] = L[i - 1];
L[pos - 1] = x;
++*NElem;
return 0;
}
/* igual (*NElem)++ , *NElem += 1 */
/* retorno 0, inserción correcta */
Arrays - strings
¾ Un string o cadena de caracteres es una secuencia
de cero o más caracteres que finaliza con ‘\0’.
¾ Un string se considera un string constante o literal si
los caracteres aparecen tal cual entre comillas dobles.
“Hola mundo”
“Esto es un string literal o constante”
“El resultado es %d \n”
“\x31\x32\x33\x34\x35”
“ \“Esto tambien en un literal\” ”
Arrays - strings
Asignación de un string literal
char * saludo = “Hola mundo”;
char * p = “Esto es un string literal”;
char * formato = “El valor buscado es %d\n”;
char numeros[] = “\x31\x32\x33\x34\x35”;
char vacia[] = “”;
/* sólo está ‘\0’ */
char str[6] = {‘e’,‘r’,‘r’,‘o’,‘r’,‘\0’};
char * saltos7 = “\n\n\n\n\n\n\n”;
char * Innecesario = {“string entre llaves”};
char MuyLarga[] = “Esta cadena es larga\
bastante larga, pero que muy larga”;
Arrays - strings
En C no se permite
¾ Comparar strings con ningún tipo de operador.
¾ Copiar directamente un string en otro usando
la sentencia de asignación.
... entonces, ¿cómo lo hago?
Arrays - string.h
C proporciona el header estándar <string.h> que
contiene una colección de funciones básicas para el
manejo de strings y, en general, de cadenas de
caracteres.
Dentro de <string.h> hay dos grupos de funciones, que
se distinguen por el comienzo de sus nombres:
¾ Funciones que comienzan por str : manejan
datos de tipo string, es decir, cadenas de
caracteres que terminan con un nulo ‘\0’.
¾ Funciones que comienzan por mem : manejan
cadenas de caracteres en general, por tanto, no
es necesario que terminen con ‘\0’.
Arrays - string.h
Algunas funciones de uso habitual
char * strcpy (char * s, const char * t)
Copia el string t en el string s, incluyendo el terminador ‘\0’, retorna s.
char * strncpy (char * s, const char * t, size_t n)
Copia como máximo n caracteres del string t en s, retorna s. Si t tiene
menos de n caracteres, se rellena el exceso con ‘\0’.
char * strcat (char * s, const char * t)
Concatena el string t al final del string s, retorna s.
int strcmp (const char * s, const char * t)
Compara el string s con t usando el orden lexicográfico, retorna < 0 si
s < t, 0 si s == t ó > 0 si s > t.
int strncmp (const char * s, const char *t, size_t n)
Compara como máximo n caracteres del string s con t, retorna < 0 si
s < t, 0 si s == t ó > 0 si s > t.
Arrays - string.h
Algunas funciones de uso habitual
size_t strlen (const char * s)
Retorna la longitud del string s.
void * memcpy (void * s, const void * t, size_t n)
Copia n caracteres de la cadena t en la cadena s, retorna s.
void * memset (void * s, int c, size_t n)
Coloca el carácter c en la n primeras posiciones de la cadena s,
retorna s. El entero c se convierte a unsigned char.
int memcmp (const void * s, const void * t, size_t n)
Compara los primeros n caracteres de la cadena s con la cadena t,
retorna < 0 si s < t, 0 si s == t ó > 0 si s > t.
Arrays - string.h
Ejemplos de implementación
char * strcpy (char * s, const char * t)
{
int i;
for(i = 0; s[i] = t[i]; i++);
return s;
}
char * strcpy (char * s, const char * t)
{
char * p = s;
while (*p++ = *t++);
return s;
}
Arrays - string.h
Ejemplos de implementación
size_t strlen (const char * s)
{
int i;
for(i = 0; s[i]; i++);
return (size_t) i;
}
int memcmp (const void * s, const void * t, size_t n)
{
int i;
const char * p = s, * q = t;
for(i = 0; i < n && p[i] == q[i]; i++);
if(i == n) return 0;
return p[i] - q[i];
}
Arrays - string.h
Ejemplos de implementación
void * memcpy (void * s, const void * t, size_t n)
{
int i;
char * p = s;
const char * q = t;
for(i = 0; i < n; i++) p[i] = q[i];
return (void *) p;
}
void * memset (void * s, int c, size_t n)
{
int i;
char * p = s;
for(i = 0; i < n; p[i++] = (unsigned char) c);
return (void *) p;
}
Arrays - matrices
Una matriz o array bidimensional es una colección
finita de elementos, todos del mismo tipo, con las
siguientes características:
¾ El número de elementos de la matriz es finito y prefijado
de antemano. La disposición de los elementos se asemeja a
una tabla organizada por filas y columnas.
¾ El acceso a cada elemento de la matriz se realiza
mediante un nombre y dos índices. El nombre es común a
todos los elementos; el primer y el segundo índice indican
respectivamente la fila y la columna donde se encuentra un
cierto elemento dentro de la colección (es decir su posición
en la matriz).
¾ Los elementos de la matriz se almacenan por filas en
posiciones consecutivas de memoria.
Arrays - matrices
<tipo> <nombre> [ <nº filas> ] [ <nº columnas> ];
<tipo>
: Tipo de los elementos de la matriz.
<nombre> : Identificador para la matriz y sus elementos.
<nº filas> : Expresión constante que indica el número de
filas que tiene la matriz.
<nº columnas> : Expresión constante que indica el número
de columnas que tiene la matriz.
Tamaño de una matriz (memoria ocupada)
nº filas x nº columnas x sizeof(tipo)
Arrays - matrices
Acceso a una matriz de N filas y M columnas
int
A [N][M];
/*
N
x
M
enteros */
A[i][j] denota el elemento en la posición (i,j)
0,0
0,1
0,2
0,3
··· ··· ···
0,M-2
0,M-1
1,0
1,1
1,2
1,3
··· ··· ···
1,M-2
1,M-1
··· ··· ···
··· ··· ···
··· ··· ···
··· ··· ···
··· ··· ···
··· ··· ···
··· ··· ···
N-2,0
N-2,1
N-2,2
N-2,3
··· ··· ···
N-2,M-2 N-2,M-1
N-1,0
N-1,1
N-1,2
N-1,3
··· ··· ···
N-1,M-2 N-1,M-1
Arrays - matrices
Acceso a los elementos de una matriz
Se puede acceder a los elementos de una matriz usando
bucles anidados; el bucle externo se utiliza para el
acceso a las filas y el bucle interno para el acceso a las
columnas.
for(i = 0; i < NFilas; i++)
for(j = 0; j < NColumnas; j++)
{
/* Tratamiento de cada elemento */
procesar(matriz[i][j]);
}
Arrays - matrices
Lectura de una matriz
#include <stdio.h>
#define MAX 20
void main (void)
{
int Mat[MAX][MAX], fil, col, i, j;
printf(“\n Número de filas : ”);
scanf(“%d”, &fil);
/* 0 < fil <= MAX */
printf(“\n Número de columnas : ”);
scanf(“%d”, &col);
/* 0 < col <= MAX */
printf(“Introducir elementos matriz por filas :”);
for(i = 0; i < fil; i++)
for(j = 0; j < col; j++) {
printf(“\n Mat[%d][%d] = ”, i, j);
scanf(“%d”, &Mat[i][j]);
}
··· ··· ···
}
Arrays - matrices
Escritura de una matriz
#include <stdio.h>
#define MAX 20
void main (void)
{
int Mat[MAX][MAX], fil, col, i, j;
/* Lectura de la matriz */
··· ··· ···
/* Escritura de la matriz por filas */
for(i = 0; i < fil; i++) {
for(j = 0; j < col; j++)
printf(“ %5d”, Mat[i][j]);
printf(“\n”); /* salto para siguiente fila */
}
··· ··· ···
}
Arrays - matrices
Producto algebraico de dos matrices
#define N 3
#define M 4
#define P 5
··· ··· ···
int A[N][P], B[P][M], C[N][M];
··· ··· ···
for(i = 0; i < N; i++)
for(j = 0; j < M; j++)
{
C[i][j] = 0;
for(k = 0; k < P; k++)
C[i][j] += A[i][k] * B[k][j];
}
Arrays - matrices
Inicialización de matrices
int tabla[2][4] = {0};
int tabla[2][4] = {1,2,3,4,5,6,7,8}
int tabla[2][4} = {1,2,3,4},
{5,6,7,8}};
int tabla[ ][4] = {{1,2,3,4},
{5,6,7,8}};
/* Incorrecto */
int tabla[2][ ] = {{1,2,3,4},
{5,6,7,8}};
Arrays - matrices
Paso de una matriz como parámetro de una función
Supongamos declarada la matriz
int tabla [2][4];
que deseamos pasar como parámetro de un función fun. Existen varias
posibilidades equivalentes:
/* Usar el array tal y como está declarado */
void fun ( int tabla[2][4] );
/* Ignorar el número de filas */
void fun ( int tabla[ ][4] );
/* Usar un puntero */
void fun ( int (*tabla)[4] );
Los paréntesis en (*tabla) son necesarios para que sea “puntero a
vector de tamaño 4”, es decir, puntero a puntero. Sin los paréntesis sería
“vector de tamaño 4 cuyos elementos son punteros”, por la mayor
prioridad del operador [ ] sobre el operador *.
Arrays - matrices
Punto de silla de una matriz cuadrada
#include <stdio.h>
#include <math.h>
#define N 3
typedef int MATRIZ [N][N];
void LeerMatriz (MATRIZ);
void EscMatriz (const MATRIZ);
int Maximo (int, const MATRIZ);
int HayMin (int, int, const MATRIZ);
int Silla (const MATRIZ, int *, int *);
Arrays - matrices
Punto de silla de una matriz cuadrada
void main (void)
{
MATRIZ A;
int fil, col;
LeerMatriz(A);
EscMatriz(A);
if(Silla(A, &fil, &col))
printf(“Hay punto de silla [%d,%d] = %d\n”,
fil,col,A[fil][col]);
else
printf(“No existe punto de silla\n”);
}
Arrays - matrices
Punto de silla de una matriz cuadrada
void LeerMatriz (MATRIZ A)
{
int i,j;
for(i = 0; i < N; i++)
for(j = 0; j < N; j++) scanf(“%d”, &A[i][j]);
}
void EscMatriz (const MATRIZ B)
{
int i, j;
for(i = 0; i < N; i++)
{
for(j = 0; j < N; j++)
printf(“%d ”, B[i][j]);
printf(“\n”);
}
}
Arrays - matrices
Punto de silla de una matriz cuadrada
int Silla(const MATRIZ A, int *fil, int *col)
{
*fil = 0;
while(*fil < N)
{
*col = Maximo(*fil,A);
if(*col < N && HayMin(*fil,*col,A))
return 1;
*fil += 1;
}
return 0;
}
Arrays - matrices
Punto de silla de una matriz cuadrada
int Maximo (int i, const MATRIZ A)
{
int j, k;
for(j = 0, k = 1; k < N; k++)
if(A[i][j] <= A[i][k])
{
if(A[i][j] == A[i][k])
for(k++; k < N; k++)
if(A[i][k] > A[i][j])
break;
j = k;
}
return j;
}
Arrays - matrices
Punto de silla de una matriz cuadrada
int HayMin (int i, int j, const MATRIZ A)
{
int k;
for(k = 0; k < N; k++)
if(k != i && A[k][j] <= A[i][j])
return 0;
return 1;
}
Arrays - matrices
Algunos tipos de matrices cuadradas
Diagonal
Simétrica
Antisimétrica
Triangular superior
Triangular inferior
Tribanda
A(i,j)
A(i,j)
A(i,j)
A(i,j)
A(i,j)
A(i,j)
=
=
=
=
=
=
0 para i ≠ j
A(j,i)
-A(j,i)
0 para i > j
0 para i < j
0 si |i – j| <= 1
En programación, el valor 0 podría ser cualquier
otro, siempre que su significado sea “el valor que se
repite por defecto”.
Arrays - matrices
Elementos adyacentes a una componente (i,j)
i-1,j-1
i-1,j
i-1,j+1
i,j-1
i,j
i,j+1
i+1,j-1
i+1,j
i+1,j+1
Arrays - matrices
Elementos adyacentes a una componente (i,j)
Condición: componentes (r,s) que verifican
|i - r| <= 1 && |j - s| <= 1
excepto el borde o perímetro de la matriz.
Arrays - matrices
Elementos adyacentes a una componente (i,j)
Comprobar si una componente (i,j) es la suma de sus
componentes adyacentes.
int Matriz[NFil][NCol];
··· ··· ···
suma = 0;
for(r = i - 1; r <= i + 1, r++)
for(s = j - 1; s <= j + 1; s++)
if(r != i || s != j)
suma += Matriz[r][s];
if(Matriz[i][j] == suma)
··· ··· ···
Arrays - matrices
Matrices k-dimensionales
<tipo> <nombre> [ <dim 1> ] ··· [ <dim k> ] ;
char espiral [10][20][5];
short medida [LARGO][ANCHO][ALTO];
float posicion [ejeX][ejeY][ejeZ][TIEMPO];
espiral[i][4][9] = 2;
medida[0][0][1] = 25;
posicion[i][2 * j][6][seg] = 4.73;