void straight_insertion_sort(int arr[], int left, int right)
{
	int i;

	/* move smallest key to left end */
	for(i = left+1; i <= right; i++)
		if(arr[0] > arr[i])
			swap(arr, 0, i);

	for(i = left+1; i <= right; i++)
	{
		int j, key;

		for(j = i-1, key = arr[i]; arr[j] > key; j--)
				arr[j+1] = arr[j];

		arr[j+1] = key;
	}
}

void bubble_sort(int arr[], int left, int right)
{
	int i, j;

	for(i = right; i > left; i--)
	{
		for(j = left; j < i; j++)
			if(arr[j] > arr[j+1])
				swap(arr, j, j+1);
	}
}

void straight_selection_sort(int arr[], int left, int right)
{
	int i, j, min;

	for(i = left; i < right; i++)
	{
		min = i;
		for(j = i+1; j <= right; j++)
		{
			if(arr[j] < arr[min])
				min = j;
		}
		swap(arr, i, min);
	}
}

def bsort(tab):
    for i in range(len(tab) - 1):
        for j in range(i + 1, len(tab)):
            if tab[j] < tab[i]:
                tab[i], tab[j] = tab[j], tab[i]

def ssort(tab):
    for i in range(len(tab) - 1):
        min = tab[i]
        indexmin = i
        for j in range(i + 1, len(tab)):
            if tab[j] < min:
                min = tab[j]
                indexmin = j
        if indexmin != i:
            tab[i], tab[indexmin] = tab[indexmin], tab[i]

def isort(tab):
    for i in range(1, len(tab)):
        buffer = tab[i]
        j = i - 1
        while j >= 0 and tab[j] > buffer:
            tab[j + 1] = tab[j]
            j -= 1
        tab[j + 1] = buffer

and the C versions:

int insert_sort(int *tab, int l)
{
    int *ip, *jp;
    int value;
    printf("insert sorting!\n");
    for (ip = tab + 1; ip < tab + l; ip++) {
        value = *ip;
        jp = ip - 1;
        while((jp >= tab) && (value < *jp)) {
            *(jp + 1) = *jp;
            --jp;
        }
        *(jp + 1) = value;
    }
    return 0;
}

int bubble_sort(int *tab, int l)
{
    int *ip, *jp;
    printf("bubble sorting!\n");
    for (jp = tab + l - 2; jp >= tab; jp--) {
        for (ip = tab; ip <= jp; ip++) {
            if (*ip > *(ip + 1))
                swap (ip, ip + 1);
        }
    }
    return 0;
}

int select_sort(int *tab, int l)
{
    int *ip, *jp;
    int min;
    printf("select sorting!\n");
    for (jp = tab; jp < tab + l - 1; jp++) {
        min = *jp;
        for (ip = jp + 1; ip < tab + l; ip++)
            if (*ip < min)
                swap(ip, &min);
        *jp = min;
    }
    return 0;
}

(defn in-sort! [data]
  (letfn [(insert ([raw x](insert [] raw x))
		  ([sorted [y & ys :as raw] x]
		     (if (empty? raw) (conj sorted x)
			 (if (neg? (compare x y )) (concat sorted [x,y] ys )
			     (recur (conj sorted y)  ys x )))))]
    (reduce insert [] data)))

(defn sel-sort! [coll]
  (let [len (count coll)]
    (letfn [(min-index [coll start]
		       (if (=  start len) start
			   (reduce #(if (neg? (compare (nth coll %1) (nth coll %2))) %1 %2) (range start len))))
	    (vswap! [a-vec x y] (assoc a-vec x (nth a-vec y) y (nth a-vec x)))]
      (loop [cur 0
	     data (vec coll)
	     min (min-index data cur)]
	(if (>= cur len) data
	    (let [data (vswap! data  min cur)
		  cur (inc cur)]
	      (recur cur data (min-index data cur))))))))

(defn b-sort! [coll]
  (let [cnt (dec (count coll))
	swap (fn [n m data] (assoc data n (nth data m) m (nth data n)))]
    (loop [changed false, n 0,data (vec coll)]
      (cond (>= n cnt)
	    (if changed (recur false 0 data) data)
	    (neg? (compare (nth data n) (nth data (inc n))))
	    (recur changed (inc n) data)
	    :else
	    (recur true (inc n) (swap n (inc n) data))))))

(def data '(6 8 5 9 3 2 1 4 7))

(println "b-sort!:" (b-sort! data))
(println "sel-sort!:" (sel-sort! data))
(println "in-sort!:" (in-sort! data))
;Should print
;b-sort!: [1 2 3 4 5 6 7 8 9]
;sel-sort!: [1 2 3 4 5 6 7 8 9]
;in-sort!: (1 2 3 4 5 6 7 8 9)

The insertion sort is done functionally, and can sort over anything Clojure can turn into a sequence (any Clojure collection, ArrayLists, etc.). So as not to clutter the code further, in this case I chose to use numbers only, allowing the use of Clojure’s built-in min function.

(import 'java.util.ArrayList)

(defn arr-swap! [#^ArrayList arr i j]
  (let [t (.get arr i)]
    (doto arr
      (.set i (.get arr j))
      (.set j t))))

(defn bubble-sort!
  ([arr] (bubble-sort! compare arr))
  ([cmp #^ArrayList arr]
     (letfn [(sorter
	      [stop-i]
	      (let [changed (atom false)]
		(doseq [i (range stop-i)]
		  (if (> (cmp (.get arr i) (.get arr (inc i))) 0)
		    (do
		      (arr-swap! arr i (inc i))
		      (reset! changed true))))
		@changed))]
       (doseq [stop-i (range (dec (.size a)) -1 -1)
	       :while (sorter stop-i)])
       arr)))

(defn sel-sort!
  ([arr] (sel-sort! compare arr))
  ([cmp #^ArrayList arr]
     (let [n (.size arr)]
       (letfn [(move-min!
		[start-i]
		(loop [i start-i]
		  (when (< i n)
		    (when (< (cmp (.get arr i) (.get arr start-i)) 0)
		      (arr-swap! arr start-i i))
		    (recur (inc i)))))]
	 (doseq [start-i (range (dec n))]
	   (move-min! start-i))
	 arr))))

(defn ins-sort
  [xs]
  (letfn [(remove-first
	   [x xs]
	   (if (= x (first xs)) (next xs)
	       (cons (first xs) (remove-first x (next xs)))))
	  (sorter
	   [xs]
	   (if (or (empty? xs) (empty? (next xs))) xs
	       (let [x (apply min xs)
		     xs1 (remove-first x xs)]
		 (cons x (sorter xs1)))))]
       (sorter (seq xs))))