Introduo

As tcnicas de ordenao e busca, sempre foram utilizadas em computao e quase sempre so indispensveis a grandes e robustos sistemas onde trabalhar com informaes uma necessidade bsica. Para estes sistemas o emprego de algoritmos eficientes que sejam capazes de organizar a informao e busc-las rapidamente garante um ganho de desempenho e consequentemente tempo. Sero abordados os principais tipos de ordenao e busca bem como um exemplo de seus cdigos em Java.

Tcnicas de ordenao
As tcnicas de ordenao so uma maneira de organizao de conjuntos de informaes que possibilita a localizao destas informaes de uma maneira fcil e gil. Estas tcnicas de ordenao geralmente so executadas em ambientes computacionais devido a sua ampla lista de funcionalidades e pela automao apresentada por estes sistemas. Existem inmeros algoritmos de ordenao para as mais variadas situaes, entre eles esto: Bubble Sort. Insertion Sort Selection Sort Heap Sort Quick sort

Bubble Sort
O algoritmo de ordenao Bubble Sort ou ordenao por flutuao um algoritmo que utiliza a ideia de flutuao dos elementos do nvel mais baixo para o mais alto ou vice e versa. A ideia central percorrer um array de elementos comparando elementos dois a dois e os trocando de posio em funo de uma relao entre os dois. Sero realizadas no mximo n iteraes, no pior dos casos, e no mnimo n iteraes, em um caso de vetor ordenado. Um exemplo do algoritmo Bubble Sort segue abaixo: public static int[] bubbleSort(int vector[], int ordem) { if(ordem == CRESCENTE) { for(int i=0; i<vector.length; i++) { for(int j=1; j<vector.length; j++) { if(vector[j] < vector[j-1]) { vector = troca(vector,j,j-1); } } } } else {

for(int i=0; i<vector.length; i++)

} }

for(int j=1; j<vector.length; j++) { if(vector[j-1] < vector[j]) { vector = troca(vector,j,j-1); } }

return vector;

Neste algoritmo inserido um vetor com n posies como parmetro e o tipo de ordenao ascendente ou descendente representado pelas palavras crescente e decrescente, sendo no final do cdigo retornado o vetor ordenado.

