Replacement Selection Sort

function replacementSelectionSort(arr, stats) {
  const n = arr.length;
  if (n < 2) return;
  const heap = new Array(n).fill(0);
  for (let i = 0; i < n; i++) {
    heap[i] = arr[i];
  }
  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
    let root = i;
    while (true) {
      let smallest = root;
      const l = 2 * root + 1;
      const r = 2 * root + 2;
      if (l < n && heap[l] < heap[smallest]) smallest = l;
      if (r < n && heap[r] < heap[smallest]) smallest = r;
      if (smallest === root) break;
      const t = heap[root];
      heap[root] = heap[smallest];
      heap[smallest] = t;
      root = smallest;
    }
  }
  let size = n;
  for (let out = 0; out < n; out++) {
    arr[out] = heap[0];
    size--;
    heap[0] = heap[size];
    let root = 0;
    while (true) {
      let smallest = root;
      const l = 2 * root + 1;
      const r = 2 * root + 2;
      if (l < size && heap[l] < heap[smallest]) smallest = l;
      if (r < size && heap[r] < heap[smallest]) smallest = r;
      if (smallest === root) break;
      const t = heap[root];
      heap[root] = heap[smallest];
      heap[smallest] = t;
      root = smallest;
    }
  }
}

def sort(arr, n, stats):
    if (n < 2):
        return
    heap = [0] * n
    for i in range(n):
        heap[i] = arr[i]
    for i in range(((n // 2) - 1), (0 - 1), -1):
        root = i
        while True:
            smallest = root
            l = ((2 * root) + 1)
            r = ((2 * root) + 2)
            if ((l < n) and (heap[l] < heap[smallest])):
                smallest = l
            if ((r < n) and (heap[r] < heap[smallest])):
                smallest = r
            if (smallest == root):
                break
            t = heap[root]
            heap[root] = heap[smallest]
            heap[smallest] = t
            root = smallest
    size = n
    for out in range(n):
        arr[out] = heap[0]
        size -= 1
        heap[0] = heap[size]
        root = 0
        while True:
            smallest = root
            l = ((2 * root) + 1)
            r = ((2 * root) + 2)
            if ((l < size) and (heap[l] < heap[smallest])):
                smallest = l
            if ((r < size) and (heap[r] < heap[smallest])):
                smallest = r
            if (smallest == root):
                break
            t = heap[root]
            heap[root] = heap[smallest]
            heap[smallest] = t
            root = smallest

#include <vector>
#include <algorithm>
void sort(std::vector<int>& arr, int n, int& comparisons, int& swaps) {
    if((n < 2)) {
        return;
    }
    std::vector<int> heap(n, 0);
    for(int i=0; i<n; i++) {
        heap[i] = arr[i];
    }
    for(int i=((n / 2) - 1); i>(0 - 1); i--) {
        int root = i;
        while(1) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < n) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < n) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
    int size = n;
    for(int out=0; out<n; out++) {
        arr[out] = heap[0];
        size--;
        heap[0] = heap[size];
        int root = 0;
        while(1) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < size) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < size) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
}

public void Sort(int[] arr, int n, dynamic stats) {
    if((n < 2)) {
        return;
    }
    int[] heap = new int[n];
    for(int i=0; i<n; i++) {
        heap[i] = arr[i];
    }
    for(int i=((n / 2) - 1); i>(0 - 1); i--) {
        int root = i;
        while(true) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < n) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < n) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
    int size = n;
    for(int out=0; out<n; out++) {
        arr[out] = heap[0];
        size--;
        heap[0] = heap[size];
        int root = 0;
        while(true) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < size) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < size) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
}

#include <stdio.h>
#include <string.h>
void sort(int arr[], int n, int* comparisons, int* swaps) {
    if((n < 2)) {
        return;
    }
    int heap[n]; memset(heap, 0, sizeof(heap));
    for(int i=0; i<n; i++) {
        heap[i] = arr[i];
    }
    for(int i=((n / 2) - 1); i>(0 - 1); i--) {
        int root = i;
        while(1) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < n) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < n) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
    int size = n;
    for(int out=0; out<n; out++) {
        arr[out] = heap[0];
        size--;
        heap[0] = heap[size];
        int root = 0;
        while(1) {
            int smallest = root;
            int l = ((2 * root) + 1);
            int r = ((2 * root) + 2);
            if(((l < size) && (heap[l] < heap[smallest]))) {
                smallest = l;
            }
            if(((r < size) && (heap[r] < heap[smallest]))) {
                smallest = r;
            }
            if((smallest == root)) {
                break;
            }
            int t = heap[root];
            heap[root] = heap[smallest];
            heap[smallest] = t;
            root = smallest;
        }
    }
}