// slection short

public void SelectionSort(int[] vetor)

{
int min, aux;
for (int i = 0; i < vetor.Length - 1; i++)
{
min = i;
for (int j = i + 1; j < vetor.Length; j++)
if (vetor[j] < vetor[min])
min = j;
if (min != i)
{
aux = vetor[min];
vetor[min] = vetor[i];
vetor[i] = aux;
}
}
}
O algoritmo possui complexidade O(n^2)
Este algoritmo baseado em se passar sempre o menor valor do vetor para a primeir
a posio (ou o maior dependendo da ordem requerida), depois
o segundo menor valor para a segunda posio e assim sucessivamente, at os ltimos dois
elementos.
Neste algoritmo de ordenao escolhido um nmero a partir do primeiro, este nmero escol
hido comparado com os nmeros a partir da sua direita,
quando encontrado um nmero menor, o nmero escolhido ocupa a posio do menor nmero enco
ntrado. Este nmero encontrado ser o prximo nmero escolhido,
caso no for encontrado nenhum nmero menor que este escolhido, ele colocado na posio
do primeiro nmero escolhido, e o prximo nmero sua direita vai
ser o escolhido para fazer as comparaes. repetido esse processo at que a lista este
ja ordenada.
Esquema de funcionamento do Selection Sort
Figura 3: Esquema de funcionamento do Selection Sort
Neste passo o primeiro nmero escolhido foi o 3, ele foi comparado com todos os nme
ros sua direita e o menor nmero encontrado foi o 1,
ento os dois trocam de lugar.
O mesmo processo do passo 1 acontece, o nmero escolhido foi o 5 e o menor nmero en
contrado foi o 2.
No foi encontrado nenhum nmero menor que 3, ento ele fica na mesma posio.
O nmero 5 foi escolhido novamente e o nico nmero menor que ele sua direita o 4, ent
eles trocam.
Vetor j ordenado.

Leia mais em: Algoritmos de ordenao: anlise e comparao http://www.devmedia.com.br/alg

oritmos-de-ordenacao-analise-e-comparacao/28261#ixzz41Um68laq
================================================================================
=====================================================================
Insertion sort
void Inserction(int n, int vetor[]){
int j,i,key;
for(j = 1; j < n; j++){
key = vetor[j];
i = j - 1;
while(i >= 0 && vetor[i] > key){
vetor[i + 1] = vetor[i];
i = i - 1;
}
vetor[i + 1] = key;
}
}
Menor nmero de trocas e comparaes entre os algoritmos de ordenao O(n) quando o vetor
est ordenado.
Pior caso O(n)
O Insertion sort um algoritmo simples e eficiente quando aplicado em pequenas li
stas. Neste algoritmo a lista percorrida da esquerda para a direita,
medida que avana vai deixando os elementos mais esquerda ordenados.
O algoritmo funciona da mesma forma que as pessoas usam para ordenar cartas em u
m jogo de baralho como o pquer.
Esquema de funcionamento do Insertion Sort
Figura 4: Esquema de funcionamento do Insertion Sort
Neste passo verificado se o 5 menor que o 3, como essa condio falsa, ento no h t
verificado se o quatro menor que o 5 e o 3, ele s menor que o 5, ento os dois troc
am de posio.
verificado se o 2 menor que o 5, 4 e o 3, como ele menor que 3, ento o 5 passa a
ocupar a posio do 2,
o 4 ocupa a posio do 5 e o 3 ocupa a posio do 4, assim a posio do 3 fica vazia e o 2
assa para essa posio.
O mesmo processo de comparao acontece com o nmero 1, aps esse processo o vetor fica
ordenado.

Leia mais em: Algoritmos de ordenao: anlise e comparao http://www.devmedia.com.br/alg

