Um vetor e um conjunto de variáveis de um mesmo tipo de dado as quais são acessadas e referenciadas através da posição (índices) e do identificador do vetor. Um vetor pode ser multidimensional, ou seja, pode armazenar valores em 2 ou mais dimensões.
A declaração de um vetor unidimensional segue a sintaxe abaixo:
<tipo-do-dado> <identificador>[<tamanho>];
Onde:
<tipo-do-dado>: tipo do dado
armazenado em cada elemento do vetor.
<identificador>: identificador usado para referenciar a variável vetor.
<tamanho>: número de elementos do vetor.
long inteiros[10]; // vetor com 10 números inteiros longos char texto[1000]; // vetor com 1000 caracteres
O identificador de um vetor em C é, na verdade, um ponteiro que aponta para o primeiro elemento do vetor. Quando declaramos long inteiros[10]; estamos reservando um conjunto de dez posições de memória contíguas, cada uma delas com 4 bytes (um long tem 4 bytes). Logo, o vetor completo tem 40 bytes.
Para saber o número de bytes ocupado por uma variável, podemos usar a função sizeof, que recebe como parâmetro uma variável e retorna o número de bytes ocupados pela mesma.
main() {
char c;
int i;
long l;
long vl[10];
float f;
double d;
printf("bytes de cada tipo:\n");
printf("char %d\n", sizeof(c));
printf("int %d\n", sizeof(i));
printf("long %d\n", sizeof(l));
printf("long[10] %d\n", sizeof(vl));
printf("float %d\n", sizeof(f));
printf("double %d\n", sizeof(d));
}
É importante notar que vetores em C começam pelo índice 0. Por exemplo, para referenciar o primeiro elemento usamos o índice 0 e décimo elemento, usamos o índice 9.
main() {
long Vetor[100];
long I, N, Menor, Ordenadas, Temp;
printf("N:"); scanf("%d", &N);
for (I = 0; I < N; I++)
scanf("%d", &Vetor[I]);
Ordenadas = -1;
do {
Ordenadas++;
Menor = Ordenadas;
for (I = Ordenadas + 1; I < N; I++)
if (Vetor[I] < Vetor[Menor])
Menor = I;
Temp = Vetor[Ordenadas];
Vetor[Ordenadas] = Vetor[Menor];
Vetor[Menor] = Temp;
}
while (Ordenadas < N);
for (I = 0; I < N; I++)
printf("%d\n", Vetor[I]);
}
Conforme mencionado anteriormente, uma variável do tipo vetor é equivalente a um apontador para o primeiro elemento do vetor, com a facilidade de usar um índice para acessar o elemento desejado. Além desta forma, podemos usar apontadores puramente para acessar e manipular o vetor como um todo e seus elementos e vice-versa.
float BuscaMaior(float *v, int t, int *p) {
float Maior = v[0];
*p = 0;
int i;
for (i = 1; i <= t; i++)
if (v[i] > Maior) {
Maior = v[i];
*p = i;
}
return(Maior);
}
main() {
float valores[4];
valores[0] = 19.0;
valores[1] = 11.0;
valores[2] = 5.0;
valores[3] = 32.0;
int pos;
float m = BuscaMaior(valores, 3, &pos);
printf("valor: %f na posicao %d\n", m, pos);
m = BuscaMaior(valores, 2, &pos);
printf("valor: %f na posicao %d", m, pos);
}
A declaração de um vetor multidimensional segue a sintaxe abaixo:
<tipo-do-dado> <identificador> <tamanhos>;
Onde:
<tipo-do-dado>: tipo do dado
armazenado em cada elemento do vetor.
<identificador>: identificador usado para referenciar a variável vetor.
<tamanhos>: seqüência dos tamanhos de cada dimensão.
long MatrizInteiros[3][3]; // matriz 3x3 char texto[1000][80]; // matriz que representa um texto com 1000 linhas de 80 colunas
float BuscaMaiorMatriz(float v[3][3], int maxLin, int maxCol, int *lin, int *col) {
float Maior = v[0][0];
*lin = *col = 0;
int i, j;
for (i = 0; i < maxLin; i++)
for ( (j = (i == 0 ? 1 : 0)); j < maxCol; j++)
if (v[i][j] > Maior) {
Maior = v[i][j];
*lin = i;
*col = j;
}
return(Maior);
}
main() {
float valores[3][3];
valores[0][0] = 19.0; valores[0][1] = 11.0; valores[0][2] = 5.0;
valores[1][0] = 32.0; valores[1][1] = 2.0; valores[1][2] = 12.0;
valores[2][0] = 5.5; valores[2][1] = 4.3; valores[2][2] = 41.0;
int lin, col;
float m = BuscaMaiorMatriz(valores, 3, 3, &lin, &col);
printf("valor: %f na posicao [%d,%d]\n", m, lin, col);
m = BuscaMaiorMatriz(valores, 2, 3, &lin, &col);
printf("valor: %f na posicao [%d,%d]", m, lin,col);
}
Existem vários métodos de ordenação. Um método bastante simples e conhecido é o método da bolha. Nele, a ordenação tem como princípio "borbulhar" o menor valor para o início do vetor ou o maior para o final. Na implementação abaixo, o menor valor é "borbulhado" para o início. Logo em seguida, o segundo menor valor é "borbulhado" para a segunda posição do vetor. Este processo se repete até que não haja troca alguma durante uma iteração ou quando o último elemento a ser ordenado é alcançado.
void troca(int* a, int* b) {
int aux = *a;
*a = *b;
*b = aux;
}
void bolha (int *primeiro, int *ultimo) {
int naoTrocou;
int *posAtual;
for (; ultimo > primeiro; --ultimo) {
naoTrocou = 1;
for (posAtual = primeiro; posAtual < ultimo; ++posAtual) {
if (*posAtual > *(posAtual+1)) {
troca (posAtual, posAtual+1);
naoTrocou = 0;
}
}
if (naoTrocou) return;
}
}
void exibir(int *primeiro, int n) {
int i = 0;
for (; i < n; i++) {
printf("%d ", primeiro[i]);
}
}
main() {
int v[10];
v[0] = 6;
v[1] = 9;
v[2] = 3;
v[3] = 5;
v[4] = 4;
v[5] = 8;
printf("antes: ");
exibir(v, 6);
bolha(v, &v[5]);
printf("\ndepois: ");
exibir(v, 6);
}