//////////////////////////////////////////////////
// 【引数】
//   array : ソートする数値を格納した配列。参照引数。 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE heapSort(Var array[])
	DIM i = 0
	DIM u = UBound(array)
	WHILE i < u
		upHeap(array, i)
		i = i + 1
	WEND
	WHILE i > 0
		swap(array[0], array[i])
		downHeap(array, i)
		i = i - 1
	WEND
FEND

PROCEDURE upHeap(Var array[], n)
	WHILE n > 0
		DIM parent = (n - 1) / 2
		IFB array[parent] < array[n] THEN
			swap(array[parent], array[n])
		ELSE
			BREAK
		ENDIF
		n = parent
	WEND
FEND

PROCEDURE downHeap(Var array[], n)
	DIM m = 0
	DIM tmp = 0
	WHILE TRUE
		DIM LtChild = (m + 1) * 2 - 1
		DIM RtChild = (m + 1) * 2
		IF LtChild >= n THEN BREAK
		IF array[LtChild] > array[tmp] THEN tmp = LtChild
		IF RtChild < n AND array[RtChild] > array[tmp] THEN tmp = RtChild
		IF tmp = m THEN BREAK
		swap(array[tmp], array[m])
		m = tmp
	WEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列 
//   multiplier : inputsを繰り返す回数 
// 【戻り値】
//   inputsをmultiplier回を繰り返した文字列を返します 
//////////////////////////////////////////////////
FUNCTION strRepeat(inputs, multiplier)
	DIM res = ""
	FOR n = 1 TO multiplier
		res = res + inputs
	NEXT
	RESULT = res
FEND

//////////////////////////////////////////////////
// 【引数】
//   a : bと交換する値。参照引数。 
//   b : aと交換する値。参照引数。 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE swap(Var a, Var b)
	DIM tmp = a
	a = b
	b = tmp
FEND

//////////////////////////////////////////////////
// 【引数】
//   arrayname : 上限値を求める配列の名前 
//   dimension : 返す次元を示す整数 
// 【戻り値】
//   配列の上限値 
//////////////////////////////////////////////////
FUNCTION UBound(arrayname[], dimension = 1)
	RESULT = EVAL("RESIZE(arrayname" + strRepeat("[0]", dimension - 1) + ")")
FEND

DIM array[] = 8, 20, 2, 22, 17, 30, 14, 4, 25, 5

heapSort(array)

FOR item IN array
	PRINT item
NEXT