rust语言实现堆排序 完整代码

### 回答1：
堆排序的完整 Rust 代码如下所示：

fn heap_sort(arr: &mut [i32]) {
    // 从最后一个非叶子节点开始，对整个序列进行小根堆的调整
    for i in (0..arr.len() / 2).rev() {
        adjust_heap(arr, i, arr.len());
    }

    // 将堆顶元素与末尾元素交换，将最小元素"沉"到数组末端;
    // 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
    for i in (1..arr.len()).rev() {
        arr.swap(0, i);
        adjust_heap(arr, 0, i);
    }
}

fn adjust_heap(arr: &mut [i32], root: usize, len: usize) {
    let mut child = 2 * root + 1;
    while child < len {
        if child + 1 < len && arr[child] > arr[child + 1] {
            child += 1;
        }
        if arr[root] <= arr[child] {
            return;
        }
        arr.swap(root, child);
        root = child;
        child = 2 * root + 1;
    }
}

fn main() {
    let mut arr = [4, 5, 1, 3, 2, 6];
    heap_sort(&mut arr);
    println!("{:?}", arr);
}

这里，我们演示了一个小根堆的实现方法，其中 `heap_sort` 函数是主函数，`adjust_heap` 函数是辅助函数，用来调整堆。在 `heap_sort` 函数中，我们首先对整个序列进行小根堆的调整，然后将堆顶元素与末尾元素交换，将最小元素"

### 回答2：
Rust语言实现堆排序的完整代码如下：

fn heapify(arr: &mut [i32], n: usize, i: usize) {
    let mut largest = i;
    let left = 2 * i + 1;
    let 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 {
        arr.swap(i, largest);
        heapify(arr, n, largest);
    }
}
  
fn heap_sort(arr: &mut [i32]) {
    let n = arr.len();

    for i in (0..=n / 2 - 1).rev() {
        heapify(arr, n, i);
    }

    for i in (1..n).rev() {
        arr.swap(0, i);
        heapify(arr, i, 0);
    }
}

fn main() {
    let mut arr = [64, 34, 25, 12, 22, 11, 90];
    let n = arr.len();

    heap_sort(&mut arr);

    println!("Sorted array: {:?}", arr);
}

上述代码首先定义了一个辅助函数`heapify`用于维护最大堆结构，然后定义了`heap_sort`函数来实现堆排序。`heap_sort`函数先构建一个最大堆，然后逐个将堆顶元素与未排序部分的最后一个元素互换，然后再重新构建最大堆，重复此过程直到整个数组排序完成。

在`main`函数中，我们声明一个需要进行排序的数组`arr`，然后调用`heap_sort`函数对其进行排序。最后打印排序完成后的数组。

### 回答3：
下面是使用rust语言实现堆排序的完整代码：

fn heapify(arr: &mut [i32], n: usize, i: usize) {
    let mut largest = i;
    let left = 2 * i + 1;
    let 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 {
        arr.swap(i, largest);
        heapify(arr, n, largest);
    }
}

fn heap_sort(arr: &mut [i32]) {
    let n = arr.len();

    for i in (0..=n / 2 - 1).rev() {
        heapify(arr, n, i);
    }

    for i in (1..n).rev() {
        arr.swap(0, i);
        heapify(arr, i, 0);
    }
}

fn main() {
    let mut numbers = [14, 33, 27, 10, 35, 19, 42, 44];
    heap_sort(&mut numbers);
    println!("Sorted array: {:?}", numbers);
}

在这个代码中，`heapify`函数用于构建最大堆，`heap_sort`函数用于对数组进行堆排序。

`heapify`函数接受一个可变的数组`arr`，数组长度`n`以及要进行堆化的起始索引`i`。该函数首先找到当前节点、左子节点以及右子节点中的最大值，并将其索引存入`largest`变量中。接下来，如果最大值不是当前节点，就将当前节点与最大节点交换，并递归地对最大节点进行堆化。通过这样的方式，`heapify`函数可以将给定的数组构建成最大堆。

`heap_sort`函数接受一个可变的数组`arr`，并使用循环将数组构建成最大堆。然后，它从数组的末尾开始，将最大值与数组的当前元素交换，并对剩余的部分进行堆化，最终得到一个有序的数组。

在主函数中，我们声明一个待排序的数组，并调用`heap_sort`函数对其进行排序。最后，我们打印排序后的数组。