Added a heapsort implementation & recursive reverse of SinglyLinkedList

src/TechInterview/HeapSort.java

@@ -0,0 +1,58 @@
+package TechInterview;
+
+import java.util.Arrays;
+
+public class HeapSort {
+
+	public static int[] heapSort(int list[]) {
+		int size = list.length;
+
+		for (int i = size/2 - 1; i >= 0; i--) {
+			heapify(list, size, i);
+		}
+
+		for(int i = list.length-1; i >= 0; i--) {
+			int swap = list[0];
+			list[0] = list[i];
+			list[i] = swap;
+			size--;
+			heapify(list, size, 0);
+		}
+		return list;
+	}
+
+	private static int leftChild(int i) {
+		return 2 * i + 1;
+	}
+
+	private static int rightChild(int i) {
+		return 2 * i + 2;
+	}
+
+	private static void heapify(int[] list, int size, int i) {
+		int largestElementIndex = i;
+		int leftChildIndex = leftChild(i);
+		if (leftChildIndex < size && list[leftChildIndex] > list[largestElementIndex]) {
+			largestElementIndex = leftChildIndex;
+		}
+
+		int rightChildIndex = rightChild(i);
+  		if (rightChildIndex < size && list[rightChildIndex] > list[largestElementIndex]) {
+	  		largestElementIndex = rightChildIndex;
+  		}
+		if (largestElementIndex != i) {
+			int swap = list[i];
+			list[i] = list[largestElementIndex];
+			list[largestElementIndex] = swap;
+			heapify(list, size, largestElementIndex);
+		}
+	}
+
+	public static void main(String[] args) {
+		int[] list = {9, 8, 10, 3, 5, 4, 7, 2, 1, 6};
+		System.out.println(Arrays.toString(list));
+
+		heapSort(list);
+		System.out.println(Arrays.toString(list));
+	}
+}

src/TechInterview/SinglyLinkedList.java

@@ -54,11 +54,11 @@ public E get(int index) {
         return null;
     }
 
-    public void reverseOrder() {
+    public void reverseOrderIteratively() {
         Node prev = null;
         Node curr = head;
         Node next;
-        
+
         while (curr != null) {
             next = curr.next;
             curr.next = prev;
@@ -67,6 +67,30 @@ public void reverseOrder() {
         }
         head.next = prev;
     }
+
+    public void reverseOrderRecursively() {
+        Node prev = null;
+        Node curr = head;
+
+        if (head == null) {
+            return;
+        } else {
+            reverseHelper(curr, prev);
+        }
+    }
+
+    Node reverseHelper(Node curr, Node prev) {
+        if (curr.next == null) {
+            head = curr;
+            curr.next = prev;
+            return null;
+        }
+
+        Node next = curr.next;
+        curr.next = prev;
+        reverseHelper(next, curr);
+        return head;
+    }
 
     @Override
     public String toString() {
@@ -114,7 +138,10 @@ public static void main(String[] args) {
         ll.remove(0);
         System.out.println(ll);
 
-        ll.reverseOrder();
+        ll.reverseOrderIteratively();
+        System.out.println(ll);
+
+        ll.reverseOrderRecursively();
         System.out.println(ll);
     }
 }