💡

What is happening?

Select an algorithm and press Play or Step Forward to begin. Enter your own numbers or use a preset to see the magic!

Quick Sort CLRS Pseudo-code

Procedure QUICKSORT(A, p, r)
1if p < r
2    then q ← PARTITION(A, p, r)
3         QUICKSORT(A, p, q - 1)
4         QUICKSORT(A, q + 1, r)
Procedure PARTITION(A, p, r)
1x ← A[r]
2i ← p - 1
3for j ← p to r - 1
4    do if A[j] ≤ x
5        then i ← i + 1
6             exchange A[i] ↔ A[j]
7exchange A[i + 1] ↔ A[r]
8return i + 1

Merge Sort CLRS Pseudo-code

Procedure MERGESORT(A, p, r)
1if p < r
2    then q ← ⌊(p + r) / 2⌋
3         MERGESORT(A, p, q)
4         MERGESORT(A, q + 1, r)
5         MERGE(A, p, q, r)
Procedure MERGE(A, p, q, r)
1n₁ ← q - p + 1
2n₂ ← r - q
3create arrays L[1..n₁ + 1] and R[1..n₂ + 1]
4for i ← 1 to n₁
5    do L[i] ← A[p + i - 1]
6for j ← 1 to n₂
7    do R[j] ← A[q + j]
8L[n₁ + 1] ← ∞
9R[n₂ + 1] ← ∞
10i ← 1
11j ← 1
12for k ← p to r
13    do if L[i] ≤ R[j]
14        then A[k] ← L[i]
15             i ← i + 1
16        else A[k] ← R[j]
17             j ← j + 1

Heap Sort CLRS Pseudo-code

Procedure HEAPSORT(A)
1BUILD_HEAP(A)
2for i ← length[A] down to 2
3    do exchange A[1] ↔ A[i]
4       heap_size[A] ← heap_size[A] - 1
5       HEAPIFY(A, 1)
Procedure BUILD_HEAP(A)
1heap_size[A] ← length[A]
2for i ← ⌊length[A] / 2⌋ downto 1
3    do HEAPIFY(A, i)
Procedure HEAPIFY(A, i)
1l ← LEFT_CHILD(i)
2r ← RIGHT_CHILD(i)
3if l ≤ heap_size[A] and A[l] > A[i]
4    then largest ← l
5    else largest ← i
6if r ≤ heap_size[A] and A[r] > A[largest]
7    then largest ← r
8if largest ≠ i
9    then exchange A[i] ↔ A[largest]
10         HEAPIFY(A, largest)

Variables Tracking

No active variables. Press step to trace.