|
1 |
| -// Java program for implementation of Heap Sort |
| 1 | +import java.util.*; |
2 | 2 | public class HeapSort {
|
3 |
| - public void sort(int arr[]) |
4 |
| - { |
5 |
| - int n = arr.length; |
6 |
| - |
7 |
| - // Build heap (rearrange array) |
8 |
| - for (int i = n / 2 - 1; i >= 0; i--) |
9 |
| - heapify(arr, n, i); |
10 |
| - |
11 |
| - // One by one extract an element from heap |
12 |
| - for (int i = n - 1; i >= 0; i--) { |
13 |
| - // Move current root to end |
14 |
| - int temp = arr[0]; |
15 |
| - arr[0] = arr[i]; |
16 |
| - arr[i] = temp; |
17 |
| - |
18 |
| - // call max heapify on the reduced heap |
19 |
| - heapify(arr, i, 0); |
| 3 | + public void sort(int arr[]) |
| 4 | + { |
| 5 | + int N = arr.length; |
| 6 | + |
| 7 | + for (int i = N / 2 - 1; i >= 0; i--) |
| 8 | + heapify(arr, N, i); |
| 9 | + |
| 10 | + for (int i = N - 1; i > 0; i--) { |
| 11 | + |
| 12 | + int x = arr[0]; |
| 13 | + arr[0] = arr[i]; |
| 14 | + arr[i] = x; |
| 15 | + |
| 16 | + heapify(arr, i, 0); |
| 17 | + } |
| 18 | + } |
| 19 | + |
| 20 | + void heapify(int arr[], int N, int i) |
| 21 | + { |
| 22 | + int largest = i; |
| 23 | + int l = 2 * i + 1; |
| 24 | + int r = 2 * i + 2; |
| 25 | + |
| 26 | + if (l < N && arr[l] > arr[largest]) |
| 27 | + largest = l; |
| 28 | + |
| 29 | + if (r < N && arr[r] > arr[largest]) |
| 30 | + largest = r; |
| 31 | + |
| 32 | + if (largest != i) { |
| 33 | + int swap = arr[i]; |
| 34 | + arr[i] = arr[largest]; |
| 35 | + arr[largest] = swap; |
| 36 | + |
| 37 | + heapify(arr, N, largest); |
| 38 | + } |
20 | 39 | }
|
21 |
| - } |
22 |
| - |
23 |
| - // To heapify a subtree rooted with node i which is |
24 |
| - // an index in arr[]. n is size of heap |
25 |
| - void heapify(int arr[], int n, int i) |
26 |
| - { |
27 |
| - int largest = i; // Initialize largest as root |
28 |
| - int l = 2 * i + 1; // left = 2*i + 1 |
29 |
| - int r = 2 * i + 2; // right = 2*i + 2 |
30 |
| - |
31 |
| - // If left child is larger than root |
32 |
| - if (l < n && arr[l] > arr[largest]) |
33 |
| - largest = l; |
34 |
| - |
35 |
| - // If right child is larger than largest so far |
36 |
| - if (r < n && arr[r] > arr[largest]) |
37 |
| - largest = r; |
38 |
| - |
39 |
| - // If largest is not root |
40 |
| - if (largest != i) { |
41 |
| - int swap = arr[i]; |
42 |
| - arr[i] = arr[largest]; |
43 |
| - arr[largest] = swap; |
44 |
| - |
45 |
| - // Recursively heapify the affected sub-tree |
46 |
| - heapify(arr, n, largest); |
| 40 | + static void printArray(int arr[]) |
| 41 | + { |
| 42 | + int N = arr.length; |
| 43 | + |
| 44 | + for (int i = 0; i < N; ++i) |
| 45 | + System.out.print(arr[i] + " "); |
| 46 | + System.out.println(); |
| 47 | + } |
| 48 | + |
| 49 | + public static void main(String args[]) |
| 50 | + { |
| 51 | + int i, n, arr[]; |
| 52 | + |
| 53 | + Scanner s = new Scanner(System.in); |
| 54 | + System.out.println("Enter no. of elements in aray:"); |
| 55 | + n = s.nextInt(); |
| 56 | + |
| 57 | + arr = new int[n]; |
| 58 | + |
| 59 | + System.out.println("Enter " + n + " integers:"); |
| 60 | + |
| 61 | + for (i = 0;i<n; i++) |
| 62 | + arr[i] = s.nextInt(); |
| 63 | + |
| 64 | + HeapSort ob = new HeapSort(); |
| 65 | + ob.sort(arr); |
| 66 | + |
| 67 | + System.out.println("Sorted array is"); |
| 68 | + printArray(arr); |
47 | 69 | }
|
48 |
| - } |
49 |
| - |
50 |
| - /* A utility function to print array of size n */ |
51 |
| - static void printArray(int arr[]) |
52 |
| - { |
53 |
| - int n = arr.length; |
54 |
| - for (int i = 0; i < n; ++i) |
55 |
| - System.out.print(arr[i] + " "); |
56 |
| - System.out.println(); |
57 |
| - } |
58 |
| - |
59 |
| - // Driver program |
60 |
| - public static void main(String args[]) |
61 |
| - { |
62 |
| - int arr[] = { 12, 11, 13, 5, 6, 7 }; |
63 |
| - int n = arr.length; |
64 |
| - |
65 |
| - HeapSort ob = new HeapSort(); |
66 |
| - ob.sort(arr); |
67 |
| - |
68 |
| - System.out.println("Sorted array is"); |
69 |
| - printArray(arr); |
70 |
| - } |
| 70 | + |
| 71 | + |
71 | 72 | }
|
0 commit comments