static void HeapSort( int[] arr, int i)
        {
            int temp;
            int k;
            for (int n = ((i-1) / 2); n >= 0; n--)  //生成堆根
            {
                k = n;
                temp = arr[n];  

                if ((2 * (n + 1)) < i && arr[(n + 1) * 2] > temp)  //将父节点与子节点进行比较
                { 
                    k = ((n + 1) * 2);  // 比较结果为真，则将节点的序号填入
                    temp = arr[k];  //将元素序号内的数值填到中继变量
                }

                if (2 * n + 1 < i && arr[2 * n + 1] > temp)  // 将子节点与堆内当前最大值进行比较
                {
                    k = 2 * n + 1;   // 比较结果为真，则将节点的序号填入
                    temp = arr[k];  //将元素序号内的数值填到中继变量
                }

                if (k != n)
                {
                    arr[k] = arr[n];  //将较大的元素与父节点交换
                    arr[n] = temp;
                }
            }

            if (i > 2)  // 此时，父点为零  n =(i/2)= 0  
            {
                // 将最大的元素下沉到数组的末尾或已下沉元素的前面
                temp = arr[i - 1];
                arr[i - 1] = arr[0];
                arr[0] = temp;  

                HeapSort(arr, i-1);  // 递归时，将下沉元素排除在递归在外
            }
        }