AHK: Сортировка массива

arr := [{value: 1}, {value: 3}, {value: 2}, {value: 2}]
sorted := SortByKey(arr, "value", true)
MsgBox % PrintArray(sorted)

SortByKey(arr, key, reverse := false) {
    ArrMin := [], ArrMax := []
    Random, pivot, 1, arr.Count()
    for k, v in arr {
        if (k = pivot)
            continue

        array := (!reverse ? arr[k, key] < arr[pivot, key] : arr[k, key] > arr[pivot, key]) ? "ArrMin" : "ArrMax"
        %array%.Push(v)
    }
    for k, v in ["ArrMin", "ArrMax"]
       (%v%.Length() > 1 && %v% := SortByKey(%v%, key, reverse))

    ArrMin.Push(arr[pivot], ArrMax*)
    Return ArrMin
}

PrintArray(arr, del = "") {
	for k, v in arr
		str .= del k ":" ((IsFunc(v) ? "__Function" : IsObject(v) ? PrintArray(v, del) : (v + 0 != "" ? v : """" v """")))", " 
	Return "{" RTrim(str, ", ") del "}"
}

arr := [{value: 1}, {value: 32}, {value: 3}, {value: 2}, {value: 32}, {value: 32}, {value: 2}]
 
sorted := SortDescending(arr, "value")  
MsgBox % PrintArray(sorted,  "`n" )

SortDescending(arr, key, sort = "R N", del = "|") {
	res := [], ex := {}, str := "" 
	for k, v in arr {
		str .= v[key] del
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	Sort str, U D%del% Z %sort%
	Loop, Parse, str, %del%
	{
		for k, v in ex[A_LoopField]  
			res.push(arr[v])
	} 
	Return res 
}

arr := [{value: 1}, {value: 32}, {value: 3}, {value: 2}, {value: 32}, {value: 32}, {value: 2}]

sorted := SortDescending(arr, "value", 1) 
MsgBox % PrintArray(sorted,  "`n" )

SortDescending(arr, key, reverse := false) {
	res := [], ex := [] 
	for k, v in arr { 
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	for k, v in ex { 
		for k2, v2 in ex[k]
			reverse ? res.insertat(1, arr[ex[k][k2]]) : res.push(arr[ex[k][k2]]) 
	} 
	Return res 
}
PrintArray(arr, del = "") {
	for k, v in arr
		str .= del k ":" ((IsFunc(v) ? "__Function" : IsObject(v) ? PrintArray(v, del) : (v + 0 != "" ? v : """" v """")))", " 
	Return "{" RTrim(str, ", ") del "}"
}

SetBatchLines, -1

arr := []
Loop 100000 {
    Random, rand
    arr.Push({value: rand})
}
start := A_TickCount
res1 := SortByKey(arr, "value", true)
end1 := A_TickCount
res2 := SortDescending(arr, "value")
end2 := A_TickCount

MsgBox % A_Clipboard := end1 - start . "`n" . end2 - end1 . "`n`n" . PrintArray(res1) . "`n`n" . PrintArray(res2)

SortDescending(arr, key, sort = "R N", del = "|") {
	res := [], ex := {}, str := "" 
	for k, v in arr {
		str .= v[key] del
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	Sort str, U D%del% Z %sort%
	Loop, Parse, str, %del%
	{
		for k, v in ex[A_LoopField]  
			res.push(arr[v])
	} 
	Return res 
}

SortByKey(arr, key, reverse := false) {
    stack := []
    stack.Push([1, arr.Length()])

    while (stack.Length() > 0) {
        low := stack.Pop()
        high := low[2]
        low := low[1]

        while (high - low > 10) {
            pivotIndex := MedianOfThree(arr, low, high, key, reverse)
            pivotIndex := Partition(arr, low, high, pivotIndex, key, reverse)

            if (pivotIndex - low < high - pivotIndex) {
                stack.Push([pivotIndex + 1, high])
                high := pivotIndex - 1
            } else {
                stack.Push([low, pivotIndex - 1])
                low := pivotIndex + 1
            }
        }
        InsertionSort(arr, low, high, key, reverse)
    }

    return arr
}

MedianOfThree(arr, low, high, key, reverse) {
    mid := low + (high - low) // 2
    if reverse {
        if (arr[low, key] < arr[mid, key])
            Swap(arr, low, mid)
        if (arr[mid, key] < arr[high, key])
            Swap(arr, mid, high)
        if (arr[low, key] < arr[mid, key])
            Swap(arr, low, mid)
    } else {
        if (arr[low, key] > arr[mid, key])
            Swap(arr, low, mid)
        if (arr[mid, key] > arr[high, key])
            Swap(arr, mid, high)
        if (arr[low, key] > arr[mid, key])
            Swap(arr, low, mid)
    }
    return mid
}

Partition(arr, low, high, pivotIndex, key, reverse) {
    pivot := arr[pivotIndex, key]
    Swap(arr, pivotIndex, high)

    i := low - 1

    Loop, % high - low {
        j := A_Index + low - 1
        compare := !reverse ? arr[j, key] < pivot : arr[j, key] > pivot
        if compare {
            i++
            Swap(arr, i, j)
        }
    }

    Swap(arr, i + 1, high)
    return i + 1
}

InsertionSort(arr, low, high, key, reverse) {
    Loop, % high - low {
        i := A_Index + low
        j := i
        while (j > low) {
            compare := !reverse ? arr[j, key] < arr[j-1, key] : arr[j, key] > arr[j-1, key]
            if compare
                Swap(arr, j, j-1)
            else
                break
            j--
        }
    }
}

Swap(arr, i, j) {
    temp := arr[i]
    arr[i] := arr[j]
    arr[j] := temp
}

PrintArray(arr, del = "") {
	for k, v in arr
		str .= del k ":" ((IsFunc(v) ? "__Function" : IsObject(v) ? PrintArray(v, del) : (v + 0 != "" ? v : """" v """")))", " 
	Return "{" RTrim(str, ", ") del "}"
}

SetBatchLines, -1

arr := []
arr.SetCapacity(100000000) 
Loop 100000 {
    Random, rand
    arr.Push({value: rand})
}

a := A_TickCount
SortDescending(arr, "value")
msgbox % A_TickCount - a

a := A_TickCount
SortDescending1(arr, "value")
msgbox % A_TickCount - a

a := A_TickCount
SortDescending2(arr, "value")
msgbox % A_TickCount - a


SortDescending(arr, key, sort = "R N", del = "|") {
	res := [], ex := {}, str := "" 
	for k, v in arr {
		str .= v[key] del
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	Sort str, U D%del% Z %sort%
	Loop, Parse, str, %del%
	{
		for k, v in ex[A_LoopField]  
			res.push(arr[v])
	} 
	Return res 
}


SortDescending1(arr, key, sort = "R N", del = "|") {
	res := [], ex := {}, str := "" 
; res.SetCapacity(100000000) 
 VarSetCapacity(str, 100000000)
	for k, v in arr {
		str .= v[key] del
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	Sort str, U D%del% Z %sort%
	Loop, Parse, str, %del%
	{
		for k, v in ex[A_LoopField]  
			res.push(arr[v])
	} 
	Return res 
}

SortDescending2(arr, key, sort = "R N", del = "|") {
	res := [], ex := {}, str := "" 
 res.SetCapacity(100000000) 
; VarSetCapacity(str, 100000000)
	for k, v in arr {
		str .= v[key] del
		If !ex[v[key]]
			ex[v[key]] := []
		ex[v[key]].push(k)
	}
	Sort str, U D%del% Z %sort%
	Loop, Parse, str, %del%
	{
		for k, v in ex[A_LoopField]  
			res.push(arr[v])
	} 
	Return res 
}