Insertion Sort
O algoritmo de ordenao Insertion Sort ou por ordenao por insero realiza basicamente o que o prprio nome j diz insero. Em um vetor desordenado os elementos so comparados com todos os elementos esquerda ou todos os elementos direita a fim de inseri-lo entre dois valores configurando uma ordenao momentnea, deixando os elementos, mais a esquerda ou mais a direita, ordenados. Um exemplo do Insertion Sort apresentado abaixo: public static int[] insertionSort(int vetor[], int ordem) { if(ordem == CRESCENTE) { for (int i = 1; i < vetor.length; i++) { int valor = vetor[i]; for (int j = i - 1; j >= 0 && vetor[j] > valor; j--) { vetor[j + 1] = vetor[j]; vetor[j] = valor; } } } return vetor;

else if(ordem == DECRESCENTE) { for (int i = 1; i < vetor.length; i++) { int valor = vetor[i]; for (int j = i - 1; j >= 0 && vetor[j] < valor; j--) { vetor[j + 1] = vetor[j]; vetor[j] = valor; }

} }

return vetor;

return null;

Neste exemplo passado um vetor de elementos para ser ordenado juntamente com seu tipo de ordenao ascendente ou descendente, onde no final da ordenao retorna-se o vetor ordenado.

Selection Sort
Selection sort ou algorimo de ordenao por seleo, ele ordena os elementos salvando o ndice do menor (caso a ordenao seja ascendente) valor ou o maior (caso a ordenao seja descendente) o jogando em sua devida posio assim sendo ele parte para o prximo valor realizando a mesma comparao e assim por diante. Um exemplo de Selection Sort est apresentado abaixo: public static int[] selectionSort(int vetor[], int ordem) { int menor, indiceMenor, maior, indiceMaior; if(ordem == CRESCENTE) { for (int i = 0; i < vetor.length - 1; i++) { menor = vetor[i]; indiceMenor = i; for (int j = i + 1; j < vetor.length; j++) { if (vetor[j] < menor) { menor = vetor[j]; indiceMenor = j; } } vetor[indiceMenor] = vetor[i]; vetor[i] = menor;

} } return vetor;

else if(ordem == DECRESCENTE) { for (int i = 0; i < vetor.length - 1; i++) { maior= vetor[i]; indiceMaior = i; for (int j = i + 1; j < vetor.length; j++) { if (vetor[j] > maior) { maior = vetor[j];

indiceMaior = j;

} } return vetor;

vetor[indiceMaior] = vetor[i]; vetor[i] = maior;

return null; } Neste exemplo um vetor pode ser ordenado de duas maneiras diferentes: ascendente ou descendente sendo retornado no final da ordenao.

Heap Sort
Heap Sort um algoritmo de ordenao generalista, e faz parte da famlia de algoritmos de ordenao por seleo. Ele utiliza uma estrutura de dados chamada heap, para ordenar os elementos medida que os insere na estrutura (um vetor ou uma rvore). Para se ordenar ascendentemente deve ser construdo um heap mximo, onde o maior elemento fica na raiz, e para se ordenar descendentemente deve ser construdo um heap mnimo, onde o menor elemento fica na raiz. Sua ordenao muito eficiente em ordenaes aleatrias com uma margem de eficincia em pior dos casos muito prximo do caso mdio, tendo sua eficcia representada pela seguinte relao: O (n lg n). Um exemplo de Heap Sort apresentado abaixo: public static <T extends Comparable<? super T>> void heapSort(T[] v) { buildMaxHeap(v); int n = v.length; for (int i = v.length - 1; i > 0; i--) { swap(v, i, 0); maxHeapify(v, 0, --n); } private static <T extends Comparable<? super T>> void buildMaxHeap(T v[]) { for (int i = v.length / 2 - 1; i >= 0; i--) maxHeapify(v, i, v.length); } private static <T extends Comparable<? super T>> void maxHeapify(T[] v, int pos, int n) {

int max = 2 * pos + 1, right = max + 1; if (max < n) { if (right < n && v[max].compareTo(v[right]) < 0) max = right; if (v[max].compareTo(v[pos]) > 0) { swap(v, max, pos); maxHeapify(v, max, n); } }

public static void swap(Object[] v, int j, int aposJ) { Object aux = v[j]; v[j] = v[aposJ]; v[aposJ] = aux; }

Quick Sort
Quick Sort ou ordenao que adota a estratgia de diviso e conquista. Consiste em dividir o problema central em dois subproblemas e selecionar um piv que garantir que todos os elementos no final da ordenao sejam maiores ou menores que ele (em caso de ascendente ou descendente), em seguida as duas sublistas so fundidas e ordenadas. Um exemplo de Quic Sort apresentado abaixo: public static void quick_sort(int []v,int ini, int fim) { int meio; if (ini < fim) { meio = partition(v, ini, fim); quick_sort(v, ini, meio); quick_sort(v, meio + 1, fim); } } public static int partition(int []v, int ini, int fim) { int pivo, topo, i; pivo = v[ini]; topo = ini; for (i = ini + 1; i <= fim; i++) { if (v[i] < pivo) { v[topo] = v[i]; v[i] = v[topo + 1]; topo++; } } v[topo] = pivo; return topo; }

Algoritmos de Busca
A busca sempre foi necessria ao longo da histria da humanidade mas foi somente a partir do surgimento da internet que se tornou amplamente utilizada. Em computao existem dois tipos principais de buscas: Busca Linear Busca Binria

Busca linear
Busca binria consiste em um algoritmo de busca sequencial comparando cada elemento da estrutura (vetor, listas dinmicas, rvores) com o elemento buscado. Um exemplo de algoritmo de busca apresentado abaixo: public static int buscaLinear(int vetor[], int valor) { for(int i=0; i<vetor.length; i++) { if(vetor[i] == valor) { return i; } } } return -1;

Busca Binria
O algoritmo de busca binria consiste em um vetor organizado comparar o elemento do meio da sequencia com o atual verificando: Se igual Se maior Se menor Com estas trs comparaes ele capaz de a cada iterao cortar metade das comparaes pois j foi observado que o elemento buscado no vetor organizado maior ou menor que o elemento central dispensando busc-lo na outra metade. Feito isto o elemento final torna-se o elemento anterior ao do meio, ou o elemento inicial torna-se o elemento posterior ao do meio. Isto at que o elemento do meio seja o elemento buscado. Um exemplo de busca binria: public static int buscaBinaria(int vetor[], int valor) { int fim = vetor.length - 1; int inicio = 0; int meio;

vetor = bubbleSort(vetor, CRESCENTE); for(int i=inicio; i<=fim; i++) { meio = (inicio + fim)/2; if(vetor[meio] == valor) { return meio; } else if(valor < vetor[meio]) { fim = meio - 1; } else { } } }

inicio = meio + 1;

return -1;

Concluso:
Podemos concluir que com o advento da computao a utilizao destas tcnicas tanto de busca quanto de ordenao tornou-se indispensvel no mundo atual. As informaes esto cada vez mais abundantes, de acordo com as projees feitas pela Cisco, em 2016, ns consumiremos 1,3 zettabytes de dados, 4 vezes mais do que consumimos hoje. Se no houver algoritmo de busca e ordenao eficientes ns nos perderemos nesta quantidade absurda de dados ou no mnimo levaremos angustiveis horas para encontrar uma informao que poderia salvar uma vida.

Referncias:
http://www.tudocelular.com/Curiosidade/noticias/n26138/internet-2016.html http://rafaelsakurai.blogspot.com.br/2008/06/bubble-sort-em-java.html http://blog.renatogama.com/category/algoritmos/ordenacao/insertion-sort/ http://www.ft.unicamp.br/liag/siteEd/definicao/selection-sort.php http://www.ime.usp.br/~pf/algoritmos/aulas/hpsrt.html http://www.ime.usp.br/~pf/algoritmos/aulas/hpsrt.html http://www.dca.fee.unicamp.br/cursos/EA876/apostila/HTML/node19.html http://www.dca.fee.unicamp.br/cursos/EA876/apostila/HTML/node20.html