'Option Explicit
'Сортирует только численные массивы, очень эффективно ("сортировка методом пересчета")
Sub Countingsort(List, n, k)
    Dim counts() As Long
    Dim i As Long
    Dim j As Long
    Dim next_index As Long
    Dim min, max
    Dim min_value As Variant, max_value As Variant

    min_value = Minimum(List, n, k)
    max_value = Maximum(List, n, k)

    min = n
    max = k
    
    ReDim counts(min_value To max_value)
    
    'Подсчет значений.
    For i = min To max
        counts(List(i,  1 )) = counts(List(i,  1 )) +  1 
    Next i

    'Повторное занесение значений в массив.
    next_index = min
    For i = min_value To max_value
        For j =  1  To counts(i)
            List(next_index,  1 ) = i
            next_index = next_index +  1 
        Next j
    Next i
End Sub

Private Function Maximum(l, nac, kon)
    Dim S1, s2
    Dim i
    S1 = nac
    s2 = kon
    Maximum = l(S1,  1 )
    For i = S1 To s2
        If l(i,  1 ) > Maximum Then Maximum = l(i,  1 )
    Next i
End Function

Private Function Minimum(l, nac, kon)
    Dim S1, s2
    Dim i
    S1 = nac
    s2 = kon
    Minimum = l(S1,  1 )
    For i = S1 To s2
        If l(i,  1 ) < Minimum Then Minimum = l(i,  1 )
    Next i
End Function

'Сортирует все, ("быстрая сортировка")
'n - строка с которой начнется сортировка
'k - строка на которой сортировка закончится
'Shirina - ширина массива
'Stolbec - столбец по которому будет идти сортировка
Sub QuickSortByStolbec(massiv() As String, n, k, Shirina, Stolbec)
    Dim S As Long, l As Long, r As Long, i As Integer
    Dim shablon() As String
    Dim g As Boolean
    
    S = Int((n + k) /  2 )
    l = n
    r = k
    g = False
    ReDim shablon( 1  To Shirina)
    
    Do Until g = True
        Do Until massiv(l, Stolbec) > massiv(S, Stolbec) Or S = l
            l = l +  1 
        Loop
        
        Do Until massiv(r, Stolbec) < massiv(S, Stolbec) Or r = S
            r = r -  1 
        Loop
        
        If r = S Then
            If l = S Then
                g = True
                If S - n >  1  Then
                    Call QuickSortByStolbec(massiv(), n, S -  1 , Shirina, Stolbec)
                End If
                If k - S >  1  Then
                    Call QuickSortByStolbec(massiv(), S +  1 , k, Shirina, Stolbec)
                End If
            Else
                S = Int((l + r) /  2 )
                For i =  1  To Shirina
                    shablon(i) = massiv(r, i)
                    massiv(r, i) = massiv(l, i)
                    massiv(l, i) = massiv(S, i)
                    massiv(S, i) = shablon(i)
                Next i
                r = r -  1 
            End If
        Else
            If l = S Then
                S = Int((l + r) /  2 ) +  1 
                For i =  1  To Shirina
                    shablon(i) = massiv(l, i)
                    massiv(l, i) = massiv(r, i)
                    massiv(r, i) = massiv(S, i)
                    massiv(S, i) = shablon(i)
                Next i
                l = l +  1 
            Else
                For i =  1  To Shirina
                    shablon(i) = massiv(l, i)
                    massiv(l, i) = massiv(r, i)
                    massiv(r, i) = shablon(i)
                Next i
            End If
        End If
    Loop
End Sub