Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored HeapSort

Browse Source
This commit is contained in:
nik 2018-04-10 11:16:28 +03:00
parent 9491b45a05
commit 18a5148576
1 changed files with 99 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

169
Sorts/src/sort/HeapSort.java
View File

@ -1,6 +1,10 @@
package sort;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static sort.SortUtils.*;
/**
* Heap Sort Algorithm
@ -9,52 +13,22 @@ import java.util.Scanner;
* @author Unknown
*
*/
public class HeapSort {
public class HeapSort implements SortAlgorithm {
private static class Heap<T extends Comparable<T>> {
/** Array to store heap */
private int[] heap;
/** The size of the heap */
private int size;
private T[] heap;
/**
* Constructor
*
* @param heap array of unordered integers
*/
public HeapSort(int[] heap) {
this.setHeap(heap);
this.setSize(heap.length);
}
/**
* Setter for variable size
*
* @param length new size
*/
private void setSize(int length) {
this.size = length;
}
/**
* Setter for variable heap
*
* @param heap array of unordered elements
*/
private void setHeap(int[] heap) {
public Heap(T[] heap) {
this.heap = heap;
}
/**
* Swaps index of first with second
*
* @param first First index to switch
* @param second Second index to switch
*/
private void swap(int first, int second) {
int temp = this.heap[first];
this.heap[first] = this.heap[second];
this.heap[second] = temp;
}
/**
* Heapifies subtree from top as root to last as last child
*
@ -64,26 +38,27 @@ public class HeapSort {
private void heapSubtree(int rootIndex, int lastChild) {
int leftIndex = rootIndex * 2 + 1;
int rightIndex = rootIndex * 2 + 2;
int root = this.heap[rootIndex];
T root = heap[rootIndex];
if (rightIndex <= lastChild) { // if has right and left children
int left = this.heap[leftIndex];
int right = this.heap[rightIndex];
if (left < right && left < root) {
this.swap(leftIndex, rootIndex);
this.heapSubtree(leftIndex, lastChild);
} else if (right < root) {
this.swap(rightIndex, rootIndex);
this.heapSubtree(rightIndex, lastChild);
T left = heap[leftIndex];
T right = heap[rightIndex];
if (less(left, right) && less(left, root)) {
swap(heap, leftIndex, rootIndex);
heapSubtree(leftIndex, lastChild);
} else if (less(right, root)) {
swap(heap, rightIndex, rootIndex);
heapSubtree(rightIndex, lastChild);
}
} else if (leftIndex <= lastChild) { // if no right child, but has left child
int left = this.heap[leftIndex];
if (left < root) {
this.swap(leftIndex, rootIndex);
this.heapSubtree(leftIndex, lastChild);
T left = heap[leftIndex];
if (less(left, root)) {
swap(heap, leftIndex, rootIndex);
heapSubtree(leftIndex, lastChild);
}
}
}
/**
* Makes heap with root as root
*
@ -92,14 +67,14 @@ public class HeapSort {
private void makeMinHeap(int root) {
int leftIndex = root * 2 + 1;
int rightIndex = root * 2 + 2;
boolean hasLeftChild = leftIndex < this.heap.length;
boolean hasRightChild = rightIndex < this.heap.length;
boolean hasLeftChild = leftIndex < heap.length;
boolean hasRightChild = rightIndex < heap.length;
if (hasRightChild) { //if has left and right
this.makeMinHeap(leftIndex);
this.makeMinHeap(rightIndex);
this.heapSubtree(root, this.heap.length - 1);
makeMinHeap(leftIndex);
makeMinHeap(rightIndex);
heapSubtree(root, heap.length - 1);
} else if (hasLeftChild) {
this.heapSubtree(root, this.heap.length - 1);
heapSubtree(root, heap.length - 1);
}
}
@ -108,69 +83,49 @@ public class HeapSort {
*
* @return root of heap
*/
private int getRoot() {
this.swap(0, this.size - 1);
this.size--;
this.heapSubtree(0, this.size - 1);
return this.heap[this.size]; // return old root
private T getRoot(int size) {
swap(heap, 0, size);
heapSubtree(0, size - 1);
return heap[size]; // return old root
}
/**
* Sorts heap with heap sort; displays ordered elements to console.
*
* @return sorted array of sorted elements
*/
public final int[] sort() {
this.makeMinHeap(0); // make min heap using index 0 as root.
int[] sorted = new int[this.size];
int index = 0;
while (this.size > 0) {
int min = this.getRoot();
sorted[index] = min;
index++;
}
@Override
public <T extends Comparable<T>> T[] sort(T[] unsorted) {
return sort(Arrays.asList(unsorted)).toArray(unsorted);
}
@Override
public <T extends Comparable<T>> List<T> sort(List<T> unsorted) {
int size = unsorted.size();
@SuppressWarnings("unchecked")
Heap<T> heap = new Heap<>(unsorted.toArray((T[]) new Comparable[unsorted.size()]));
heap.makeMinHeap(0); // make min heap using index 0 as root.
List<T> sorted = new ArrayList<>(size);
while (size > 0) {
T min = heap.getRoot(--size);
sorted.add(min);
}
return sorted;
}
/**
* Gets input to sort
*
* @return unsorted array of integers to sort
*/
public static int[] getInput() {
final int numElements = 6;
int[] unsorted = new int[numElements];
Scanner input = new Scanner(System.in);
System.out.println("Enter any 6 Numbers for Unsorted Array : ");
for (int i = 0; i < numElements; i++) {
unsorted[i] = input.nextInt();
}
input.close();
return unsorted;
}
/**
* Prints elements in heap
*
* @param heap array representing heap
*/
public static void printData(int[] heap) {
System.out.println("Sorted Elements:");
for (int i = 0; i < heap.length; i++) {
System.out.print(" " + heap[i] + " ");
}
}
/**
* Main method
*
* @param args the command line arguments
*/
public static void main(String[] args) {
int[] heap = getInput();
HeapSort data = new HeapSort(heap);
int[] sorted = data.sort();
printData(sorted);
Integer[] heap = {4, 23, 6, 78, 1, 54, 231, 9, 12};
HeapSort heapSort = new HeapSort();
print(heapSort.sort(heap));
}
}