Aula 10

Aprender
Empreender

Ordenação e pesquisa

Ordenação de vectores
Ordenação por selecção
Ordenação por borbulhamento (bubble sort)
Ordenação por fusão
Ordenação por partição e troca
Pesquisa de vectores
Pesquisa linear
Pesquisa binária (num vector ordenado)

Pesquisar: encontrar o valor desejado

1
 Ordenação por selecção
indice início passo passo passo passo passo passo passo
1 2 3 4 5 6 7
0 7 7 2 2 2 2 2 2

1 21 21 21 7 7 7 7 7

2 10 10 10 10 10 10 10 10

3 15 15 15 15 15 11 11 11

4 2 2 7 21 21 21 13 13

5 13 13 13 13 13 13 21 15

6 11 11 11 11 11 15 15 21

Ordenação por selecção

#include <stdio.h>
void ordena(int v[ ], int n)
{
int passo, imin, i, aux; /* imin é o mínimo corrente */
for (passo = 0; passo < n - 1; passo++) {
imin = passo; /* posição inicial da busca */
for (i = passo + 1; i < n; i++)
if (v[i] < v[imin]) imin = i; /* actualize o mínimo */
if (imin != passo) { /* se mínimo diferente do valor */
aux = v[passo]; /* inicial, troca */
v[passo] = v[imin];
v[imin] = aux;
} main()
} {
} int i, v[7] = {17, 3, 31, 9, -3, 35, 10};
ordena(v, 7);
for (i = 0; i < 7; i++) printf("%d ", v[i]);
printf("\n");
4
}

2
 Ordenação por fusão
indice início passo passo passo passo fusão
1 2 3 4
0 7 7 7 7 7 2

1 21 21 21 10 10 7

2 10 10 10 21 15 10

3 15 15 15 15 21 11

4 2 2 2 2 2 13

5 13 13 13 11 11 15

6 11 11 11 13 13 21

Pesquisa linear
#include <stdio.h>
int find(int v[ ], int x, int n, int *p)
/* p contém a posição onde o elemento foi encontrado */
/* Retorna 1 se x foi encontrado; 0 no caso contrário */
{
*p = 0; /* busca começa em 0 */
while (v[*p] != x && *p < n) (*p)++;
if (*p != n)
return 1; /* encontrou */
else
return 0; /* não encontrou */
}
main()
{
int pos, x[5] = {2, 7, -3, 5, 9};
if (find(x, -3, 5, &pos)) printf("%d\n", pos); /* escreve 2 */
if (find(x, 9, 4, &pos)) printf("%d\n", pos); /* nao escreve */
} 6

3
 Pesquisa binária
indice início passo 1 passo 2 passo 3 fim

0 2 2 2 2 2

1 7 7 7 7 7

2 10 10 10 10 10

3 11 11 11 11 11

4 13 13 13 13 13

5 15 15 15 15 15

6 21 21 21 21 21

#include <stdio.h>
int find(int v[ ], int x, int n, int *p)
Pesquisa binária
/* p : posicao onde o elemento foi encontrado. */
/* Retorna 1 se x foi encontrado; 0 no caso contrario. */
{
int baixo = 0, alto = n - 1, medio;
while (baixo <= alto) { /* enquanto existe intervalo de busca */
medio = (int) ((baixo + alto)/2.0); /* índice médio */
if (x < v[medio])
alto = medio - 1; /* intervalo inferior */
else
if (x > v[medio])
baixo = medio + 1; /* intervalo superior*/
else {
*p = medio;
return 1; /* encontrado */
}
}
return 0; /* não encontrado */
}
main()
{
int k, p, v[7] = {1, 3, 17, 31, 52, 73, 86}; /* vector ordenado */
printf("Valor inteiro a encontrar: "); scanf("%d", &k);
if (!find(v, k, 7, &p))
printf("Nao encontrado!\n");
else
printf("Encontrado na posicao %d\n", p+1); /* p começa em 0 */
8
}

4
 Strings
Strings são sequências de caracteres (também chamadas
cadeias de caracteres) que compõem, por exemplo, qualquer
texto. Várias linguagens de programação definem o tipo string.
Em C não existe o tipo string.
Existem, contudo, ferramentas para operar com strings,
representadas como vectores de caracteres terminados com o
carácter especial '\0' (“null-terminated strings”).
Este carácter terminador, de código 0 (não confundir com o
carácter '0'), é, portanto, usado para marcar o fim da sequência.
Como em C as strings são vectores de caracteres
terminados com '\0', a sua declaração e inicialização pode
ser feita como vector, ou então como string
char msg[7] = {'V', 'i', 'v', 'a', ' ', '!', '\0'};
char msg[7] = "Viva !";
for(i = 0; i < 7; i++) printf("%c", msg[i]);
printf("%s\n", msg); /* mencionando apenas o nome da string */ 9

Now Hiring

10

5
 Leitura e escrita de strings
A escrita de strings pode ser feita com printf e campo de
formatação "%s".
A linguagem C também disponibiliza a função puts, de escrita
de uma string s, que se comporta como
printf("%s\n", s);

A leitura de strings pode ser feita com as rotinas scanf,

gets e fgets.
A rotina scanf é usada da forma habitual com o campo
de formatação "%s".
Infelizmente, a leitura com scanf só serve para strings
constituídas por uma única palavra; de facto, a leitura
de caracteres com scanf pára logo que é detectado um
espaço (ou TAB). scanf("%s", nome);
gets(nome);
11
fgets(nome, max, stdin);

Operações com strings

#include <string.h>
int strlen(char *string);
/* comprimento */

char *strcpy(char *dest, char *src);

/* cópia */

char *strcat(char *string1, char *string2);

/* concatenação */

int strcmp(char *string1, char *string2); mystrcpy(char dest[], char src[])

/* comparação */ {
int i = 0;
char *strchr(char *string, int c); while(src[i] != '\0')
/* localização de um carácter */
{
char *strstr(char *string1, char *string2); dest[i] = src[i];
/* localização de sub-string*/ i++;
}
dest[i] = '\0';
12
}

6
 13

Conversões string-número
#include <stdlib.h>
double atof(char *string);
/* converte string em double */

int atoi(char *string);

/* converte string em inteiro */

long atol(char *string);

/* converte string em inteiro longo */

double strtod(char *string, char *endptr);

/* converte string em double, dando a localização do primeiro carácter não convertido */

long strtol(char *string, char *endptr, int base);

/* converte string em inteiro longo, na base de numeração pretendida, e dando a localização
do primeiro carácter não convertido */

unsigned long strtoul(char *string, char *endptr, int base);

/* converte string em inteiro longo sem sinal, na base de numeração pretendida, e dando a
localização do primeiro carácter não convertido */

14

7
 Vectores multi-dimensionais
tipo nome[dim1][dim2]...[dim n]
int v[3][4] = { {33, 17, 11, 31}, {23, 34, 34, 45}, {-3, 0, -34, 2} };

int a2[5][7];
int i, j;
for(i = 0; i < 5; i++) {
for(j = 0; j < 7; j++)
a2[i][j] = 0;
}

15

Vector de vectores

#include <stdio.h>
main() expressões equivalentes
{ v[i][j]
int v[3][4] = { * (v[i] + j)
{33, 17, 11, 31}, (* (v + i))[j]
{23, 34, 34, 45}, * (* (v + i) + j)
{-3, 0, -34, 2} };
int * pi;
pi = v[0];
printf("%d %d %d\n", * pi, * * v, v[0][0]);
}

16

8
17

18