Vetores e Matrizes

Muitos programas requerem o tratamento de vários dados do mesmo tipo. Nestas

situações torna-se conveniente guardar os dados em matrizes, pois guardar cada idade
do aluno numa variável nova seria impraticável.
Imagine declarar 150 variáveis para guardar todas as idades dos alunos. Assim, Surge a
necessidade de utilizar as matrizes, que permitem com um único identificador guardar
um conjunto de dados do mesmo tipo.
A forma mais fácil de imaginar uma matriz é a através de uma tabela que tem um
conjunto de m linhas e de n colunas (mxn). As matrizes podem possuir uma ou mais
dimensões: quando possuem uma só dimensão designam-se de unidimensionais ou
vetores; quando possuem duas dimensões designam-se de matrizes bidimensionais ou
somente matrizes; e quando possuem mais que duas dimensões designam-se de
matrizes multidimensionais.

Os dados das matrizes são armazenados em endereços de memória contíguos.

Em C# as matrizes são objetos, pelo que devem ser inicializadas com a palavra “new”.
Caso se queira atribuir valores iniciais à matriz pode-se omiti a parte new int[].

Vetores
Um vetor é uma variável unidimensional formada por uma sequência de valores de um
determinado tipo de dados. A seguinte figura mostra a representação de um vetor. O
acesso aos elementos do vetor faz-se utilizando o nome do vetor e o índice dos
elementos que varia entre 0 e o tamanho do vetor menos 1.

A definição de vetores faz-se da forma apresentada em seguida.

Sintaxe:
<tipo_de_dados> [] <nome_do_vetor>;
Exemplo: vetor “a” de inteiros
int [] a;

A inicialização de um vetor faz-se da forma apresentada de seguida.

Sintaxe:
<tipo_de_dados> [] <nome_do_vetor> = new tipo_de_dados [dimensão]
<tipo_de_dados> [] <nome_do_vetor> = new tipo_de_dados [dimensão]
{valor1, valor2, …, valorn}
 <tipo_de_dados> [] <nome_do_vetor> = new tipo_de_dados [] {valor1, valor2,
…, valorn}
<tipo_de_dados> [] <nome_do_vetor> = {valor1, valor2, …, valorn}

Exemplo de um vetor de inteiros inicializado com 5 valores:

int[] a = new int[5];
Exemplo de um vetor de inteiros inicializado com os seguintes os valores iniciais 10, 20,
30, 40, 50:
intl] a = new int[5]{10,20,30,40,50};
int[] a = new int[]{10,20,30,40,50};
intl] a = {10,20,30,40,50};

Um vetor que não seja explicitamente inicializado será inicializado com todos os
valores a 0.

Manipulação de vetores
Exemplo 1- Leitura e escrita de valores num vetor
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] a = new int[] { 10, 20, 30, 40, 50 };
Console.WriteLine(a[3]); //Mostra o elemento 40
Console.Write("Insira um valor para a terceira posição:");
a[2] = Convert.ToInt32(Console.ReadLine());
Console.WriteLine(a[2]); //Mostra o valor inserido
}
}
}

Exemplo 2 – Leitura e escrita de um vetor de inteiros

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
 Console.Write("Quantos elementos deseja para o vetor:");
int n = Convert.ToInt32(Console.ReadLine());
int[] v = new int[n];
for (int i = 0; i < n; i++)
{
Console.Write("Insira um número para a posição {0}:", i);
v[i] = Convert.ToInt32(Console.ReadLine());
}
for (int i = 0; i < n; i++)
{
Console.WriteLine("Valor na posição {0}: {1}", i, v[i]);
}
}
}
}

Exemplo 3 – Contar valores superiores a 5

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] v = new int[] { 3,7,4,9,2,6,7,8,9,2};
int contar = 0;
for (int i = 0; i < v.Length; i++) {
if (v[i] > 5) {
contar ++;
}
}
Console.WriteLine("Resultado: {0}”, contar);
}
}
}

Neste exemplo, como não se sabia o número de elementos, utilizou-se a propriedade

Length. Esta propriedade dos vetores devolve o número de elementos do mesmo.

Exemplo 4 – Pesquisar um elemento no vetor

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] v = new int[] { 3,7,4,9,2,6,7,8,9,2};
for (int i = 0; i < v.Length; i++) {
if (v[i] == 7) {
Console.WriteLine("Índice: {0}”, i);
break;
}
}
}
}
}

