Heapsort (метод кучи, пирамидальная сортировка) для строк - C#

Формулировка задачи:

Доброго всем времени суток, может ли кто-то поделиться опытом сортировки по алфавиту методом heapsort? Есть массив array с названиями, которые нужно отсортировать, знаю как применять алгоритм к числам, а как ко строкам?

Как переделать данный алгоритм для строк?

                    Листинг программы
                
 
                            
                        
        public static void heapify(int[] arr, int pos, int size)
        {
            int temp;
            while (2 * pos + 1 < size)
            {
                int t = 2 * pos + 1;
                if (2 * pos + 2 < size && arr[2 * pos + 2] >= arr[t])
                {
                    t = 2 * pos + 2;
                }
                if (arr[pos] < arr[t])
                {
                    temp = arr[pos];
                    arr[pos] = arr[t];
                    arr[t] = temp;
                    pos = t;
                }
                else break;
            }
        }
        public static void heap_make(int[] arr, int n)
        {
            for (int i = n - 1; i >= 0; i--)
            {
                heapify(arr, i, n);
            }
        }
        public static void heap_sort(int[] arr, int n)
        {
            int temp;
            heap_make(arr, n);
            while (n > 0)
            {
                temp = arr[0];
                arr[0] = arr[n - 1];
                arr[n - 1] = temp;
                n--;
                heapify(arr, 0, n);
            }
        }

Решение задачи: «Heapsort (метод кучи, пирамидальная сортировка) для строк»

textual
                            Листинг программы 
                        
 
                            
                        
internal static class HeapSort
    {
        internal static void Sort<T>(T[] array, int offset, int length, Comparison<T> comparison)
        {
            if (array == null)
                throw new ArgumentNullException("array");
            if (offset < 0 || length < 0)
                throw new ArgumentOutOfRangeException((length < 0 ? "length" : "offset"), "Non-negative number required.");
            if (array.Length - offset < length)
                throw new ArgumentException("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.");
            if (comparison == null)
                throw new ArgumentNullException("comparison");
            for (var i = 0; i < length; i++)
            {
                var index = i;
                var item = array[offset + i];
                while (index > 0 && comparison(array[offset + (index - 1) / 2], item) < 0)
                {
                    var top = (index - 1) / 2;
                    array[offset + index] = array[offset + top];
                    index = top;
                }
                array[offset + index] = item;
            }
            for (var i = length - 1; i > 0; i--)
            {
                var last = array[offset + i];
                array[offset + i] = array[offset];
                var index = 0;
                while (index * 2 + 1 < i)
                {
                    int left = index * 2 + 1, right = left + 1;
                    if (right < i && comparison(array[offset + left], array[offset + right]) < 0)
                    {
                        if (comparison(last, array[offset + right]) > 0)
                            break;
                        array[offset + index] = array[offset + right];
                        index = right;
                    }
                    else
                    {
                        if (comparison(last, array[offset + left]) > 0)
                            break;
                        array[offset + index] = array[offset + left];
                        index = left;
                    }
                }
                array[offset + index] = last;
            }
        }
    }