Sortowanie przez kopcowanie.

Witam,

Napisałem algorytm sortowania przez kopcowanie ale po "sortowaniu" jest tylko jeden element w tablicy tzn. 81. Czy ktos wie gdzie może być błąd?

 class Heap
    {
        static void Restore(int[] arr, int k, int n)
        {
            int i, j;
            i = arr[k - 1];
            while (k <= n / 2)
            {
                j = 2 * k;
                if ((j < n) && (arr[j - 1] < arr[j])) 
                    j++;
                if (i >= arr[j - 1])
                    break;
                else
                {
                    arr[k - 1] = arr[j - 1];
                    k = j;
                }
            }
        }
        static void HeapSort(int[] arr, int n)
        {
            int k, swap;
            for (k = n / 2; k > 0; k--)
                Restore(arr, k, n);
            do
            {
                swap = arr[0];
                arr[0] = arr[n - 1];
                arr[n - 1] = swap;
                n--;
                Restore(arr, 1, n);
            } while (n > 1);
        }
        static void Main(string[] args)
        {
            int i = 0;
            int [] array = { 12, 3, -12, 3, 34, 23, 1, 81, 45, 17, 9, 23, 11, 4 };
            for (; i < 14; i++)
                Console.Write(" {0}", array[i]);

            HeapSort(array, 14);

            Console.WriteLine();
            
            for (i = 0; i < 14; i++)
                Console.Write(" {0}", array[i]);
            Console.Read();
        }
    }

Błąd jest chyba tutaj:
arr[0] = arr[n - 1];
Zamiast 0 daj n

Po zmianie kompilator informuje mnie, że zakres tablicy w trakcie wykonywania został przekroczony i przerywa działanie w tym momencie.

Chciałem zrobić drobne poprawki ale poprawki się mnożyły i ostatecznie wyszło na to że przepisałem od nowa...
Ogólnie twoje Restore (czyli SiftDown u mnie) było jakieś dziwne - poprawiona wersja:

using System;
class Heap
{
    static void SiftDown(int[] arr, int start, int end)
    {
        int root = start;

        while (root * 2 + 1 < end)
        {
            int child = root * 2 + 1;
            int swap = root;
            if (arr[swap] < arr[child])
                swap = child;
            if (child + 1 <= end && arr[swap] < arr[child + 1])
                swap = child + 1;
            if (swap != root)
            {
                int tmp = arr[swap];
                arr[swap] = arr[root];
                arr[root] = tmp;
                root = swap;
            }
            else
                return;
        }
    }

    static void Heapify(int[] arr, int count)
    {
        int start = count / 2 - 1;

        while (start >= 0)
        { SiftDown(arr, start, count - 1); start--; }
    }

    static void HeapSort(int[] arr, int count)
    {
        Heapify(arr, count);

        int end = count - 1;
        while (end > 0)
        {
            int tmp = arr[end];
            arr[end] = arr[0];
            arr[0] = tmp;

            SiftDown(arr, 0, end - 1);
            end--;
        }
    }
    static void Main(string[] args)
    {
        int i = 0;
        int[] array = { 12, 3, -12, 3, 34, 23, 1, 81, 45, 17, 9, 23, 11, 4 };
        for (; i < 14; i++)
            Console.Write(" {0}", array[i]);

        HeapSort(array, 14);

        Console.WriteLine();

        for (i = 0; i < 14; i++)
            Console.Write(" {0}", array[i]);
        Console.Read();
    }
}

Polecam np. http://en.wikipedia.org/wiki/Heapsort, wszystko ładnie wytłumaczone.