给定一组“无序”记录序列｛25, 30, 11, 7, 22, 16, 18, 33, 40, 55｝，采用冒泡排序、堆排序将该序列排成非递减序列，完成以下问题： 1）写出冒泡排序、堆排序方法的Java实现代码。 2）写出冒泡排序第二趟排序后的结果。 4）画出采用堆排序方法第一次抽取堆顶元素后得到的最小堆。 7）比较上述2种排序算法的性能（时间复杂度）。

以下是我的回答：

1) 冒泡排序和堆排序的Java实现代码：

冒泡排序：

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

堆排序：

public static void heapSort(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);
    }
}

private static void heapify(int[] arr, int n, int i) {
    int largest = i; // 初始化最大元素的索引
    int l = 2 * i + 1; // 左子节点的索引
    int r = 2 * i + 2; // 右子节点的索引

    // 找出最大元素的索引
    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }
    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }

    // 如果最大元素的索引不是当前节点的索引，则交换它们，并继续向下维护最大堆
    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;

        heapify(arr, n, largest);
    }
}

2）冒泡排序第二趟排序后的结果：

第二趟排序后的结果为：{11,25,7,22,16,18,30,33,40,55}

3）画出采用堆排序方法第一次抽取堆顶元素后得到的最小堆：

7
/ \
22 11
/ \ / \
33 40 25 16
/ \
18 30
\
55

4）比较上述2种排序算法的性能（时间复杂度）：

冒泡排序的时间复杂度为O(n^2)，堆排序的时间复杂度为O(nlogn)。因此，对于较大的数据集，堆排序的性能要优于冒泡排序。但是，在实际应用中，堆排序可能需要更多的内存空间来存储堆。