堆排序,分别用汇编语言，C语言，C++,java,python编写出来

帆帆资源网

堆排序，就是利用大顶堆或者小顶堆来设计的排序算法，是一种选择排序。堆是一种完全二叉树：

• 大顶堆：每个节点的数值都大于或者等于其左右孩子节点的数值。
• 小顶堆：每个节点的数值都小于或者等于其左右孩子节点的数值。
  
  

堆排序,分别用汇编语言，C语言，C++,java,python编写出来
以下是使用汇编语言、C语言、C++、Java和Python编写的堆排序算法示例代码：
1.汇编语言（x86）代码示例：

1. assembly
   
2. section .data
   
3.     arr db 5, 3, 1, 2, 4
   
4.     n equ $-arr
   
5. section .text
   
6.     global _start
   
7. _start:
   
8.     mov esi, n / 2 - 1 ; 构建初始堆
   
9.     jmp heapify_loop
   
10. heapify_loop:
    
11.     call heapify
    
12.     dec esi
    
13.     cmp esi, 0
    
14.     jge heapify_loop
    
15.     mov esi, n - 1 ; 执行堆排序
    
16.     jmp sort_loop
    
17. sort_loop:
    
18.     mov al, [arr]
    
19.     xchg al, [arr + esi]
    
20.     xchg al, [arr]
    
21.     dec esi
    
22.     cmp esi, 0
    
23.     jge sort_loop
    
24.     jmp exit
    
25. heapify:
    
26.     push esi
    
27.     push ecx
    
28.     push eax
    
29.     mov ecx, esi
    
30.     shl ecx, 1
    
31.     inc ecx
    
32.     cmp ecx, n
    
33.     jge skip_left_child
    
34.     mov al, [arr + ecx]
    
35.     cmp al, [arr + esi]
    
36.     jle skip_left_child
    
37.     mov esi, ecx
    
38. skip_left_child:
    
39.     mov ecx, esi
    
40.     inc ecx
    
41.     cmp ecx, n
    
42.     jge skip_right_child
    
43.     mov al, [arr + ecx]
    
44.     cmp al, [arr + esi]
    
45.     jle skip_right_child
    
46.     mov esi, ecx
    
47. skip_right_child:
    
48.     cmp esi, ecx
    
49.     je skip_swap
    
50.     mov al, [arr + esi]
    
51.     xchg al, [arr + ecx]
    
52.     xchg al, [arr + esi]
    
53.     call heapify
    
54. skip_swap:
    
55.    

复制代码

pop eax
    pop ecx
    pop esi
    ret
exit:
    mov eax, 1 ; 退出系统调用
    xor ebx, ebx ; 返回值为0
    int 0x80 ; 调用系统调用




2.C语言代码示例：

1. #include <stdio.h>
   
2. void heapify(int arr[], int n, int i) {
   
3.     int largest = i;
   
4.     int left = 2 * i + 1;
   
5.     int right = 2 * i + 2;
   
6.     if (left < n && arr[left] > arr[largest]) {
   
7.         largest = left;
   
8.     }
   
9.     if (right < n && arr[right] > arr[largest]) {
   
10.         largest = right;
    
11.     }
    
12.     if (largest != i) {
    
13.         int temp = arr[i];
    
14.         arr[i] = arr[largest];
    
15.         arr[largest] = temp;
    
16.         heapify(arr, n, largest);
    
17.     }
    
18. }
    
19. void heapSort(int arr[], int n) {
    
20.     for (int i = n / 2 - 1; i >= 0; i--) {
    
21.         heapify(arr, n, i);
    
22.     }
    
23.     for (int i = n - 1; i >= 0; i--) {
    
24.         int temp = arr[0];
    
25.         arr[0] = arr[i];
    
26.         arr[i] = temp;
    
27.         heapify(arr, i, 0);
    
28.     }
    
29. }
    
30. 
    

复制代码

