Arrays constituem uma das estruturas de dados mais simples em programação e sem dúvida uma das mais importantes, senão a mais importante.
Basicamente arrays são coleções de elementos (primitivos, compostos ou objetos) estruturados de tal forma que cada um dos elementos possa ser identificado por, pelo menos, um índice ou uma chave.
1. A Memória RAM do Computador
Antes de falar sobre a criação e manipulação de arrays vou descrever como um array se comporta fisicamente, isto é, como um array é manipulado na memoria do computador.
Toda informação temporária de um computador é armazenada na memória RAM a qual é gerenciada pelo sistema operacional. Pense na RAM como uma “estante” com diversas “gavetas” onde cada uma dessas gavetas pode armazenar um único tipo de conteúdo.
Ao criarmos um array solicitamos ao sistema operacional uma certa quantidade de “gavetas” fazendo com que o SO procure por um conjunto de gavetas contínuas e desocupadas entre todas as gavetas da estante, uma vez que encontrar o SO nos devolverá o endereço da primeira gaveta o qual chamamos de elemento 0. Se por alguma razão o SO não conseguir encontrar um conjunto continuo e livre de gavetas o mesmo retornará uma mensagem de erro.
Uma vez tendo em mãos o endereço da primeira gaveta e sabendo que as demais estão alocadas de forma contínua, para descobrir o endereço da n-ésima gaveta basta somarmos o endereço da primeira gaveta com o índice da “gaveta” que desejamos encontrar.
Por exemplo, suponha que o endereço da primeira gaveta corresponda ao valor 23 e buscamos pela 3º gaveta a qual terá seu índice igual 2 (lembre-se que a primeira gaveta está no índice 0), basta somarmos o índice 2 ao endereço 23 obtendo assim 25 que corresponde ao endereço da gaveta que buscamos.
2. A Estrutura de um Array
Um array é formado por um bloco contínuo de memória onde cada elemento está associado à um índice começando por 0. Dessa forma podemos buscar facilmente por um determinado elemento passando como referência a posição que o mesmo se encontra no array.
Na prática um array nada mais é do que uma coleção de objetos de um mesmo tipo o que permite um código melhor estruturado e reduzido.
3. Arrays Unidimensionais
Também chamados de vetores os arrays unidimensionais são as coleções mais simples em programação e consistem em um bloco continuo de valores que podem ser indexados através de uma única variável.
3.1. Criando Vetores
Para criarmos um vetor precisamos definir um nome, um tipo de dado e o número de elementos mesmo que de forma implícita, isto é, em algumas linguagens como Python e PHP que fazem uso de tipagem fraca o tipo de dado é definido em tempo de execução através das características dos elementos que estamos atribuindo e portanto não precisamos definir um tipo de dado de forma explicita mas mesmo assim ele está lá.
Podemos então criar um vetor vazio e ir preenchendo os elementos com o decorrer do programa:
tipo nome [numero de elementos]; tipo nome[10]; //Vetor Vazio com Capacidade para 10 Elementos Indexados de 0 à 9.
Ou podemos criar um vetor com os seus elementos já preenchidos:
tipo nome[ ] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; //Vetor Criado com 10 elementos.
Note que ao criar um vetor a partir de seus elementos não precisamos definir o tamanho do vetor de forma explicita pois o mesmo será definido levando em consideração os elementos passados.
Dependendo da linguagem a sintaxe pode sofrer alterações, para entender melhor as diferenças observe os exemplos na seção 3.3.
3.2. Indexando Vetores
Podemos usar a indexação tanto para atribuir valores quanto para ler valores referentes a um índice.
Para atribuir um valor basta indicar o nome do vetor e passar o índice referente à posição no vetor.
nome[indice] = 10; // Atribuímos o valor 10 a um determinado índice no vetor; nome[3] = 10; // Atribuímos o valor 10 ao elemento de índice 3 no vetor.
Agora para a leitura de valores podemos realizar a indexação de um único elemento ou de um conjunto de elementos.
Para um único elemento basta indicarmos o nome do vetor e então passarmos o índice referente ao elemento ao qual desejamos buscar atribuindo o resultado a alguma variável ou objeto.
resultado = nome[indice];
Quando desejamos um conjunto de valores o mais comum é utilizarmos uma estrutura de repetição no qual definimos o elemento inicial, o elemento final e um incremento a fim de percorrermos o vetor.
Perceba que como o primeiro elemento do vetor se encontra no índice 0, o índice do último elemento pode ser encontrado subtraindo 1 unidade do numero total de elementos, isto é, se o vetor tem 10 elementos o primeiro índice será 0 e o último será 9. Por essa razão a instrução “indice < array.length” torna-se necessária no laço de repetição.
3.3. Imprimindo os Elementos de um Vetor
Observe os exemplos referentes a criação e manipulação de vetores. Aconselho que leia, execute e realize algumas alterações com o objetivo de entender ao máximo a estrutura.
No primeiro exemplo inicialmente criamos dois vetores sendo o primeiro com seus valores pré definidos e o segundo sem elementos com a finalidade de preenchermos os valores posteriormente.
Na sequência preenchemos os elementos do vetor vazio com os números de 0 à 9 e então realizamos a impressão de todos os elementos de ambos os vetores.
Já no segundo exemplo criamos um vetor a partir das informações inseridas pelo usuário. Dessa forma o usuário deve informar o número de elementos e os valores referente a cada elemento. Ao final o programa realizará a impressão de todos os elementos do vetor.
Em algumas linguagens iremos usar a função “length” a qual tem por objeto obter o número de elementos do vetor, entretanto essa função pode ser substituída por um valor numérico desde que se saiba previamente o número de elementos do vetor.
Java
Exemplo 1
/**
Exemplo 1 - Criando um vetor a partir de seus elementos pré
definidos e outro vazio realizando a impressão de ambos ao
final.
**/
class Main {
public static void main(String[] args) {
//Criando Vetor com 10 Elementos Pré Definidos
int vetorPreDefinido[] = {0,1,2,3,4,5,6,7,8,9};
//Criando Vetor Vazio com Capacidade para 10 Elementos
int vetorVazio[] = new int[10];
//Preenchendo os Elementos do Vetor Vazio
for(int indice = 0; indice < vetorVazio.length; indice++){
vetorVazio[indice] = indice;
}
System.out.printf("Imprimindo os Elementos do Vetor Pré Definido:\n");
for(int indice = 0; indice < vetorVazio.length; indice++){
System.out.printf("%d ", vetorPreDefinido[indice]);
}
System.out.println("\n");
System.out.print("Imprimindo os Elementos do Vetor Vazio:\n");
for(int indice = 0; indice < vetorVazio.length; indice++){
System.out.printf("%d ", vetorVazio[indice]);
}
System.out.println();
}
}Exemplo 2
/**
Exemplo 2 - Criando um vetor a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Insira o Número de Elementos");
int numeroDeElementos = input.nextInt();
int vetor[] = new int[numeroDeElementos];
System.out.printf("Insira %d Elementos separados por espaços\n", numeroDeElementos);
for(int indice = 0; indice < vetor.length; indice++){
vetor[indice] = input.nextInt();
}
System.out.printf("Imprimindo os Elementos do Vetor\n");
for(int indice = 0; indice < vetor.length; indice++){
System.out.printf("%d ", vetor[indice]);
}
System.out.println();
}
}C
Exemplo 1
/**
Exemplo 1 - Criando um vetor a partir de seus elementos pré
definidos e outro vazio realizando a impressão de ambos ao
final.
**/
#include <stdio.h>
int main(void){
//Criando Vetor com 10 Elementos Pré Definidos
int vetorPreDefinido[] = {0,1,2,3,4,5,6,7,8,9};
//Criando Vetor Vazio com Capacidade para 10 Elementos
int vetorVazio[10];
//Preenchendo os Elementos do Vetor Vazio
for(int indice = 0; indice < 10; indice++){
vetorVazio[indice] = indice;
}
printf("Imprimindo os Elementos do Vetor Pré Definido:\n");
for(int indice = 0; indice < 10; indice++){
printf("%d ", vetorPreDefinido[indice]);
}
printf("\n");
printf("Imprimindo os Elementos do Vetor Vazio:\n");
for(int indice = 0; indice < 10; indice++){
printf("%d ", vetorVazio[indice]);
}
printf("\n");
}Exemplo 2
/**
Exemplo 2 - Criando um vetor a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
#include <stdio.h>
int main(void){
printf("Insira o Número de Elementos\n");
int numeroDeElementos;
scanf("%d", &numeroDeElementos);
int vetor[numeroDeElementos];
printf("Insira %d Elementos separados por espaços\n", numeroDeElementos);
for(int indice = 0; indice < numeroDeElementos; indice++){
scanf("%d", &vetor[indice]);
}
printf("Imprimindo os Elementos do Vetor\n");
for(int indice = 0; indice < numeroDeElementos; indice++){
printf("%d ", vetor[indice]);
}
printf("\n");
}C++
Exemplo 1
/**
Exemplo 1 - Criando um vetor a partir de seus elementos pré
definidos e outro vazio realizando a impressão de ambos ao
final.
**/
#include <iostream>
using namespace std;
int main(void){
//Criando Vetor com 10 Elementos Pré Definidos
int vetorPreDefinido[] = {0,1,2,3,4,5,6,7,8,9};
//Criando Vetor Vazio com Capacidade para 10 Elementos
int vetorVazio[10];
//Preenchendo os Elementos do Vetor Vazio
for(int indice = 0; indice < 10; indice++){
vetorVazio[indice] = indice;
}
printf("Imprimindo os Elementos do Vetor Pré Definido:\n");
for(int indice = 0; indice < 10; indice++){
cout << vetorPreDefinido[indice] << " ";
}
printf("\n");
cout << "Imprimindo os Elementos do Vetor Vazio:\n";
for(int indice = 0; indice < 10; indice++){
cout << vetorVazio[indice] << " ";
}
cout << "\n";
}Exemplo 2
/**
Exemplo 2 - Criando um vetor a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
#include <iostream>
using namespace std;
int main(void){
cout << "Insira o Número de Elementos\n";
int numeroDeElementos;
cin >> numeroDeElementos;
int vetor[numeroDeElementos];
cout << "Insira " << numeroDeElementos << " Elementos separados por espaços\n";
for(int indice = 0; indice < numeroDeElementos; indice++){
cin >> vetor[indice];
}
cout << "Imprimindo os Elementos do Vetor\n";
for(int indice = 0; indice < numeroDeElementos; indice++){
cout << vetor[indice] << " ";
}
cout << "\n";
}Python
Exemplo 1
'''
Exemplo 1 - Criando uma vetor com 12 elementos
e realizando a impressão com a função print().
'''
''' ---------------------------------------------------'''
print("Exemplo 1:")
vetor1 = (1,2,3,4,5,6,7,8,9,10,11,12)
print(vetor1)Exemplo 2
'''
Exemplo 2 - Criando uma vetor com 12 elementos
e realizando a impressão com laços de repetição.
'''
''' ---------------------------------------------------'''
print("Exemplo 2:")
vetor2 = (1,2,3,4,5,6,7,8,9,10,11,12)
for indice in range(len(vetor2)):
print(vetor2[indice])Exemplo 3
'''
Exemplo 3 - Criando um vetor com 12 elementos usando
o pacote NumPy e realizando a impressão de seus elementos
'''
''' ---------------------------------------------------'''
print("Exemplo 3:")
import numpy as np
vetor3 = np.array((1,2,3,4,5,6), dtype=np.int)
print(vetor3)Exemplo 4
'''
Exemplo 4 - Criando um vetor com 12 elementos vazio
com o pacote NumPy.
'''
''' ---------------------------------------------------'''
print("Exemplo 4:")
vetor4 = np.zeros((12), dtype=np.int)
print(vetor4)Exemplo 5
print("Exemplo 5:")
indiceDoNumeroDelinhas = 0
indiceDoNumeroDecolunas = 1
print("Insira número de elementos do vetor")
numeroDeElementos = int(input())
vetor5 = np.zeros((numeroDeElementos), dtype=np.int)
print("Insira os %d elementos do vetor com cada valor em uma nova linha:" % numeroDeElementos)
for indice in range(len(vetor5)):
vetor5[indice] = int(input())
print(vetor5)Arduino
Exemplo 1
/**
Exemplo 1 - Criando um vetor a partir de seus elementos pré
definidos e outro vazio realizando a impressão de ambos ao
final.
**/
void setup() {
Serial.begin(9600);
}
void loop() {
//Criando Vetor com 10 Elementos Pré Definidos
int vetorPreDefinido[] = {0,1,2,3,4,5,6,7,8,9};
//Criando Vetor Vazio com Capacidade para 10 Elementos
int vetorVazio[10];
//Preenchendo os Elementos do Vetor Vazio
for(int indice = 0; indice < 10; indice++){
vetorVazio[indice] = indice;
}
Serial.print("Imprimindo os Elementos do Vetor Pré Definido:\n");
for(int indice = 0; indice < 10; indice++){
Serial.print(vetorPreDefinido[indice]);
Serial.print(" ");
}
Serial.print("\n");
Serial.print("Imprimindo os Elementos do Vetor Vazio:\n");
for(int indice = 0; indice < 10; indice++){
Serial.print(vetorVazio[indice]);
Serial.print(" ");
}
Serial.print("\n");
while(true);
}4. Arrays Bidimensionais
Também chamados de matrizes, os arrays bidimensionais são coleções de elementos organizados em duas dimensões e podem ser interpretados como tabelas. Isso significa que, nessa organização e diferentemente de como era com os vetores, torna-se necessário a utilização de duas variáveis de indexação.
A matriz é muito usada quando precisamos cruzar duas informações distintas mas com uma relação entre si como por exemplo associar “C” notas a uma turma de “L” alunos.
4.1. Criando Matrizes
Assim como ocorre com os vetores para criarmos matrizes também precisamos atribuir um nome, um tipo e o número de elementos. Entretanto ao invés de um único índice precisamos atribuir dois referentes as linhas e colunas.
Para um vetor vazio de tamanho fixo devemos fazer:
tipo nome[linha][coluna]; //Matriz Vazia com linha*coluna elementos. tipo nome[5][4]; //Matriz Vazia com Capacidade para 20 Elementos.
Ou para criarmos uma matriz com seus elementos pré definidos devemos fazer:
tipo nome[ ][ ] = {{1, 2, 3},
{4, 5, 6},
{7, 8, 8}
};
//Matriz Quadrada Criada com 3x3 Elementos.
4.2. Indexando Matrizes
Cada elemento de uma matriz está associado a um tupla (dupla de elementos na forma (a , b) onde ‘a’ representa o índice da linha e ‘b’ o índice da coluna) de elementos, portanto podemos indexar cada elemento individualmente passando valores literais ou indexar um grupo de elementos através de uma estrutura de repetição a fim de de atribuir ou ler valores.
Para atribuir um valor basta indicarmos o nome da matriz e passarmos os índices referentes a posição na linha e coluna.
nome[linha][coluna] = 10; // Atribuímos o valor 10 a um determinado elemento; nome[3][2] = 10; // Atribuímos o valor 10 ao elemento de índice (3,2) na matriz.
Agora para lermos um valor podemos indexar um elemento em específico indicando o nome da matriz junto da linha e coluna correspondente atribuindo o resultado a uma variável ou objeto.
resultado = nome[linha][coluna]
Por outro lado se desejamos indexar um grupo de elementos em específico podemos fazer uso de laços aninhados através de duas estruturas “FOR” onde o laço externo será responsável por percorrer as linhas e o laço interno por percorrer as colunas.
Perceba que como o primeiro elemento tanto da linha quanto da coluna começam pelo índice 0, o índice do último elemento pode ser encontrado subtraindo 1 unidade do numero total de linha e colunas, isto é, se a matriz tem 4×4 elementos o primeiro índice da linha assim como da coluna será 0 e o ultimo será 3. Por está razão torna-se necessário as instruções “linha < array.length” e “coluna < array[linha].length” no laço aninhado.
4.3. Imprimindo os Elementos de uma Matriz
Observe os exemplos referentes a criação e manipulação de matrizes. Aconselho que leia, execute e realize algumas alterações com o objetivo de entender ao máximo esta estrutura.
No primeiro exemplo inicialmente criamos duas matrizes sendo um com seus valores pré definidos e outra vazia com a finalidade de preencher os valores posteriormente.
Na sequência preenchemos os elementos da matriz vazia com os números de 0 à 9 e então realizamos a impressão dos elementos das duas matrizes.
Já no segundo exemplo criamos uma matriz a partir das informações inseridas pelo usuário. Dessa forma o usuário deve informar inicialmente o número de linhas, colunas e os valores referente a cada elemento. O número de elementos é calculado a partir do produto entre número total de linhas e colunas. Ao final o programa realizará a impressão de todos os elementos da matriz.
Em algumas linguagens iremos usar a função “length” a qual tem por objeto obter o número de elementos de cada linha da matriz, entretanto essa função pode ser substituída por um valor numérico desde que se saiba previamente o número de elementos de cada linha da matriz.
Note que em Python mesmo que nativamente existam arrays o mais comum é utilizar uma biblioteca especifica está tarefa. Para saber mais sobre essa biblioteca leia o artigo de nome “Pacote NumPy” disponibilizado neste blog.
Java
Exemplo 1
/**
Exemplo 1 - Criando uma matriz a partir de seus elementos pré
definidos e outra vazia realizando a impressão de ambos ao
final.
**/
class Main {
public static void main(String[] args) {
//Criando Matriz com 12 Elementos Pré Definidos
int matrizPreDefinida[][] = {{1 ,2 ,3 ,4},
{5 ,6 ,7 ,8},
{9 ,10,11,12}};
//Criando Matriz Vazia com Capacidade para 12 Elementos
int matrizVazia[][] = new int[3][4];
//Preenchendo os Elementos da Matriz Vazia
int valores = 0;
for(int linha = 0; linha < matrizVazia.length; linha++){
for(int coluna = 0; coluna < matrizVazia[linha].length; coluna++){
matrizVazia[linha][coluna] = valores;
++valores;
}
}
System.out.printf("\nImprimindo os Elementos da Matriz Pré Definida: \n");
for(int linha = 0; linha < matrizPreDefinida.length; linha++){
for(int coluna = 0; coluna < matrizPreDefinida[linha].length; coluna++){
System.out.printf("%d ", matrizPreDefinida[linha][coluna]);
}
System.out.println();
}
System.out.println("\n");
System.out.print("Imprimindo os Elementos da Matriz Vazia: \n");
for(int linha = 0; linha < matrizVazia.length; linha++){
for(int coluna = 0; coluna < matrizVazia[linha].length; coluna++){
System.out.printf("%d ", matrizVazia[linha][coluna]);
}
System.out.println();
}
}
}Exemplo 2
/**
Exemplo 2 - Criando uma matriz a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Insira o Número de Linhas e Colunas Separado por Espaço");
int numeroDeLinhas = input.nextInt();
int numeroDeColunas = input.nextInt();
int matriz[][] = new int[numeroDeLinhas][numeroDeColunas];
System.out.printf("Insira os %d Elementos separados por espaços\n", numeroDeLinhas*numeroDeColunas);
for(int linha = 0; linha < matriz.length; linha++){
for(int coluna = 0; coluna < matriz[linha].length; coluna++){
matriz[linha][coluna] = input.nextInt();
}
}
System.out.printf("Imprimindo os Elementos da Matriz:\n");
for(int linha = 0; linha < matriz.length; linha++){
for(int coluna = 0; coluna < matriz[linha].length; coluna++){
System.out.printf("%d ", matriz[linha][coluna]);
}
System.out.println();
}
}
}C
Exemplo 1
/**
Exemplo 1 - Criando uma matriz a partir de seus elementos pré
definidos e outra vazia realizando a impressão de ambos ao
final.
**/
#include <stdio.h>
int main(void) {
//Criando Matriz com 12 Elementos Pré Definidos
int matrizPreDefinida[3][4] = {{1 ,2 ,3 ,4},
{5 ,6 ,7 ,8},
{9 ,10,11,12}};
//Criando Matriz Vazia com Capacidade para 12 Elementos
int matrizVazia[3][4];
//Preenchendo os Elementos da Matriz Vazia
int valores = 0;
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
matrizVazia[linha][coluna] = valores;
++valores;
}
}
printf("Imprimindo os Elementos da Matriz Pré Definida: \n");
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
printf("%d ", matrizPreDefinida[linha][coluna]);
}
printf("\n");
}
printf("\n");
printf("Imprimindo os Elementos da Matriz Vazia: \n");
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
printf("%d ", matrizVazia[linha][coluna]);
}
printf("\n");
}
}Exemplo 2
/**
Exemplo 2 - Criando uma matriz a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
#include <stdio.h>
int main(void) {
printf("Insira o Número de Linhas e Colunas Separado por Espaço\n");
int numeroDeLinhas, numeroDeColunas;
scanf("%d%d", &numeroDeLinhas, &numeroDeColunas);
int matriz[numeroDeLinhas][numeroDeColunas];
printf("Insira os %d Elementos separados por espaços\n", numeroDeLinhas*numeroDeColunas);
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
scanf("%d", &matriz[linha][coluna]);
}
}
printf("Imprimindo os Elementos da Matriz:\n");
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
printf("%d ", matriz[linha][coluna]);
}
printf("\n");
}
}C++
Exemplo 1
/**
Exemplo 1 - Criando uma matriz a partir de seus elementos pré
definidos e outra vazia realizando a impressão de ambos ao
final.
**/
#include <iostream>
using namespace std;
int main(void) {
//Criando Matriz com 12 Elementos Pré Definidos
int matrizPreDefinida[3][4] = {{1 ,2 ,3 ,4},
{5 ,6 ,7 ,8},
{9 ,10,11,12}};
//Criando Matriz Vazia com Capacidade para 12 Elementos
int matrizVazia[3][4];
//Preenchendo os Elementos da Matriz Vazia
int valores = 0;
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
matrizVazia[linha][coluna] = valores;
++valores;
}
}
cout << "Imprimindo os Elementos da Matriz Pré Definida: \n";
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
cout << matrizPreDefinida[linha][coluna] << " ";
}
cout << "\n";
}
cout << "\n" << "Imprimindo os Elementos da Matriz Vazia: \n";
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
cout << matrizVazia[linha][coluna] << " ";
}
cout << "\n";
}
}Exemplo 2
/**
Exemplo 2 - Criando uma matriz a partir das informações inseridas
pelo usuário e imprimindo os seus elementos ao final.
**/
#include <iostream>
using namespace std;
int main(void) {
cout << "Insira o Número de Linhas e Colunas Separado por Espaço\n";
int numeroDeLinhas, numeroDeColunas;
cin >> numeroDeLinhas >> numeroDeColunas;
int matriz[numeroDeLinhas][numeroDeColunas];
cout << "Insira os " << numeroDeLinhas*numeroDeColunas << " Elementos separados por espaços\n";
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
cin >> matriz[linha][coluna];
}
}
cout << "Imprimindo os Elementos da Matriz:\n";
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
cout << matriz[linha][coluna] << " ";
}
cout << "\n";
}
}Python
Exemplo 1
'''
Exemplo 1 - Criando uma matriz 3x4 com 12 elementos
e realizando a impressão com a função print().
'''
''' ---------------------------------------------------'''
print("Exemplo 1:")
matriz1 = [[1 ,2 ,3 , 4],
[5 ,6 , 7, 8],
[9 ,10,11,12]]
print(matriz1)Exemplo 2
'''
Exemplo 2 - Criando uma matriz 3x4 com 12 elementos
e realizando a impressão com laços de repetição.
'''
''' ---------------------------------------------------'''
print("Exemplo 2:")
matriz2 = [[1 ,2 ,3 , 4],
[5 ,6 , 7, 8],
[9 ,10,11,12]]
for linha in range(len(matriz2)):
for coluna in range(len(matriz2[linha])):
print(matriz2[linha][coluna], end=" ")
print("\n")Exemplo 3
'''
Exemplo 3 - Criando uma matriz a partir de uma lista
de listas.
'''
''' ---------------------------------------------------'''
print("Exemplo 3:")
matriz3 = []
for indice in range (4):
linha = []
for coluna in range(4):
linha.append(0)
matriz3.append(linha)
print(matriz3)
for linha in range(len(matriz3)):
for coluna in range(len(matriz3[linha])):
print(matriz3[linha][coluna], end=" ")
print("\n")Exemplo 4
'''
Exemplo 4 - Criando uma matriz 3x4 com o pacote NumPy
e realizando a impressão de seus elementos
'''
''' ---------------------------------------------------'''
print("Exemplo 4:")
import numpy as np
matriz4 = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]], dtype=np.int)
print(matriz4)Exemplo 5
'''
Exemplo 5 - Criando uma matriz 5x5 vazia com o pacote
NumPy.
'''
''' ---------------------------------------------------'''
print("Exemplo 5:")
matriz5 = np.zeros((5,5), dtype=np.int)
print(matriz5)Exemplo 6
'''
Exemplo 6 - Criando uma matriz a partir de informações
do usuário.
'''
''' ---------------------------------------------------'''
print("Exemplo 6:")
indiceDoNumeroDelinhas = 0
indiceDoNumeroDecolunas = 1
print("Insira o valor da linha e da coluna separado por espaço:")
indices = list(map(int, input().split()))
matriz6 = np.zeros((indices[indiceDoNumeroDelinhas],indices[indiceDoNumeroDecolunas]), dtype=np.int)
print("Insira os %d elementos da matriz com cada valor em uma nova linha:" % (indices[indiceDoNumeroDelinhas]*indices[indiceDoNumeroDecolunas]))
for linha in range(len(matriz6)):
for coluna in range(len(matriz6[linha])):
matriz6[linha][coluna] = int(input())
print(matriz6)Arduino
Exemplo 1
/**
Exemplo 1 - Criando uma matriz a partir de seus elementos pré
definidos e outra vazia realizando a impressão de ambos ao
final.
**/
void setup() {
Serial.begin(9600);
}
void loop() {
//Criando Matriz com 12 Elementos Pré Definidos
int matrizPreDefinida[3][4] = {{1 ,2 ,3 ,4},
{5 ,6 ,7 ,8},
{9 ,10,11,12}};
//Criando Matriz Vazia com Capacidade para 12 Elementos
int matrizVazia[3][4];
//Preenchendo os Elementos da Matriz Vazia
int valores = 0;
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
matrizVazia[linha][coluna] = valores;
++valores;
}
}
Serial.print("Imprimindo os Elementos da Matriz Pré Definida: \n");
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
Serial.print(matrizPreDefinida[linha][coluna]);
Serial.print(" ");
}
Serial.print("\n");
}
Serial.print("\n");
Serial.print("Imprimindo os Elementos da Matriz Vazia: \n");
for(int linha = 0; linha < 3; linha++){
for(int coluna = 0; coluna < 4; coluna++){
Serial.print(matrizVazia[linha][coluna]);
Serial.print(" ");
}
printf("\n");
}
while(true);
}5. Arrays Tridimensionais
Outro tipo de array muito comum é aquele em três dimensões o qual além de linhas e colunas também existe um índice referente a profundidade. Devido a estarem geralmente relacionados com problemas de sólidos 3d esses índices também costumam ser chamado de altura, largura e profundidade.
O número de elementos assim como ocorre com 2 dimensões pode ser encontrado realizando o produto das três dimensões (linhas * colunas * profundidade).
Não pretendo me estender demais nesse tipo de array pois se você entendeu como criar e manipular arrays em uma e duas dimensões não terá problema algum para trabalhar com três dimensões. Tanto a criação quanto manipulação é exatamente igual bastando aumentar os índices e laços aninhados.
5.1. Criando Arrays em 3 Dimensões
Assim como para uma e duas dimensões podemos criar arrays vazios da seguinte forma:
tipo nome[linha][coluna][profundidade]; // Array em 3 Dimensões Vazio; tipo nome[2][2][3]; // Array em 3 Dimensões com Capacidade para 12 elementos.
Ou podemos criar arrays com elementos pré definidos:
tipo nome[ ][ ][ ] = {
{
{1, 2},
{3, 4}
},
{
{5, 8},
{7, 8}
},
{
{9, 10},
{11, 12}
{
};
// Array criado com 12 elementos de dimensão 2x2x3.
5.2. Imprimindo Arrays Tridimensionais
Observe os exemplos baixo referentes a criação e manipulação de arrays tridimensionais. Aconselho que leia, execute e realize algumas alterações com o objetivo de entender ao máximo está estrutura.
No primeiro exemplo inicialmente criamos dois arrays sendo um com seus valores pré definidos e outro vazio com a finalidade de preencher os valores posteriormente.
Na sequência preenchemos os elementos do array vazio com os números de 0 à 12 e então realizamos a impressão dos elementos dos dois arrays.
Já no segundo exemplo criamos um array a partir das informações inseridas pelo usuário. Dessa forma o usuário deve informar inicialmente o valor da profundidade e o número de linhas, colunas e os valores referente a cada elemento. O número de elementos é calculado a partir do produto entre número total de linhas e colunas e a profundidade. Ao final o programa realizará a impressão de todos os elementos do array.
Em algumas linguagens iremos usar a função “length” a qual tem por objeto obter o número de elementos de cada linha do array, entretanto essa função pode ser substituída por um valor numérico desde que se saiba previamente o número de elementos de cada linha do array.
Estamos usando o pacote NumPy para manipulação de arrays multidimensionais em Python. Em caso de dúvidas consulte o artigo que descreve tal biblioteca.
Java
Exemplo 1
/**
Exemplo 1 - Criando um array em 3 dimesões a partir
de seus elementos pré definidos e outro vazio realizando
a impressão de ambos ao final.
**/
class Main {
public static void main(String[] args) {
//Criando Array em 3 Dimensões com 12 Elementos Pré Definidos
int array3DimensoesPreDefinido[][][] = {
{
{1, 2},
{3, 4}
},
{
{5, 8},
{7, 8}
},
{
{9, 10},
{11, 12}
}
};
//Criando Array em 3 Dimensões Vazia com Capacidade para 12 Elementos ([profundidade][linha][coluna])
int array3DimensoesVazio[][][] = new int[3][2][2];
//Preenchendo os Elementos do Array em 3 Dimensões Vazio
int valores = 0;
for(int profundidade = 0; profundidade < array3DimensoesVazio.length; profundidade++){
for(int linha = 0; linha < array3DimensoesVazio[profundidade].length; linha++){
for(int coluna = 0; coluna < array3DimensoesVazio[profundidade][linha].length; coluna++){
array3DimensoesVazio[profundidade][linha][coluna] = valores;
++valores;
}
}
}
System.out.printf("\nImprimindo os Elementos do Array em 3 Dimensões Pré Definido: \n");
for(int profundidade = 0; profundidade < array3DimensoesPreDefinido.length; profundidade++){
for(int linha = 0; linha < array3DimensoesPreDefinido[profundidade].length; linha++){
for(int coluna = 0; coluna < array3DimensoesPreDefinido[profundidade][linha].length; coluna++){
System.out.printf("%d ", array3DimensoesPreDefinido[profundidade][linha][coluna]);
}
System.out.println();
}
System.out.println();
}
System.out.print("Imprimindo os Elementos do Array em 3 Dimensões Vazio: \n");
for(int profundidade = 0; profundidade < array3DimensoesVazio.length; profundidade++){
for(int linha = 0; linha < array3DimensoesVazio[profundidade].length; linha++){
for(int coluna = 0; coluna < array3DimensoesVazio[profundidade][linha].length; coluna++){
System.out.printf("%d ", array3DimensoesVazio[profundidade][linha][coluna]);
}
System.out.println();
}
System.out.println();
}
}
}Exemplo 2
/**
Exemplo 2 - Criando um array em 3 dimensões a partir das
informações inseridas pelo usuário e imprimindo os seus
elementos ao final.
**/
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Insira a Profundidade o Número de Linhas e Colunas Separado por Espaço");
int valorProfundidade = input.nextInt();
int numeroDeLinhas = input.nextInt();
int numeroDeColunas = input.nextInt();
int array3Dimensoes[][][] = new int[valorProfundidade][numeroDeLinhas][numeroDeColunas];
System.out.printf("Insira os %d Elementos separados por espaços\n", valorProfundidade*numeroDeLinhas*numeroDeColunas);
for(int profundidade = 0; profundidade < array3Dimensoes.length; profundidade++){
for(int linha = 0; linha < array3Dimensoes[profundidade].length; linha++){
for(int coluna = 0; coluna < array3Dimensoes[profundidade][linha].length; coluna++){
array3Dimensoes[profundidade][linha][coluna] = input.nextInt();
}
}
}
System.out.printf("\nImprimindo os Elementos do Array em 3 Dimensões:\n");
for(int profundidade = 0; profundidade < array3Dimensoes.length; profundidade++){
for(int linha = 0; linha < array3Dimensoes[profundidade].length; linha++){
for(int coluna = 0; coluna < array3Dimensoes[profundidade][linha].length; coluna++){
System.out.printf("%d ", array3Dimensoes[profundidade][linha][coluna]);
}
System.out.println();
}
System.out.println();
}
}
}C
Exemplo 1
/**
Exemplo 1 - Criando um array em 3 dimesões a partir
de seus elementos pré definidos e outro vazio realizando
a impressão de ambos ao final.
**/
#include <stdio.h>
int main(void){
//Criando Array em 3 Dimensões com 12 Elementos Pré Definidos
int array3DimensoesPreDefinido[3][2][2] = {
{
{1, 2},
{3, 4}
},
{
{5, 8},
{7, 8}
},
{
{9, 10},
{11, 12}
}
};
//Criando Array em 3 Dimensões Vazia com Capacidade para 12 Elementos ([profundidade][linha][coluna])
int array3DimensoesVazio[3][2][2];
//Preenchendo os Elementos do Array em 3 Dimensões Vazio
int valores = 0;
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
array3DimensoesVazio[profundidade][linha][coluna] = valores;
++valores;
}
}
}
printf("Imprimindo os Elementos do Array em 3 Dimensões Pré Definido:\n");
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
printf("%d ", array3DimensoesPreDefinido[profundidade][linha][coluna]);
}
printf("\n");
}
printf("\n");
}
printf("Imprimindo os Elementos do Array em 3 Dimensões Vazio:\n");
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
printf("%d ", array3DimensoesVazio[profundidade][linha][coluna]);
}
printf("\n");
}
printf("\n");
}
}Exemplo 2
/**
Exemplo 2 - Criando um array em 3 dimensões a partir das
informações inseridas pelo usuário e imprimindo os seus
elementos ao final.
**/
#include <stdio.h>
int main(void){
printf("Insira a Profundidade o Número de Linhas e Colunas Separado por Espaço\n");
int valorProfundidade, numeroDeLinhas, numeroDeColunas;
scanf("%d%d%d", &valorProfundidade, &numeroDeLinhas,&numeroDeColunas);
int array3Dimensoes[valorProfundidade][numeroDeLinhas][numeroDeColunas];
printf("Insira os %d Elementos separados por espaços\n", valorProfundidade*numeroDeLinhas*numeroDeColunas);
for(int profundidade = 0; profundidade < valorProfundidade; profundidade++){
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
scanf("%d", &array3Dimensoes[profundidade][linha][coluna]);
}
}
}
printf("\nImprimindo os Elementos do Array em 3 Dimensões:\n");
for(int profundidade = 0; profundidade < valorProfundidade; profundidade++){
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
printf("%d ", array3Dimensoes[profundidade][linha][coluna]);
}
printf("\n");
}
printf("\n");
}
}C++
Exemplo 1
/**
Exemplo 1 - Criando um array em 3 dimesões a partir
de seus elementos pré definidos e outro vazio realizando
a impressão de ambos ao final.
**/
#include <iostream>
using namespace std;
int main(void){
//Criando Array em 3 Dimensões com 12 Elementos Pré Definidos
int array3DimensoesPreDefinido[3][2][2] = {
{
{1, 2},
{3, 4}
},
{
{5, 8},
{7, 8}
},
{
{9, 10},
{11, 12}
}
};
//Criando Array em 3 Dimensões Vazia com Capacidade para 12 Elementos ([profundidade][linha][coluna])
int array3DimensoesVazio[3][2][2];
//Preenchendo os Elementos do Array em 3 Dimensões Vazio
int valores = 0;
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
array3DimensoesVazio[profundidade][linha][coluna] = valores;
++valores;
}
}
}
printf("Imprimindo os Elementos do Array em 3 Dimensões Pré Definido:\n");
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
cout << array3DimensoesPreDefinido[profundidade][linha][coluna] << " ";
}
cout << "\n";
}
cout << "\n";
}
cout << "Imprimindo os Elementos do Array em 3 Dimensões Vazio:\n";
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
cout << array3DimensoesVazio[profundidade][linha][coluna] << " ";
}
cout << "\n";
}
cout << "\n";
}
}Exemplo 2
/**
Exemplo 2 - Criando um array em 3 dimensões a partir das
informações inseridas pelo usuário e imprimindo os seus
elementos ao final.
**/
#include <iostream>
using namespace std;
int main(void){
cout << "Insira a Profundidade o Número de Linhas e Colunas Separado por Espaço\n";
int valorProfundidade, numeroDeLinhas, numeroDeColunas;
cin >> valorProfundidade >> numeroDeLinhas >> numeroDeColunas;
int array3Dimensoes[valorProfundidade][numeroDeLinhas][numeroDeColunas];
cout << "Insira os " << (valorProfundidade*numeroDeLinhas*numeroDeColunas) << " Elementos separados por espaços\n";
for(int profundidade = 0; profundidade < valorProfundidade; profundidade++){
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
cin >> array3Dimensoes[profundidade][linha][coluna];
}
}
}
cout << "\nImprimindo os Elementos do Array em 3 Dimensões:\n";
for(int profundidade = 0; profundidade < valorProfundidade; profundidade++){
for(int linha = 0; linha < numeroDeLinhas; linha++){
for(int coluna = 0; coluna < numeroDeColunas; coluna++){
cout << array3Dimensoes[profundidade][linha][coluna] << " ";
}
cout << "\n";
}
cout << "\n";
}
}Python
Exemplo 1
'''
Exemplo 1 - Criando um array 3x2x2 com 12 elementos
e realizando a impressão com a função print().
'''
''' ---------------------------------------------------'''
print("Exemplo 1:")
array1 = [
[[1 , 2],[3 , 4]],
[[5 , 6],[7 , 8]],
[[9 ,10],[11 ,12]],
]
print(array1)Exemplo 2
'''
Exemplo 2 - Criando um array 3x2x2 com 12 elementos
e realizando a impressão com laços de repetição.
'''
''' ---------------------------------------------------'''
print("Exemplo 2:")
array2 = [
[[1 , 2],[3 , 4]],
[[5 , 6],[7 , 8]],
[[9 ,10],[11,12]],
]
for profundidade in range(len(array2)):
for linha in range(len(array2[profundidade])):
for coluna in range(len(array2[profundidade][linha])):
print(array2[profundidade][linha][coluna], end=" ")
print("\n")
print("\n")Exemplo 3
'''
Exemplo 3 - Criando um array a partir de uma lista
de listas.
'''
''' ---------------------------------------------------'''
print("Exemplo 3:")
array3 = []
for indiceProfundidade in range (3):
profundidade = []
for indiceLinha in range(2):
linha = []
for indiceColuna in range(2):
linha.append(0)
profundidade.append(linha)
array3.append(profundidade)
print(array3)
for profundidade in range(len(array3)):
for linha in range(len(array3[profundidade])):
for coluna in range(len(array3[profundidade][linha])):
print(array3[profundidade][linha][coluna], end=" ")
print("\n")
print("\n")Exemplo 4
'''
Exemplo 4 - Criando um array 3x2x2 com 12 elementos
usando o pacote NumPy e realizando a impressão de
seus elementos.
'''
''' ---------------------------------------------------'''
print("Exemplo 4:")
import numpy as np
array4 = np.array([
[[1 , 2],[3 , 4]],
[[5 , 6],[7 , 8]],
[[9 ,10],[11,12]]
]
, dtype=np.int)
print(array4)Exemplo 5
'''
Exemplo 5 - Criando um array 3x2x2 vazio com o pacote
NumPy.
'''
''' ---------------------------------------------------'''
print("Exemplo 5:")
array5 = np.zeros((3,2,2), dtype=np.int)
print(array5)Exemplo 6
'''
Exemplo 6 - Criando um array a partir de informações
do usuário.
'''
''' ---------------------------------------------------'''
print("\n")
''' ---------------------------------------------------'''
print("Exemplo 6:")
valorDaProfundidade = 0
indiceDoNumeroDelinhas = 1
indiceDoNumeroDecolunas = 2
print("Insira o valor da profundidade, da linha e da coluna separados por espaços:")
indices = list(map(int, input().split()))
array6 = np.zeros((indices[valorDaProfundidade],indices[indiceDoNumeroDelinhas],indices[indiceDoNumeroDecolunas]), dtype=np.int)
print("Insira os %d elementos do array com cada valor em uma nova linha:" % (indices[valorDaProfundidade]*indices[indiceDoNumeroDelinhas]*indices[indiceDoNumeroDecolunas]))
for profundidade in range(len(array6)):
for linha in range(len(array6[profundidade])):
for coluna in range(len(array6[profundidade][linha])):
array6[profundidade][linha][coluna] = int(input())
print(array6)Arduino
Exemplo 1
/**
Exemplo 1 - Criando um array em 3 dimesões a partir
de seus elementos pré definidos e outro vazio realizando
a impressão de ambos ao final.
**/
void setup() {
Serial.begin(9600);
}
void loop() {
//Criando Array em 3 Dimensões com 12 Elementos Pré Definidos
int array3DimensoesPreDefinido[3][2][2] = {
{
{1, 2},
{3, 4}
},
{
{5, 8},
{7, 8}
},
{
{9, 10},
{11, 12}
}
};
//Criando Array em 3 Dimensões Vazia com Capacidade para 12 Elementos ([profundidade][linha][coluna])
int array3DimensoesVazio[3][2][2];
//Preenchendo os Elementos do Array em 3 Dimensões Vazio
int valores = 0;
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
array3DimensoesVazio[profundidade][linha][coluna] = valores;
++valores;
}
}
}
Serial.print("Imprimindo os Elementos do Array em 3 Dimensões Pré Definido:\n");
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
Serial.print(array3DimensoesPreDefinido[profundidade][linha][coluna]);
Serial.print(" ");
}
Serial.print("\n");
}
Serial.print("\n");
}
Serial.print("Imprimindo os Elementos do Array em 3 Dimensões Vazio:\n");
for(int profundidade = 0; profundidade < 3; profundidade++){
for(int linha = 0; linha < 2; linha++){
for(int coluna = 0; coluna < 2; coluna++){
Serial.print(array3DimensoesVazio[profundidade][linha][coluna]);
Serial.print(" ");
}
Serial.print("\n");
}
Serial.print("\n");
}
while(true);
}6. Arrays Multidimensionais
A não ser que você trabalhe com computação cientifica, inteligência artificial e processamento de dados muito raramente você terá que utilizar arrays com mais de 3 dimensões. Em muitos casos devido a complexidade optar por alguma outra estrutura de dado possa ser uma opção melhor.
Entretanto caso seja necessário basta aplicar as mesmas técnicas que são usadas para uma, duas e três dimensões. Não existe segredo quanto a isso apenas o grau de complexidade que se torna maior.