Exemplo 5 – Soma dos elementos do vetor

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] v = new int[] { 3, 7, 4, 9, 2, 6, 7, 8, 9, 2 };
int soma = 0;
for (int i = 0; i < v.Length; i++)
{
soma += v[i];
}
Console.WriteLine("Resultado: {0}", soma);
}
}
}~

Exemplo 6 – Média dos elementos do vetor

using System;
namespace ConsoleApp1
{
class Program
 {
static void Main(string[] args)
{
int[] v = new int[] { 3, 7, 4, 9, 2, 6, 7, 8, 9, 2 };
int soma = 0;
for (int i = 0; i < v.Length; i++)
{
soma += v[i];
}
Console.WriteLine("Resultado: {0:F}", (float)soma / v.Length);
}
}
}

Exemplo 7 – Menor valor de um elemento do vetor

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] v = new int[] { 3, 7, 4, 9, 2, 6, 7, 8, 9, 2 };
int menor = v[0];
for (int i = 0; i < v.Length; i++)
{
if (v[i] < menor)
menor = v[i];
}
Console.WriteLine("Resultado: {0}", menor);
}
}
}

Exemplo 8 – Valor e índice do menor valor do vetor

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
 {
int[] v = new int[] { 3, 7, 4, 9, 2, 6, 7, 8, 9, 2 };
int posMenor = 0;
for (int i = 0; i < v.Length; i++)
{
if (v[i] < v[posMenor])
posMenor = i;
}
Console.WriteLine("Resultado: Valor: {0}, Índice: {1}", v[posMenor], posMenor);
}
}
}
Existem vários algoritmos de ordenação de vetores, sendo os mais conhecidos:
• insertion sort;
• selection sort;
• o bubble sort;
• merge sort;
• quick sort.
Na resolução deste exercício utilizou-se o algoritmo de “ordenação por seleção”
(selection sort), que pesquisa pelo valor mais pequeno do vetor e o coloca no índice 0,
depois pesquisa novamente o valor mais pequeno e coloca na posição 1 e assim
sucessivamente até chegar ao fim do vetor.

Exemplo 9 – Ordenar ascendentemente um vetor

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] v = new int[] { 3, 7, 4, 9, 2, 6, 7, 8, 9, 2 };
for (int i = 0; i < v.Length; i++)
{
int iMenor = i;
for (int j = i + 1; j < v.Length; j++)
{
if (v[j] < v[iMenor])
{
iMenor = j;
}
 }
int aux = v[i];
v[i] = v[iMenor];
v[iMenor] = aux;
}
Console.Write("Resultado: ");
for (int i = 0; i < v.Length; i++)
{
Console.Write("{0} ", v[i]);
}
Console.WriteLine();
}
}
}

Copiar vetores
A primeira tentação para a resolução deste problema poderia ser a de igualar o vetor b
ao vetor a. No entanto, dado os vetores serem um tipo referenciado o que iria
acontecer era que ambos ficariam a apontar para a mesma zona de memória e
qualquer alteração num deles afetaria o outro. Assim, é necessário executar um ciclo
para copiar cada um dos elementos do vetor a para o vetor b. As implementações
abaixo mostram o que acontece na primeira situação e na segunda.

Exemplo 10 – Copiar um vetor

Versão 1 –
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] b = new int[a.Length];

b = a;
//Se alterar o valor em a vai aparecer alterado em b
//Trata-se por isso do mesmo valor e não de uma copia
a[0] = 10;
Console.WriteLine("a[0]:{0} b[0]:{1}", a[0], b[0]);
}
 }
}

Versão 2 –
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] b = new int[a.Length];

//Ciclo para copiar todos os elementos

for (int i = 0; i < a.Length; i++)
{
b[i] = a[i];
}
//O vetor b e uma copia do vetor a
//Se alterar o valor em a já não vai aparecer alterado em b
a[0] = 10;
Console.WriteLine("a[0]:{0} b[0]:{1}", a[0], b[0]);
}
}
}

Ciclo foreach
A instrução foreach permite percorrer os elementos de uma matriz. Esta iteração é
feita pela ordem dos números existentes na matriz. É uma forma fácil de percorrer
todos os elementos sem ter de saber a dimensão da matriz.