int main() {
    int arr[] = {5, 3, 1, 2, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    heapSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr);
    }
    printf("\n");
    return 0;
}




3.C++代码示例：

1. #include <iostream>
   
2. using namespace std;
   
3. void heapify(int arr[], int n, int i) {
   
4.     int largest = i;
   
5.     int left = 2 * i + 1;
   
6.     int right = 2 * i + 2;
   
7.     if (left < n && arr[left] > arr[largest]) {
   
8.         largest = left;
   
9.     }
   
10.     if (right < n && arr[right] > arr[largest]) {
    
11.         largest = right;
    
12.     }
    
13.     if (largest != i) {
    
14.         swap(arr[i], arr[largest]);
    
15.         heapify(arr, n, largest);
    
16.     }
    
17. }
    
18. void heapSort(int arr[], int n) {
    
19.     for (int i = n / 2 - 1; i >= 0; i--) {
    
20.         heapify(arr, n, i);
    
21.     }
    
22.     for (int i = n - 1; i >= 0; i--) {
    
23.         swap(arr[0], arr[i]);
    
24.         heapify(arr, i, 0);
    
25.     }
    
26. }
    
27. 
    

复制代码

int main() {
    int arr[] = {5, 3, 1, 2, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    heapSort(arr, n);
    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr << " ";
    }
    cout << endl;
    return 0;
}




4.Java代码示例：

1. public class HeapSort {
   
2.     public static void heapify(int arr[], int n, int i) {
   
3.         int largest = i;
   
4.         int left = 2 * i + 1;
   
5.         int right = 2 * i + 2;
   
6.         if (left < n && arr[left] > arr[largest]) {
   
7.             largest = left;
   
8.         }
   
9.         if (right < n && arr[right] > arr[largest]) {
   
10.             largest = right;
    
11.         }
    
12.         if (largest != i) {
    
13.             int temp = arr[i];
    
14.             arr[i] = arr[largest];
    
15.             arr[largest] = temp;
    
16.             heapify(arr, n, largest);
    
17.         }
    
18.     }
    
19.     public static void heapSort(int arr[]) {
    
20.         int n = arr.length;
    
21.         for (int i = n / 2 - 1; i >= 0; i--) {
    
22.             heapify(arr, n, i);
    
23.         }
    
24.         for (int i = n - 1; i >= 0; i--) {
    
25.             int temp = arr[0];
    
26.             arr[0] = arr[i];
    
27.             arr[i] = temp;
    
28.             heapify(arr, i, 0);
    
29.         }
    
30.     }
    
31.    
    
32. }

复制代码

public static void main(String args[]) {
        int arr[] = {5, 3, 1, 2, 4};
        heapSort(arr);
        System.out.print("Sorted array: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr + " ");
        }
        System.out.println();
    }




5.Python代码示例：

1. def heapify(arr, n, i):
   
2.     largest = i
   
3.     left = 2 * i + 1
   
4.     right = 2 * i + 2
   
5.     if left < n and arr[left] > arr[largest]:
   
6.         largest = left
   
7.     if right < n and arr[right] > arr[largest]:
   
8.         largest = right
   
9.     if largest != i:
   
10.         arr[i], arr[largest] = arr[largest], arr[i]
    
11.         heapify(arr, n, largest)
    
12. def heapSort(arr):
    
13.     n = len(arr)
    
14.     for i in range(n // 2 - 1, -1, -1):
    
15.         heapify(arr, n, i)
    
16.     for i in range(n - 1, 0, -1):
    
17.         arr[0], arr[i] = arr[i], arr[0]
    
18.         heapify(arr, i, 0)
    
19. 
    

复制代码

arr = [5, 3, 1, 2, 4]
heapSort(arr)
print("Sorted array:", arr)




这些示例代码演示了如何使用汇编语言、C语言、C++、Java和Python编写堆排序算法。请根据您的需求和偏好选择适合您的语言。