oritmos-de-ordenacao-analise-e-comparacao/28261#ixzz41UoNq03b
================================================================================
============================================================================
Bubble Sort
#include <stdio.h>
int main(void){
int vetor[10] = {10,9,8,7,6,5,4,3,2,1};
int tamanho = 10;
int aux;
for(int i=tamanho-1; i >= 1; i--) {
for( int j=0; j < i ; j++) {
if(vetor[j]>vetor[j+1]) {
 aux = vetor[j];
vetor[j] = vetor[j+1];
vetor[j+1] = aux;
}
}
}
for( int r = 0; r < 10; ++r){
printf("%d\n",vetor[r]);
}
}
Bubble sort o algoritmo mais simples, mas o menos eficientes.
Neste algoritmo cada elemento da posio i ser comparado com o elemento da posio i + 1,
ou seja, um elemento da posio 2 ser comparado
com o elemento da posio 3. Caso o elemento da posio 2 for maior que o da posio 3, ele
trocam de lugar e assim sucessivamente. Por causa
dessa forma de execuo, o vetor ter que ser percorrido quantas vezes que for necessri
a, tornando o algoritmo ineficiente para listas muito grandes.
Leia tambm: Entendendo o Algortmo Bubble Sort em Java.
Esquema de funcionamento do Buble Sort
Figura 2: Esquema de funcionamento do Buble Sort
verificado se o 3 maior que 5, por essa condio ser falsa, no h troca.
verificado se o 5 maior que 1, por essa condio ser verdadeira, h uma troca.
verificado se o 5 maior que 2, por essa condio ser verdadeira, h uma troca.
verificado se o 5 maior que 4, por essa condio ser verdadeira, h uma troca.
O mtodo retorna ao incio do vetor realizando os mesmos processos de comparaes, isso
feito at que o vetor esteja ordenado.
O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de or
denao dos mais simples.
A ideia percorrer o vector diversas vezes, a cada passagem fazendo flutuar para
o topo o maior elemento da sequncia.
Essa movimentao lembra a forma como as bolhas em um tanque de gua procuram seu prpri
o nvel, e disso vem o nome do algoritmo.
No melhor caso, o algoritmo executa n operaes relevantes, onde n representa o nmero
de elementos do vector.
No pior caso, so feitas n^2 operaes. A complexidade desse algoritmo de Ordem quadrti
ca.
Por isso, ele no recomendado para programas que precisem de velocidade e operem c
om quantidade elevada de dados.

Leia mais em: Algoritmos de ordenao: anlise e comparao http://www.devmedia.com.br/alg