Sintaxe:
foreach (<tipo_de_dados> <variavel> in <expressão>)
<bloco_de_instrucoes>

using System;
namespace ConsoleApp1
{
class Program
{
 static void Main(string[] args)
{
int[] v = { 23, 24, 25, 26, 27, 13, 14, 15, 16, 17 };
foreach (int num in v)
{
Console.WriteLine(num);
}
}
}
}

Matrizes
A semelhança dos vetores ou matrizes unidimensionais, cada elemento é identificado
com um nome e os seus índices na matriz, que no caso de ter duas dimensões, utiliza
dois índices, um para as linhas, que se costuma identificar pela letra i e outro para as
colunas que se costuma identificar pela letra j
Tal como já foi referido anteriormente as matrizes ocupam espaços contíguos na
memória.

Sintaxe:
<tipo_de_dados> [,] <nome_da_matriz>;
Matriz “a” de inteiros
int [,] a;
A inicialização das matrizes é semelhante à dos vetores, mas com a indicação das
várias dimensões.
Sintaxe:
<tipo_de_dados> [,] <nome_da_matriz> = new tipo_de_dados [dimensao1,
dimensao2, ..., dimensaon];

<tipo_de_dados> [,] <nome_da_matriz> = new tipo_de_dados [dimensao1,

dimensao2, ..., dimensaon] {valor1, valor2, ..., valorn};
<tipo_de_dados> [,] <nome_da_matriz> = new tipo_de_dados [, , ..., ] {{valor1,
valor2, ..., valorn}, …, {valor1, valor2, ..., valorn}};
<tipo_de_dados> [,] <nome_da_matriz> = {{valor1, valor2, ..., valorn}, …,
{valor1, valor2, ..., valorn}};
Exemplo de inicialização de uma matriz 3x4, sem valores inicias:
int [,] m = new int [3, 4];
Exemplos de inicialização de uma matriz 3x2 com os seguintes 6 valores iniciais
1,2,3,4,5 e 6:
int [,] m = new int [3, 2] {{1, 2}, {3, 4}, {5, 6}};
int [,] m = new int [,] {{1, 2}, {3, 4}, {5, 6}};
int [,] m = {{1, 2}, {3, 4}, {5, 6}};

Exemplo 1 – Leitura e escrita de valores numa matriz

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int[,] m = new int[3, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
Console.WriteLine(m[2, 1]); //Mostra o elemento 6
 Console.Write("Insira um valor para o primeiro indice:");
m[0, 0] = Convert.ToInt32(Console.ReadLine());
Console.WriteLine(m[0, 0]); //Mostra o valor inserido
}
}
}

Exemplo 2 – Leitura e escrita de uma matriz de inteiros

using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.Write("Quantas linhas deseja para a matriz:");
int l = Convert.ToInt32(Console.ReadLine());
Console.Write("Quantas colunas deseja para a matriz:");
int c = Convert.ToInt32(Console.ReadLine());
int[,] m = new int[l,c];
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++)
{
Console.Write("Insira um número para a linha {0}, coluna {1}:", i+1, j+1);
m[i,j] = Convert.ToInt32(Console.ReadLine());
}
for (int i = 0; i < l; i++)
{
for (int j = 0; j < c; j++)
 {
Console.WriteLine("Valor na linha {0}, coluna {1}: {2}", i+1, j+1, m[i,j]);
}
}
Console.ReadLine();
}
}

Exemplo 3 – Apresentar todos os elementos da matriz – conhecendo o nº de linhas e

colunas
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
int lins = 2, cols = 3, i, j;
int[,] m = { { 1, 2, 3 }, { 4, 5, 6 } };
for (i = 0; i < lins; i++)
{
for (j = 0; j < cols; j++)
Console.Write("{0} ", m[i, j]);
Console.WriteLine();
}
}
}
}
Exemplo 3 – Apresentar todos os elementos da matriz – não conhecendo o nº de
linhas e colunas
using System;
namespace ConsoleApp1
{
class Program
{

static void Main(string[] args)

{
int i, j;
int[,] m = { { 1, 2, 3 }, { 4, 5, 6 } };
for (i = 0; i < m.GetLength(0); i++)
{
for (j = 0; j < m.GetLength(1); j++)
Console.Write("{0} ", m[i, j]);
Console.WriteLine();
}
}
}
}