bubbleSort(array)
for i ← 1 to sizeOfArray − 1 do
    for j ← 1 to sizeOfArray − 1 − i do
        if array[j] > array[j + 1] then
           swap array[j] and array[j + 1]
        end if
    end for
end for
end bubbleSort

Bubble Sort (Ascending) — Step-by-step Iterations

Initial List: [30, 25, 62, 45, 7, 10]

Pass 1 (i = 1)
1) Compare 30 and 25 → swap → [25, 30, 62, 45, 7, 10]
2) Compare 30 and 62 → no swap → [25, 30, 62, 45, 7, 10]
3) Compare 62 and 45 → swap → [25, 30, 45, 62, 7, 10]
4) Compare 62 and 7 → swap → [25, 30, 45, 7, 62, 10]
5) Compare 62 and 10 → swap → [25, 30, 45, 7, 10, 62]
End of Pass 1: [25, 30, 45, 7, 10, 62]

Pass 2 (i = 2)
1) Compare 25 and 30 → no swap → [25, 30, 45, 7, 10, 62]
2) Compare 30 and 45 → no swap → [25, 30, 45, 7, 10, 62]
3) Compare 45 and 7 → swap → [25, 30, 7, 45, 10, 62]
4) Compare 45 and 10 → swap → [25, 30, 7, 10, 45, 62]
End of Pass 2: [25, 30, 7, 10, 45, 62]

Pass 3 (i = 3)
1) Compare 25 and 30 → no swap → [25, 30, 7, 10, 45, 62]
2) Compare 30 and 7 → swap → [25, 7, 30, 10, 45, 62]
3) Compare 30 and 10 → swap → [25, 7, 10, 30, 45, 62]
End of Pass 3: [25, 7, 10, 30, 45, 62]

Pass 4 (i = 4)
1) Compare 25 and 7 → swap → [7, 25, 10, 30, 45, 62]
2) Compare 25 and 10 → swap → [7, 10, 25, 30, 45, 62]
End of Pass 4: [7, 10, 25, 30, 45, 62]

Pass 5 (i = 5)
1) Compare 7 and 10 → no swap → [7, 10, 25, 30, 45, 62]
End of Pass 5: [7, 10, 25, 30, 45, 62]
Note: No swaps happened, so the list is already sorted (early stop).

Final Sorted List (Ascending): [7, 10, 25, 30, 45, 62]

Algorithm (Steps)

1) Start from the first element of the array.
2) Assume the first element is the minimum element.
3) Compare this minimum element with the remaining elements of the array.
4) If a smaller element is found, update the minimum element.
5) Swap the minimum element with the first element of the unsorted part.
6) Move the boundary of the sorted part one position forward.
7) Repeat the above steps until the entire array is sorted.

selectionSort(array)
  for i ← 1 to sizeOfArray − 1
    minIndex ← i
    for j ← i + 1 to sizeOfArray
      if array[j] < array[minIndex]
        minIndex ← j
    end for
    if minIndex ≠ i
      swap array[i] and array[minIndex]
  end for
end selectionSort

Insertion Sort — Step-by-step Execution

Initial Array: [30, 25, 62, 45, 7, 10]

Pass 1 (i = 2, key = 25)
Compare 25 with 30 → shift 30 to the right
Insert 25 at position 1
Array after Pass 1: [25, 30, 62, 45, 7, 10]

Pass 2 (i = 3, key = 62)
Compare 62 with 30 → no shift required
Array after Pass 2: [25, 30, 62, 45, 7, 10]

Pass 3 (i = 4, key = 45)
Compare 45 with 62 → shift 62 to the right
Compare 45 with 30 → stop shifting
Insert 45 in correct position
Array after Pass 3: [25, 30, 45, 62, 7, 10]

Pass 4 (i = 5, key = 7)
Compare 7 with 62 → shift 62 to the right
Compare 7 with 45 → shift 45 to the right
Compare 7 with 30 → shift 30 to the right
Compare 7 with 25 → shift 25 to the right
Insert 7 at the beginning
Array after Pass 4: [7, 25, 30, 45, 62, 10]

Pass 5 (i = 6, key = 10)
Compare 10 with 62 → shift 62 to the right
Compare 10 with 45 → shift 45 to the right
Compare 10 with 30 → shift 30 to the right
Compare 10 with 25 → shift 25 to the right
Compare 10 with 7 → stop shifting
Insert 10 in correct position
Array after Pass 5: [7, 10, 25, 30, 45, 62]

Final Sorted Array (Ascending Order): [7, 10, 25, 30, 45, 62]

Algorithm (Steps)
1) Choose a pivot element from the array.
2) Rearrange the array so that elements smaller than the pivot are on the left and larger elements are on the right.
3) Place the pivot in its correct position.
4) Recursively apply Quick Sort on the left subarray.
5) Recursively apply Quick Sort on the right subarray.
6) Repeat the process until the entire array is sorted.

quickSort(array, low, high)
  if low < high
    pivotIndex ← partition(array, low, high)
    quickSort(array, low, pivotIndex − 1)
    quickSort(array, pivotIndex + 1, high)
end quickSort