oritmos-de-ordenacao-analise-e-comparacao/28261#ixzz41UppHJw3
================================================================================
========================================================
merge sort
Em C
void mergeSort(int *vetor, int posicaoInicio, int posicaoFim) {
int i, j, k, metadeTamanho, *vetorTemp;
if(posicaoInicio == posicaoFim) return;
// ordenacao recursiva das duas metades
metadeTamanho = (posicaoInicio + posicaoFim ) / 2;
mergeSort(vetor, posicaoInicio, metadeTamanho);
mergeSort(vetor, metadeTamanho + 1, posicaoFim);
// intercalacao no vetor temporario t
i = posicaoInicio;
j = metadeTamanho + 1;
k = 0;
vetorTemp = (int *) malloc(sizeof(int) * (posicaoFim - posicaoInicio + 1));
while(i < metadeTamanho + 1 || j < posicaoFim + 1) {
if (i == metadeTamanho + 1 ) { // i passou do final da primeira metade,
pegar v[j]
vetorTemp[k] = vetor[j];
j++;
k++;
}
else {
if (j == posicaoFim + 1) { // j passou do final da segunda metade, p
egar v[i]
vetorTemp[k] = vetor[i];
i++;
k++;
}
else {
if (vetor[i] < vetor[j]) {
vetorTemp[k] = vetor[i];
i++;
k++;
}
else {
vetorTemp[k] = vetor[j];
j++;
k++;
}
}
}
}
// copia vetor intercalado para o vetor original
for(i = posicaoInicio; i <= posicaoFim; i++) {
vetor[i] = vetorTemp[i - posicaoInicio];
}
free(vetorTemp);
}
Cdigo em C++
#include <algorithm>
#include <iostream>
#include <vector>
std::vector<int> merge_sort(const std::vector<int> &data)
{
 if (data.size() <= 1) {
return data;
}
int middle = data.size() / 2;
std::vector<int> left(data.begin(), data.begin()+middle);
std::vector<int> right(data.begin()+middle, data.end());
left = merge_sort(left);
right = merge_sort(right);
std::vector<int> result(data.size());
std::merge(left.begin(), left.end(),
right.begin(), right.end(),
result.begin());
return result;
}
Complexidade de tempo: (n log2 n)
Complexidade de espao: (n)
Observaes[editar | editar cdigo-fonte]
Exemplo de execuo do merge sort.
possvel implementar o merge sort utilizando somente um vetor auxiliar ao longo de
toda a execuo,
tornando assim a complexidade de espao adicional igual a (n log n).
possvel tambm implementar o algoritmo com espao adicional (1)
Algoritmo Criado por Von Neumann em 1945.
Desvantagens
Utiliza funes recursivas
Gasto extra de memria, o algortimo cria uma cpia do vetor para cada nvel da chamada
recursiva, totalizando um uso adicional de memria igual a (n log n)
O merge sort, ou ordenao por mistura, ou at mesmo ordenao por entrechechamento, um e
emplo de algoritmo de ordenao do tipo dividir-para-conquistar.
Sua ideia bsica consiste em Dividir(o problema em vrios sub-problemas e resolver e
sses sub-problemas atravs da recursividade) e Conquistar(aps todos os sub-problema
s terem sido resolvidos ocorre a conquista que a unio das resolues dos sub-problema
s).Como o algoritmo do Merge Sort usa a recursividade em alguns problemas esta tc
nica no muito eficiente devido ao alto consumo de memria e tempo de execuo.
Os trs passos teis dos algoritmos dividir-para-conquistar, ou divide and conquer,
que se aplicam ao merge sort so:
Dividir: Dividir os dados em subsequncias pequenas;
Conquistar: Classificar as metades recursivamente aplicando o merge sort;
Combinar: Juntar as metades em um nico conjunto j classificado.
Podemos usar a estratgia da diviso e conquista para resolver o problema. O algori
tmo resultante supe que p r e adota o caso p = r como base da recurso:
Mergesort (A, p, r)
1 se p < r ento
2 q (p+r)/2
3 Mergesort (A, p, q)
4 Mergesort (A, q+1, r)
5 Intercala (A, p, q, r)
(Veja definio de piso.) Observe que p q < r. Com isso, tanto A[p .. q] quanto A[q
+1 .. r] so estritamente menores que A[p .. r].
Isso garante que a execuo do algoritmo termina (mais cedo ou mais tarde).
p q q+1
r
111 333 555 555 777 999 999 222 444 666
888
O que faz o algoritmo Intercala? O algoritmo recebe vetores crescentes A[p .. q
] e A[q+1 .. r] e
rearranja o vetor A[p .. q .. r] de modo que ele fique crescente. Para resolver
esse problema,
eu poderia ignorar o carter ordenado dos dois subvetores e usar o algoritmo de in
sero.
Mas possvel fazer algo mais eficiente (desde que tenhamos permisso para usar um ve
tor auxiliar B[p..r]):
Intercala (A, p, q, r)
6 para i crescendo de p at q faa
7 B[i] A[i]
8 para j crescendo de q+1 at r faa
9 B[r+q+1j] A[j]
10 i p
11 j r
12 para k crescendo de p at r faa
13 se B[i] B[j]
14 ento A[k] B[i]
15 i i+1
16 seno A[k] B[j]
17 j j1

(Esta verso do algoritmo do Algorithms in C de Sedgewick.)

Suponha que cada execuo de cada linha do cdigo consome 1 unidade de tempo.
Ento a execuo de Intercala consome 6n+5 unidades de tempo, onde n o nmero de element
os do vetor A[p..r].