1. O documento descreve algoritmos de ordenação e busca, incluindo Selection Sort, Bubble Sort, Quicksort, busca linear e binária. 2. São fornecidos exemplos de código em C para cada algoritmo, explicando seu funcionamento de forma concisa. 3. Os algoritmos ordenam vetores comparando valores e trocando de posição quando necessário (ordenação), ou buscam por um valor específico percorrendo o vetor (busca).

1. 2 REFERENCIAL TEORICO
Selection Sort: É um algoritmo de ordenação seu nome vem do inglês que tem como
significadoordenaçãoporseleção e funcionada seguinte forma:selecionaumaposiçãode um
vetor de tamanho n-1, de acordo com a variável de controle, e o armazena em uma variável
auxiliar; feito isso, ele percorrerá o vetor comparando o valor da variável auxiliar com o valor
das outras posições do vetor; se um valor menor que o armazenado na variável auxiliar for
encontrado,essarecebe ovalorencontrado, e aposiçãodovetoremque se encontravaovalor
menorrecebe o valoranteriormente alocado;apóspercorrero vetore feitaas comparações e
troca de valores,este selecionará aposiçãoseguinte.Essarotinaserá repetidaaté a penúltima
posição.
Estrutura do algoritmo na linguagem de programação em C:
void selection_sort(int num[], int tam) {
/* suponha que o vetor tem os seguintes valores armazenado
{6,4,3,5,1,2} */
int i, j, sel, aux; /* Declaração de variáveis auxiliares e de
controle */
for (i = 0; i < (tam-1); i++) /*o tamanho tem de ser -1 para
poder percorrer até o penúltima posição*/
{
sel = i; /* Aqui é armazenada a posição do menor valor que for
encontrado no vetor que começa a partir da primeira posição com
posição 0 e conteúdo na posição do vetor igual a 6*/
for (j = (i+1); j < tam; j++) { /* Esse laço será usado para
percorrer todo o vetor para que seja possível efetuar as
comparações do valor da posição selecionada com o demais valores da
outras posições, o laço será iniciado a partir da posição (i)
selecionada (+1)*/
if(num[sel] > num[j]) { /* Nessa linha é feita a comparação
do valor armazenado na posição selecionada com as outras posições
supondo que seja o primeiro laço de repetição Ex: sel=0, j=1,
num[sel] > num[j] é o mesmo que valor da posição 0 = 6 é maior que
valor da posição 1 = 4; Caso o valor da posição selecionada seja
maior que a outra posição a variável sel recebera o valor da
posição com menor valor*/
sel = j;
}
}
if(sel!=i){/* Caso a o valor variável sel seja diferente do
valor da variável i e feita a troca de valores, já que i foi a
variável selecionada anteriormente caso seja igual e feito um novo
loop*/
aux = num[i];/* aux = 0, aux receberá o conteúdo da
posição i , ou seja 6*/

2. num[i] = num[sel]; /* A posição i = 0 receberá o
conteúdo da posição sel = 1, o conteúdo é 4*/
num[sel] = aux; /* E a posição selecionada sel = 1
receberá o conteúdo de aux = 6, após o termino da troca haver o um
novo loop onde pode ou não ocorrer uma nova troca de valores*/
}
}
}
Bubble Sort: É um método de ordenação simples, recebeuo nome Bubble que tem
como significado bolha por se assemelhar a uma bolha flutuando em um tanque.Seu método
consiste em percorrer uma lista ou vetor várias vezes fazendo com que os maiores valores
subampara as últimasposiçõesaté que alistaestejaordenada;ométodofuncionadaseguinte
forma: o algoritmo entra em laços de repetição, e nos seus loops ele seleciona a primeira e
segunda posição da lista; se o primeiro elementofor maior que o segundo há uma troca de
valores;emseguidaeleselecionaasegundae terceiraposiçãoe fazacomparação;se osegundo
valorformaiorhá umanovatroca de valores,essascomparaçõesserãofeitasaté que se chegue
nofinal dalista,e entãose daráinícioaumnovo loopcomumnovolaçode repetiçãoondetodo
o processo de comparações será refeito até que a lista esteja totalmente ordenada.
Estrutura do algoritmo Bubble Sort na linguagem de programação C:
void bubble_sort(int vetor[], int tamVetor) {
int aux,i,j;
for(i= 0; i < tamVetor; i++) {
for(j=0; j < tamVetor-1 ; j++) {/* Os dois laços de
repetição permitem que seja possível ocorrer todas as comparações
entre as posições da lista*/
if(vetor[j]>vetor[j+1]) {/* É feita a comparação de uma
posição com a próxima posição, se esta for maior que a outra
posição e feita a troca de valores*/
aux = vetor[j];/*aux recebe o valor armazenado na
posição j, Ex: j = 0, valor armazenado no vetor[j] = 9*/
vetor[j] = vetor[j+1]; /*Vetor[j] agora recebera o
valor da próxima posição Ex: vetor[j+1] = 8*/
vetor[j+1] = aux; /*Agora a próxima posição recebe
o maior valor, Ex: vetor[j+1] = 9, e é feito um novo loop podendo
ou não ocorrer uma troca*/
}
}
}
}
Quicksort: É um algoritmo de ordenação por comparação que tem como princípio a
divisãoe conquista.Seufuncionamentoconsisteemselecionarumpivôe comparandoestepivô