partition(array, low, high)
  pivot ← array[high]
  i ← low − 1
  for j ← low to high − 1
    if array[j] < pivot
      i ← i + 1
      swap array[i] and array[j]
  swap array[i + 1] and array[high]
  return i + 1

Selection Sort — Step-by-step Example

Given Array: [30, 25, 62, 45, 7, 10]

Pass 1 (i = 1)
Assume minimum = 30
Compare 30 with 25 → new minimum = 25
Compare 25 with 62 → no change
Compare 25 with 45 → no change
Compare 25 with 7 → new minimum = 7
Compare 7 with 10 → no change
Swap 30 and 7
Array after Pass 1: [7, 25, 62, 45, 30, 10]

Pass 2 (i = 2)
Assume minimum = 25
Compare 25 with 62 → no change
Compare 25 with 45 → no change
Compare 25 with 30 → no change
Compare 25 with 10 → new minimum = 10
Swap 25 and 10
Array after Pass 2: [7, 10, 62, 45, 30, 25]

Pass 3 (i = 3)
Assume minimum = 62
Compare 62 with 45 → new minimum = 45
Compare 45 with 30 → new minimum = 30
Compare 30 with 25 → new minimum = 25
Swap 62 and 25
Array after Pass 3: [7, 10, 25, 45, 30, 62]

Pass 4 (i = 4)
Assume minimum = 45
Compare 45 with 30 → new minimum = 30
Compare 30 with 62 → no change
Swap 45 and 30
Array after Pass 4: [7, 10, 25, 30, 45, 62]

Pass 5 (i = 5)
Assume minimum = 45
Compare 45 with 62 → no change
No swap needed
Array after Pass 5: [7, 10, 25, 30, 45, 62]

Final Sorted Array (Ascending Order): [7, 10, 25, 30, 45, 62]

Algorithm (Steps)

1) Divide the given array into two halves.
2) Recursively apply Merge Sort on the left half.
3) Recursively apply Merge Sort on the right half.
4) Merge the two sorted halves into a single sorted array.
5) Repeat the process until the entire array is sorted.

mergeSort(array, left, right)
  if left < right
    mid ← (left + right) / 2
    mergeSort(array, left, mid)
    mergeSort(array, mid + 1, right)
    merge(array, left, mid, right)
end mergeSort

merge(array, left, mid, right)
  n1 ← mid − left + 1
  n2 ← right − mid

  create array L[1..n1] and R[1..n2]

  for i ← 1 to n1
    L[i] ← array[left + i − 1]

  for j ← 1 to n2
    R[j] ← array[mid + j]

  i ← 1, j ← 1, k ← left

  while i ≤ n1 and j ≤ n2
    if L[i] ≤ R[j]
      array[k] ← L[i]
      i ← i + 1
    else
      array[k] ← R[j]
      j ← j + 1
    k ← k + 1

  while i ≤ n1
    array[k] ← L[i]
    i ← i + 1
    k ← k + 1

  while j ≤ n2
    array[k] ← R[j]
    j ← j + 1
    k ← k + 1
end merge

Merge Sort — Step-by-step Example (Ascending)

Given Array: [30, 25, 62, 45, 7, 10]

Step 1: Divide (Split) the array
Split into two halves:
Left = [30, 25, 62]
Right = [45, 7, 10]

Step 2: Divide the Left half
Left = [30, 25, 62] → Split into:
L1 = [30, 25]
L2 = [62]

Step 3: Divide L1 further
L1 = [30, 25] → Split into:
[30] and [25]

Step 4: Merge (Sort) [30] and [25]
Merge → [25, 30]

Step 5: Merge [25, 30] and [62]
Merge → [25, 30, 62]
Sorted Left Half: [25, 30, 62]

Step 6: Divide the Right half
Right = [45, 7, 10] → Split into:
R1 = [45, 7]
R2 = [10]

Step 7: Divide R1 further
R1 = [45, 7] → Split into:
[45] and [7]

Step 8: Merge (Sort) [45] and [7]
Merge → [7, 45]

Step 9: Merge [7, 45] and [10]
Merge → [7, 10, 45]
Sorted Right Half: [7, 10, 45]

Step 10: Final Merge of two sorted halves
Merge [25, 30, 62] and [7, 10, 45]:
Result → [7, 10, 25, 30, 45, 62]

Final Sorted Array (Ascending Order): [7, 10, 25, 30, 45, 62]

<

Algorithm (Steps)
1) Choose a pivot element from the array.
2) Rearrange the array so that elements smaller than the pivot are on the left and larger elements are on the right.
3) Place the pivot in its correct position.
4) Recursively apply Quick Sort on the left subarray.
5) Recursively apply Quick Sort on the right subarray.
6) Repeat the process until the entire array is sorted.

quickSort(array, low, high)
  if low < high
    pivotIndex ← partition(array, low, high)
    quickSort(array, low, pivotIndex − 1)
    quickSort(array, pivotIndex + 1, high)
end quickSort

partition(array, low, high)
  pivot ← array[high]
  i ← low − 1
  for j ← low to high − 1
    if array[j] < pivot
      i ← i + 1
      swap array[i] and array[j]
  swap array[i + 1] and array[high]
  return i + 1