java和php语言实现堆排序算法代码示例

堆排序（Heap Sort）是一种基于堆数据结构的比较排序算法。堆是一棵完全二叉树，分为最大堆和最小堆。最大堆中父节点的值总是大于或等于其子节点的值，而最小堆则相反。堆排序通过构建堆，然后反复将堆顶元素与末尾元素交换，并调整剩余元素为堆，最终实现排序。堆排序也是常见的算法题目。

Java实现堆排序算法

public class HeapSort {
    public 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);
        }
    }

    // To heapify a subtree rooted with node i which is an index in arr[]. n is size of heap
    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);
        }
    }

    // A utility function to print array of size n
    static void printArray(int arr[]) {
        int n = arr.length;
        for (int i = 0; i < n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver code
    public static void main(String args[]) {
        int arr[] = {12, 11, 13, 5, 6, 7};
        int n = arr.length;

        HeapSort ob = new HeapSort();
        ob.sort(arr);

        System.out.println("Sorted array is");
        printArray(arr);
    }
}

PHP实现堆排序算法

<?php
class HeapSort {
    private $arr;
    private $n;

    public function __construct($arr) {
        $this->arr = $arr;
        $this->n = count($arr);
    }

    public function sort() {
        // Build heap (rearrange array)
        for ($i = floor($this->n / 2) - 1; $i >= 0; $i--) {
            $this->heapify($i);
        }

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

            // call max heapify on the reduced heap
            $this->heapify(0, $i);
        }
    }

    private function heapify($i, $size = null) {
        if ($size === null) {
            $size = $this->n;
        }
        $largest = $i; // Initialize largest as root
        $l = 2 * $i + 1; // left = 2*i + 1
        $r = 2 * $i + 2; // right = 2*i + 2

        // If left child is larger than root
        if ($l < $size && $this->arr[$l] > $this->arr[$largest]) {
            $largest = $l;
        }

        // If right child is larger than largest so far
        if ($r < $size && $this->arr[$r] > $this->arr[$largest]) {
            $largest = $r;
        }

        // If largest is not root
        if ($largest != $i) {
            $swap = $this->arr[$i];
            $this->arr[$i] = $this->arr[$largest];
            $this->arr[$largest] = $swap;

            // Recursively heapify the affected sub-tree
            $this->heapify($largest, $size);
        }
    }

    public function getArray() {
        return $this->arr;
    }
}

// Example usage:
$arr = [12, 11, 13, 5, 6, 7];
$heapSort = new HeapSort($arr);
$heapSort->sort();
print_r($heapSort->getArray());
?>