Insert-Sort(A)

1. n <- |A|
2. para j <- 2 até n faça:
3. carta <- A[j]
4. i <- j - 1
5. enquanto i>0 e A[i] > carta:
6. A[i+1] <- A[i]
7. i <- i - 1
8. A[i+1] <- carta

---------------------------------------------------------------------------------------------------------------------------

Merge-Sort(A,p,r)
1. se (p<r) então
2. q <- (p+r)/2 (arredondamento inferior)
3. Merge-Sort(A,p,q)
4. Merge-Sort(A,q+1,r)
5. Intercala(A,p,q,r)

Intercala(A,p,q,r)
1. n1 <- q-p+1; n2 <- r-q
2. crie vetores L[] e R[] // com uma posição a mais
3. L[n1+1] <- infinito; R[n2+1] <- infinito;
4. para i <- 1 até n1 faça:
5. L[i] <- A[p+i-1]
6. para j <- 1 até n2 faça:
7. R[j] <- A[q+j]
8. i <- 1; j <- 1
9. para k <- p até r faça:
10. se (L[i]<=R[j]) então:
11. A[k] <- L[i]
12. i <- i+1
13. senão
14. A[k] <- R[j]
15. j<- j+1

Funcionamento:
● Trabalha com divisão (o problema em subproblemas menores) e conquista (resolver
os subproblemas recursivamente);
●

---------------------------------------------------------------------------------------------------------------------------

Quick-Sort(A,p,r)
1. se (p<r) então
2. q <- Particione(A,p,r)
3. Quick-Sort(A,p,q-1)
4. Quick-Sort(A,q+1,r)

Particione(A,p,r)
1. pivô <- A[rr]; i <- p-1
2. para j <- p até r-1 faça:
3. se A[j] <= pivô
4. i <- i+1
5. trocar A[i] <-> A[j]
6. trocar A[i+1] <-> A[j]
7. retorne i+1

---------------------------------------------------------------------------------------------------------------------------

Heap-Sort(A)
1. BuldMaxHeap(A)
2. para i <- tam(A) até 2 faça:
3. trocar A[1] <-> A[i]
4. tam(A) <- tam(A) - 1
5. MaxHeapfy(A,1)

MaxHeapfy(A,i)
1. l <- 2i; r <- 2i+1; n <- tam(A)
2. se (l <= n) e (A[l]>A[i]) então:
3. maior <- l
4. senão:
5. maior <- i
6. se (r <=n ) e (A[l] > A[maior]) então:
7. maior <- r

BuildMaxHeap(A)
1. tam(A) <- |A|
2. para i <- tam(A)/2 (arredondamento inferior) até 1 faça:
3. MaxHeapfy(A,i)

---------------------------------------------------------------------------------------------------------------------------

Counting-Sort(A,B,k)
1. crie vetor C[1 … k] com zeros
2. para j <- 1 até n:
3. C[ A[j] ]++
4. para i <- 1 até k:
5. C[i] <- C[i] + C[i-1]
6. para j <- n até 1:
7. B[ C[ A[j] ] ] <- A[j]
8. C[ A[j] ] - -
---------------------------------------------------------------------------------------------------------------------------

Seleção(A,p,r,k)
1. se (p=r) então retorne A[p]
2. q <- particioneAleatório(A,p,r)
3. i <- q-p+1
4. se i=k então: retorne A[q]
5. se i>k então: retorne Seleção(A,p,q-1,k)
6. se i<k então: retorne Seleção(A,q+1,r,k-i)