feat: Add the section of heap sort. (#516)

* Add the section of heap sort.

* Update heap_sort.cpp

codes/cpp/chapter_sorting/CMakeLists.txt

@@ -1,4 +1,6 @@
+add_executable(selection_sort selection_sort.cpp)
 add_executable(bubble_sort bubble_sort.cpp)
 add_executable(insertion_sort insertion_sort.cpp)
 add_executable(merge_sort merge_sort.cpp)
-add_executable(quick_sort quick_sort.cpp)
+add_executable(quick_sort quick_sort.cpp)
+add_executable(heap_sort heap_sort.cpp)

codes/cpp/chapter_sorting/heap_sort.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: heap_sort.cpp
+ * Created Time: 2023-05-26
+ * Author: Krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+void siftDown(vector<int> &nums, int n, int i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = 2 * i + 1;
+        int r = 2 * i + 2;
+        int ma = i;
+        if (l < n && nums[l] > nums[ma])
+            ma = l;
+        if (r < n && nums[r] > nums[ma])
+            ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        if (ma == i) {
+            break;
+        }
+        // 交换两节点
+        swap(nums[i], nums[ma]);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
+/* 堆排序 */
+void heapSort(vector<int> &nums) {
+    // 建堆操作：堆化除叶节点以外的其他所有节点
+    for (int i = nums.size() / 2 - 1; i >= 0; --i) {
+        siftDown(nums, nums.size(), i);
+    }
+    // 从堆中提取最大元素，循环 n-1 轮
+    for (int i = nums.size() - 1; i > 0; --i) {
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        swap(nums[0], nums[i]);
+        // 以根节点为起点，从顶至底进行堆化
+        siftDown(nums, i, 0);
+    }
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    heapSort(nums);
+    cout << "堆排序完成后 nums = ";
+    printVector(nums);
+
+    return 0;
+}

codes/java/chapter_sorting/heap_sort.java

@@ -0,0 +1,57 @@
+/**
+ * File: heap_sort.java
+ * Created Time: 2023-05-26
+ * Author: Krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.Arrays;
+
+public class heap_sort {
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    public static void siftDown(int[] nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            if (ma == i)
+                break;
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    public static void heapSort(int[] nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 1, 3, 1, 5, 2 };
+        heapSort(nums);
+        System.out.println("堆排序完成后 nums = " + Arrays.toString(nums));
+    }
+}

codes/python/chapter_sorting/heap_sort.py

@@ -0,0 +1,45 @@
+"""
+File: heap_sort.py
+Created Time: 2023-05-24
+Author: Krahets (krahets@163.com)
+"""
+
+
+def sift_down(nums: list[int], n: int, i: int):
+    """堆的长度为 n ，从节点 i 开始，从顶至底堆化"""
+    while True:
+        # 判断节点 i, l, r 中值最大的节点，记为 ma
+        l = 2 * i + 1
+        r = 2 * i + 2
+        ma = i
+        if l < n and nums[l] > nums[ma]:
+            ma = l
+        if r < n and nums[r] > nums[ma]:
+            ma = r
+        # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        if ma == i:
+            break
+        # 交换两节点
+        nums[i], nums[ma] = nums[ma], nums[i]
+        # 循环向下堆化
+        i = ma
+
+
+def heap_sort(nums: list[int]):
+    """堆排序"""
+    # 建堆操作：堆化除叶节点以外的其他所有节点
+    for i in range(len(nums) // 2 - 1, -1, -1):
+        sift_down(nums, len(nums), i)
+    # 从堆中提取最大元素，循环 n-1 轮
+    for i in range(len(nums) - 1, 0, -1):
+        # 交换根节点与最右叶节点（即交换首元素与尾元素）
+        nums[0], nums[i] = nums[i], nums[0]
+        # 以根节点为起点，从顶至底进行堆化
+        sift_down(nums, i, 0)
+        
+
+"""Driver Code"""
+if __name__ == "__main__":
+    nums = [4, 1, 3, 1, 5, 2]
+    heap_sort(nums)
+    print("堆排序完成后 nums =", nums)