MATRIZ A VECTOR Y VICEVERSA.

- Se puede convertir una matriz en un

vector y también un vector en una matriz, aunque la operación correcta seria
copiar la matriz a un vector y viceversa.

Si la matriz tiene P filas y Q columnas, el vector tendrá P x Q elementos. Así en

el ejemplo, si la matriz tiene 4 filas y 6 columnas, el vector al que se vaya a
copiar estos elementos tendrá 24.

0 1 2 3 4 22 23

En este ejemplo, para evitar cargar de teclado, cargamos la matriz dentro el

programa con el contador K, es decir con los números enteros K = 1, 2, . . . .
23, 24. A partir de esta matriz, los subprogramas que siguen “convierten” la
matriz en vector y luego el vector en otra matriz. El programa principal que se
muestra a continuación describe este proceso.

Programa CopiaMatrizVectorMatriz()
Int M[4,6], V[24], A[4,6], i, j, T, k
INICIO
// cargando la matriz con los enteros 1,2,3, . . .24
T1 // comenzamos en UNO
Para i = 0, 3
Para j = 0, 5
M[i,j]  T : T  T + 1
FinPara
FinPara
mostrarMatriz(M, 4, 6) // muestra la matriz inicial
MatrizVector(M, 4, 6, V) // convertir a vector
mostrarVector(V, k) // mostrar el vector conseguido
VectorMatriz(V, A, 4, 6) // convertir a matriz
mostrarMatriz(A, 4, 6) // muestra la matriz final
FIN

Si se muestra la matriz M, con las 4 filas y 6 columnas y, cargada con el

contador K como se dijo antes, esta matriz M se mostraría así con el
subprograma mostraMatriz():
 2 3 4 5 6
7 8 9 10 11 12 Matriz M
13 14 15 16 17 18
19 20 21 22 23 24

Matriz a vector.- El subprograma que convierte la matriz M al vector V (el

vector V hasta el momento no contiene nada) es el siguiente:

// Convierte la matriz M en el vector V

Procedimiento MatrizVector(int M[], int P, int Q, int V[])
Int i, j
INICIO
// copiando la matriz al vector
k0
Para i = 0, P-1
Para j = 0, Q-1
V[k]  M[ i, j ] : k  k + 1
Fin Para
Fin Para
FIN

Mostrando el contenido del vector V, a partir de la copia de la matriz M en él, se

tendría lo siguiente, con el subprograma mostrarVector() visto anteriormente:

2 3 4 5 6 . . . . . . . . . 23 24 Vector V

Vector a Matriz.- El vector V, resultante de la primera conversión, ahora se

convierte en otra matriz, la matriz A con las mismas dimensiones que la matriz
original. El subprograma que hace esta operación de convertir (copiar) es el
siguiente:

Procedimiento VectorMatriz (int V[], A[], int P, int Q)

Int i, j, K
INICIO
k0
Para i = 0, P-1
Para j = 0, Q-1
A[i,j]  V[k] : k  k + 1
Fin Para
Fin Para
FIN

La nueva matriz A, creada a partir del vector V, con las mismas dimensiones
que la original se mostraría así con el subprograma mostrarMatriz():

2 3 4 5 6
7 8 9 10 11 12 Matriz A
13 14 15 16 17 18
19 20 21 22 23 24

Finalmente, el subprograma que muestra los elementos de una matriz es el que

sigue:
// subprograma que muestra los elementos de una matriz
Procedimiento mostrarMatriz (int M[], int P, int Q)
int i, j
INICIO
Para i = 0, P-1
Para j = 0, Q-1
Mostrar M[i,j]
Fin Para
Fin Para
FIN

VERSION MEJORADA.- El convertir un vector en una matriz, puede dar lugar

a matrices de distintas dimensiones, dependiendo de N (la dimensión del
vector) es decir, de distintas cantidades de filas y de columnas. Para el caso del
ejemplo (N=24), podemos tener las posibles siguientes matrices: A[2,12],
A[3,8], A[4,6], A[6,4], A[8,3] y A[12,2].

El subprograma que hace esta operación de copiar creando dinámicamente las

dimensiones de la matriz nueva, a partir de los divisores de N es el siguiente:

Procedimiento VectorMatriz (int V[], int N, A[])

Int i, j, K
INICIO
//calculamos nro de filas
bb  0 : K  3 // buscamos 3 o mas filas
Mientras (bb = 0)
Si N mod K = 0
Entonces bb  K
Sino K  K + 1
FinSi
FinMientras
P  bb // el numero de filas
Q  N/P // el numero de columnas
// copiamos el vector a la matriz
k0
Para i = 0, P-1
Para j = 0, Q-1
A[i,j]  V[k] : k  k + 1
Fin Para
Fin Para
FIN

Para N = 24 (tamaño del vector V), las dimensiones calculadas por este
programa para la matriz resultante serian: P = 3 y Q = 8. Este se mostraría así:

2 3 4 5 67 8
Matriz A
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24

En el subprograma se inicializa K en 3, porque se busca una matriz de 3 o mas

filas. Si K se inicializa en 1, se tendría una matriz de 2 x 12 para nuestro
ejemplo (N=24). Si N fuera un numero primo, no seria posible llevar a una
matriz, a no ser que se permitan elementos vacíos.