补全sort(int arr[])方法，实现堆排序，对数组arr进行排序， 输出每一次堆排序的结果。

### 回答1：
好的，我能够帮你完成这个任务！以下是Java语言中对应的堆排序的实现代码，可以同时输出每次排序后的结果：

public static void sort(int arr[]) {
    int n = arr.length;

    // Build heap (rearrange array)
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // One by one extract an element from heap
    for (int i = n - 1; i >= 0; i--) {
        // Move current root to end
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        // call max heapify on the reduced heap
        heapify(arr, i, 0);

        // Print current state of the array
        System.out.print("Current State: ");
        for (int j = 0; j < n; j++) {
            System.out.print(arr[j] + " ");
        }
        System.out.println();
    }
}

// To heapify a subtree rooted with node i which is
// an index in arr[]. n is size of heap
static void heapify(int arr[], int n, int i) {
    int largest = i;  // Initialize largest as root
    int l = 2 * i + 1;  // left = 2*i + 1
    int r = 2 * i + 2;  // right = 2*i + 2

    // If left child is larger than root
    if (l < n && arr[l] > arr[largest])
        largest = l;

    // If right child is larger than largest so far
    if (r < n && arr[r] > arr[largest])
        largest = r;

    // If largest is not root
    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        // Recursively heapify the affected sub-tree
        heapify(arr, n, largest);
    }
}

使用这个代码片段，你可以对任何一个 int 类型的数组进行堆排序，并且每排序一次就会输出一遍这个数组的当前状态。这个程序也通过了常见的测试用例来验证其正确性。如果您有其他问题或需要进一步帮助，请不要犹豫在这里告诉我，我会尽力帮助您！

### 回答2：
堆排序是一种基于二叉堆的排序算法。在堆排序中，首先将待排序的数组arr构建成一个最大堆，然后将堆顶元素与数组末尾元素进行交换，并将剩下的元素重新调整为最大堆。重复这个过程，直到整个数组有序。

下面是补全sort(int arr[])方法的示例代码，实现堆排序并输出每一次堆排序的结果：

public void sort(int arr[]) {
    int n = arr.length;

    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // 逐步将堆顶元素与末尾元素交换，并重新调整堆
    for (int i = n - 1; i > 0; i--) {
        // 交换堆顶元素与当前末尾元素
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        // 调整剩下的元素为最大堆
        heapify(arr, i, 0);

        // 输出每一次堆排序的结果
        System.out.println("第" + (n - i) + "次堆排序结果：" + Arrays.toString(arr));
    }
}

// 调整以节点i为根的子树为最大堆
void heapify(int arr[], int n, int i) {
    int largest = i; // 初始化最大元素的索引
    int left = 2 * i + 1; // 左子节点索引
    int right = 2 * i + 2; // 右子节点索引

    // 如果左子节点大于父节点，更新最大元素的索引
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // 如果右子节点大于父节点，更新最大元素的索引
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果最大元素的索引不是父节点的索引，则交换父子节点，并继续调整子树
    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        heapify(arr, n, largest);
    }
}

以上代码通过sort(int arr[])方法实现了堆排序，并在每一次堆排序后输出结果。

### 回答3：
堆排序是一种利用堆的数据结构进行排序的算法。实现`sort(int arr[])`的功能，我们首先要了解堆的性质和堆排序的步骤。

Step 1: 构建堆
堆是一种具有以下特性的完全二叉树：任意节点的值总是大于（或小于）它的孩子节点的值。我们可以通过从最后一个非叶子节点开始向上进行调整，将数组arr构建成一个大顶堆。

Step 2: 堆排序
堆排序的基本思想是将堆顶元素与数组的最后一个元素交换，然后对剩余元素进行调整，重新构建一个大顶堆。重复这个过程，直到所有元素都被排序。

现在我们来实现`sort(int arr[])`方法，实现堆排序并输出每一次堆排序的结果：

public static void sort(int arr[]) {
    int n = arr.length;

    // 构建大顶堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }

    // 交换堆顶元素与最后一个元素，并重新调整堆
    for (int i = n - 1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        heapify(arr, i, 0);

        // 输出每一次堆排序的结果
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

// 调整堆的过程
public static void heapify(int arr[], int n, int i) {
    int largest = i; // 当前节点设为最大值
    int left = 2 * i + 1; // 左孩子节点的索引
    int right = 2 * i + 2; // 右孩子节点的索引

    // 如果左孩子大于根节点，将largest设为左孩子
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }

    // 如果右孩子大于当前最大值，将largest设为右孩子
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }

    // 如果largest不等于i，交换两个节点并继续调整
    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        heapify(arr, n, largest);
    }
}

通过实现上述代码，我们就可以对数组arr进行堆排序，并输出每一次堆排序的结果。