3. com os demaisvalores dividindoalistaemdois ordenandoosvaloresmaioresque opivô a sua
direitae omenoresasuaesquerda; apósfeitaessascomparaçõesomesmoprocessose repetirá
na lista de valores da esquerda e da direita podendo essas duas listas ter subdivisões de listas
até que todos os valores sejam ordenados.
Estrutura do algoritmo Quicksort na linguagem de programação C:
void trocaValores(int* a, int* b)/*Função que irá auxiliar na troca
de valores*/
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}
int divide(int vec[], int esquerdo, int direito){/*Função que
dividira o vetor em outros vetores*/
int i, j;
i = esquerdo /* i é usado para saber até qual posição foi
ordenado*/;
for (j = esquerdo + 1; j <= direito; ++j){/** Laço de repetição
para teste de valores, organizando os sub vetores de modo que os
maiores valores a fiquem direita e os menores a esquerda*/
if (vec[j] < vec[esquerdo])/*Teste logico, caso um seja
menor que o outro e efetuado a troca, a primeira vez que for
executada terá apenas dois valores e conforme for avançando os
valores já estarão ordenados. Se não estiverem, cairá no pior
caso*/
{
++i;
trocaValores(&vec[i], &vec[j]); }
}
trocaValores(&vec[esquerdo], &vec[i]);/*Quando o processo
terminar, o valor do pivô será levado a última posição do vetor
deixando os elementos anteriores ordenados sendo ele o próximo
pivô, já que sub vetores tem o mesmo tamanho*/
return i;
}
void quickSort(int vec[], int esquerdo, int direito)/*Método
principal onde há a chamada da recursividade*/
{
int r;/*Valor do ponteiro*/

4. if (direito > esquerdo){/*É um teste logico para saber se é um
vetor valido e para parar a recursividade quando direito e esquerdo
forem iguais*/
r = divide(vec, esquerdo, direito);/* r será usado para
retornar o primeiro valor do pivô */
quickSort(vec, esquerdo, r - 1);/* O método quickSorte
chamado novamente de modo que organize apenas o valores a esquerda
dividindo a lista em outras listas para serem reorganizadas de
forma ordenada*/
quickSort(vec, r + 1, direito); /* O método quickSorte
chamado novamente de modo que organize apenas o valores a direita
dividindo a lista em outras listas para serem reorganizadas de
forma ordenada*/ }
}
Busca Linear: É um algoritmo de busca simples, como seu nome referência ele
percorrerá uma lista ou vetor de forma linear comparando o elemento buscado com todos os
elementos alocados na lista ou vetor até que se encontre o elemento desejado; seu código
funciona da seguinte forma: é inserido o elemento que se deseja encontrar na lista ou vetor
apósinseridoentra-seemlaçode repetiçãoonde acadaloophaveráumtestelogicoparasaber-
se se oelementoinseridoé igual aoelementoalocadonaposiçãoreferenciadapeloloopdolaço
de repetição,apósencontrarum valorigual é finalizadoolaçoe é retornadoa posiçãodovalor
encontrado, caso não seja encontrado o elemento na lista ou vetor é retornado um valor
especifico para que se saiba que o elemento não foi encontrado.
Estrutura do algoritmo de Busca Linear na linguagem de programação C:
/**
* Retorna -1 caso não encontre o elemento procurado, pois não se
tem posições negativas em listas ou vetores.
*/
int procura(char vetor[], int tamanho, char elementoProcurado) {
int i;/* Variável de controle para percorrer o vetor*/
for (i = 0; i < tamanho; i++) {/* Laço de repetição para
percorrer todo o vetor e seja feita os testes lógicos*/
if (vetor[i] == elementoProcurado) {/*Teste logico para
saber-se se o elemento procurado é igual a posição referenciada
pela variável de controle do laço de repetição*/
return i;/*Caso seja encontrado o elemento procurado e
retornado a posição onde o mesmo está alocado, e finalizada a
função*/
}
}
return -1;/*Caso seja percorrido todo e vetor e não seja
encontrado nenhum elemento igual ao procurado e retornado uma
posição -1, pois não há posições negativas em vetores e listas*/
}

