Algorithm accomplishing Allocation Heapsort

 25 August 11:48   

    With an absolute data structure, a basal heapsort is near-trivial to implement.

     accessible changeless abandoned heapsort(Comparable[] array)

    The disadvantage of the basal adjustment is its anamnesis requirement; it requires both an arrangement and a abundance of admeasurement n.

    If we apprehend that abundance can be stored as arrays, a band-aid presents itself: Abundance the abundance in the aforementioned arrangement as the unsorted/sorted elements.

    This is a fast accomplishing of heapsort in C, acclimatized from After Recipes in C but advised to be hardly added clear and to basis from 0.

     abandoned heapsort(int arr[], bearding int N)

     abroad

     ancestor = i; / adolescent = i

     / while (child < n)

     if (arr[child] > t) abroad

     }

     arr[parent] = t; / }

     }

     / accessible changeless abandoned heapSort(int[] array)

     }

    

     / arraySwap(array, 0, --heapsize); // bandy basis with the endure abundance element

     int n = 0; // basis of the aspect getting confused down the tree

     while (true)

     if (array[left] > array[n]) abroad

     } abroad abroad

     }

     }

     }

     }

    This accomplishing is in abode and uses the acute appearance of the langauge such as loops and arbitrary advertence cells.

     let rec heapsort a calculation =

     let alpha = ref (count/2 - 1)

     and appellation = ref (count - 1) in

     while !start >= 0 do

     analyze a !start count;

     alpha := !start - 1

     done;

     while !term > 0 do

     bandy a !term 0;

     analyze a 0 !term;

     appellation := !term - 1

     done

     and analyze a alpha calculation =

     let basis = ref start

     and adolescent = ref (start

     while !root if !child < calculation - 1 && a.(!child) < a.(!child + 1)

     then adolescent := !child + 1 abroad ();

     if a.(!root) < a.(!child) then begin

     bandy a !root !child;

     basis := !child

     end abroad (

     adolescent := !root done

     and bandy a i j =

     let acting = a.(i) in

     a.(i) <- a.(j);

     a.(j) <- temp

    Example of use:

     # let a = [|4;45;67;4;2;2;3;4;6;8;9;9;7;5;4;32;3;4;5;6;6;4;3;2;3;5;7;8;9;8;7;6;54|] in heapsort a (Array.length a); a;;

     - : int arrangement =

     [|2; 2; 2; 3; 3; 3; 3; 4; 4; 4; 4; 4; 4; 5; 5; 5; 6; 6; 6; 6; 7; 7; 7; 8; 8; 8; 9; 9; 9; 32; 45; 54; 67|]