Java堆排序完整代码

### 回答1：
好的，下面是一个 Java 堆排序的完整代码示例：

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr) {
        // 将数组堆化
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            heapify(arr, i, arr.length);
        }

        // 将堆顶元素与末尾元素交换，将最大元素沉到数组末端
        // 重复这个过程，直到整个数组有序
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            heapify(arr, 0, i);
        }
    }

    public static void heapify(int[] arr, int i, int length) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        // 找出三个节点中最大的节点
        if (left < length && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < length && arr[right] > arr[largest]) {
            largest = right;
        }

        // 如果最大的节点和当前的节点不同，将它们交换
        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest, length);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

堆排序的思路是将数组构建成一个堆，然后将堆顶元素与末尾元素交换，将最大元素沉到数组末端。重复这个过程，直到整个数组有序。

上面的代码中，`heapify` 函数用

### 回答2：
下面是Java实现堆排序的完整代码：

import java.util.Arrays;

public class HeapSort {

    public static void heapSort(int[] arr) {
        int len = arr.length;

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

        // 堆排序
        for (int i = len - 1; i >= 0; i--) {
            // 将根节点与最后一个节点交换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // 重新将剩余未排序的部分构建成最大堆
            heapify(arr, i, 0);
        }
    }

    private static 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;
        }

        // 如果最大值不是根节点，将最大值与根节点交换，并且递归调用heapify方法
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }

    public static void main(String[] args) {
        int[] arr = { 7, 2, 8, 1, 4, 5, 9, 3, 6 };
        System.out.println("排序前：" + Arrays.toString(arr));
        heapSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

以上代码实现了使用堆排序算法对一个整数数组进行排序。通过构建最大堆和不断调整堆的过程，将数组排序为升序。可以通过输出结果验证排序算法的正确性。

### 回答3：
Java堆排序的完整代码如下：

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 2, 1, 9, 5};

        heapSort(arr);

        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void heapSort(int[] arr) {
        int len = arr.length;

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

        // 依次取出堆顶元素，与末尾元素交换位置，并重新调整堆
        for (int i = len - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            heapify(arr, i, 0);
        }
    }

    public static void heapify(int[] arr, int len, int i) {
        int largest = i; // 初始化最大值为当前节点
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点

        // 比较左子节点与当前节点的值，找出最大值的索引
        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        // 比较右子节点与当前节点的值，找出最大值的索引
        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        // 如果最大值不是当前节点，则交换它们，并递归调整子节点
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            heapify(arr, len, largest);
        }
    }
}

以上代码实现了堆排序的主要逻辑。首先，通过`heapSort`方法建立一个最大堆，然后依次取出堆顶元素，与末尾元素交换，并重新调整堆，直到整个数组有序。`heapify`方法用于调整堆，它会比较当前节点与其左右子节点的值，找到最大值，并将最大值与当前节点互换位置，然后递归地调整子节点。最后，将排序后的数组打印输出即可。