5. Busca Binaria: É um método de busca que parte do pressuposto que a lista ou vetor
estejaordenado,usaoparadigmade dividirparaconquistar;funcionandodaseguinteforma: o
algoritmo selecionara o elemento no meioda lista e o compara com o elemento chave (Valor
que se desejabuscardentroda lista),se este foro elementoele retornaaposiçãodoelemento
caso não seja este ele testará o elementopara saber-se se o valor e maior ou menor que o
elemento selecionado nalista,poisse este formenor ou maiorele dividiramaisumaveza lista
a partir da primeira posição ao elemento selecionado anteriormente, o mesmo processo se
repetiria se o elemento chave fosse maior que o selecionado a diferença e que esta lista iria
inicia do elemento selecionadoao último elemento da lista, ou seja é como se houvesse duas
listasumacom osvaloresmaiorese outracomos valoresmenoresque oelementoselecionado
nomeiodalista,sendoassimele dividiráessaslistasaté acharoelementochave ouaté que não
seja mais possível dividir a lista.
Estrutura do algoritmo de Busca Binaria na linguagem de programação C:
int PesquisaBinaria ( int vet[], int chave, int Tam)
{
int ini = 0; /*Inicio do vetor(o primeiro elemento do vetor em
C é zero) */
int sup = Tam-1; /**/Final do vetor (termina em um número a
menos, pois em um vetor sua primeira posição é 0, ou seja 10
números correspondem a sequência de 0 a 9) */
int meio; /*Varivel para receber o valor do meio do vetor*/
while (inf <= sup){/*Laço de repetição para que seja possível
dividir a lista mais de uma vez*/
meio = (inf + sup)/2;/*Quando entrar no laço de
repetição, esse codigo é o responsável por receber a posição
central da lista, ou seja a cada loop ele recebera o centro da
lista*/
if (chave == vet[meio])
return meio;/*Se a chave estiver no centro na lista
a posição e retornada*/
else if (chave < vet[meio])
sup = meio-1;/*O teste logico identifica se a chave
e menor que o elemento central da lista, se este for sup recebera o
meio-1 isso faz com que dívida a lista pela metade deixando apenas
os elementos menores que o meio, pois agora o último elemento será
o meio menos 1*/
else
inf = meio+1; /*O teste logico identifica que a
chave e maior que o elemento central da lista, fazendo com que inf
receba o meio+1 dividindo a lista pela metade deixando apenas os
elementos maiores que o meio, pois o início agora começara do meio
mais um*/
}
return -1; // caso o elemento não esteja na lista e
retornado -1 pois não posição negativa em lista ou vetores}