diff --git a/src/com/jwetherell/algorithms/sorts/BitonicSort.java b/src/com/jwetherell/algorithms/sorts/BitonicSort.java
new file mode 100644
index 00000000..650aa13a
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/BitonicSort.java
@@ -0,0 +1,86 @@
+/* Java program for Bitonic Sort. Note that this program 
+works only when size of input is a power of 2. */
+public class BitonicSort 
+{ 
+	/* The parameter dir indicates the sorting direction, 
+	ASCENDING or DESCENDING; if (a[i] > a[j]) agrees 
+	with the direction, then a[i] and a[j] are 
+	interchanged. */
+	void compAndSwap(int a[], int i, int j, int dir) 
+	{ 
+		if ( (a[i] > a[j] && dir == 1) || 
+			(a[i] < a[j] && dir == 0)) 
+		{ 
+			// Swapping elements 
+			int temp = a[i]; 
+			a[i] = a[j]; 
+			a[j] = temp; 
+		} 
+	} 
+
+	/* It recursively sorts a bitonic sequence in ascending 
+	order, if dir = 1, and in descending order otherwise 
+	(means dir=0). The sequence to be sorted starts at 
+	index position low, the parameter cnt is the number 
+	of elements to be sorted.*/
+	void bitonicMerge(int a[], int low, int cnt, int dir) 
+	{ 
+		if (cnt>1) 
+		{ 
+			int k = cnt/2; 
+			for (int i=low; i<low+k; i++) 
+				compAndSwap(a,i, i+k, dir); 
+			bitonicMerge(a,low, k, dir); 
+			bitonicMerge(a,low+k, k, dir); 
+		} 
+	} 
+
+	/* This funcion first produces a bitonic sequence by 
+	recursively sorting its two halves in opposite sorting 
+	orders, and then calls bitonicMerge to make them in 
+	the same order */
+	void bitonicSort(int a[], int low, int cnt, int dir) 
+	{ 
+		if (cnt>1) 
+		{ 
+			int k = cnt/2; 
+
+			// sort in ascending order since dir here is 1 
+			bitonicSort(a, low, k, 1); 
+
+			// sort in descending order since dir here is 0 
+			bitonicSort(a,low+k, k, 0); 
+
+			// Will merge wole sequence in ascending order 
+			// since dir=1. 
+			bitonicMerge(a, low, cnt, dir); 
+		} 
+	} 
+
+	/*Caller of bitonicSort for sorting the entire array 
+	of length N in ASCENDING order */
+	void sort(int a[], int N, int up) 
+	{ 
+		bitonicSort(a, 0, N, up); 
+	} 
+
+	/* A utility function to print array of size n */
+	static void printArray(int arr[]) 
+	{ 
+		int n = arr.length; 
+		for (int i=0; i<n; ++i) 
+			System.out.print(arr[i] + " "); 
+		System.out.println(); 
+	} 
+
+	// Driver method 
+	public static void main(String args[]) 
+	{ 
+		int a[] = {3, 7, 4, 8, 6, 2, 1, 5}; 
+		int up = 1; 
+		BitonicSort ob = new BitonicSort(); 
+		ob.sort(a, a.length,up); 
+		System.out.println("\nSorted array"); 
+		printArray(a); 
+	} 
+} 
diff --git a/src/com/jwetherell/algorithms/sorts/BogoSort.java b/src/com/jwetherell/algorithms/sorts/BogoSort.java
new file mode 100644
index 00000000..dfbab31c
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/BogoSort.java
@@ -0,0 +1,59 @@
+// Java Program to implement BogoSort 
+public class BogoSort 
+{ 
+	// Sorts array a[0..n-1] using Bogo sort 
+	void bogoSort(int[] a) 
+	{ 
+		// if array is not sorted then shuffle the 
+		// array again 
+		while (isSorted(a) == false) 
+			shuffle(a); 
+	} 
+
+	// To generate permuatation of the array 
+	void shuffle(int[] a) 
+	{ 
+		// Math.random() returns a double positive 
+		// value, greater than or equal to 0.0 and 
+		// less than 1.0. 
+		for (int i=1; i <= n; i++) 
+			swap(a, i, (int)(Math.random()*i)); 
+	} 
+
+	// Swapping 2 elements 
+	void swap(int[] a, int i, int j) 
+	{ 
+		int temp = a[i]; 
+		a[i] = a[j]; 
+		a[j] = temp; 
+	} 
+
+	// To check if array is sorted or not 
+	boolean isSorted(int[] a) 
+	{ 
+		for (int i=1; i<a.length; i++) 
+			if (a[i] < a[i-1]) 
+				return false; 
+		return true; 
+	} 
+
+	// Prints the array 
+	void printArray(int[] arr) 
+	{ 
+		for (int i=0; i<arr.length; i++) 
+			System.out.print(arr[i] + " "); 
+		System.out.println(); 
+	} 
+
+	public static void main(String[] args) 
+	{ 
+		//Enter array to be sorted here 
+		int[] a = {3, 2, 5, 1, 0, 4}; 
+		BogoSort ob = new BogoSort(); 
+
+		ob.bogoSort(a); 
+
+		System.out.print("Sorted array: "); 
+		ob.printArray(a); 
+	} 
+} 
diff --git a/src/com/jwetherell/algorithms/sorts/BucketSort.java b/src/com/jwetherell/algorithms/sorts/BucketSort.java
new file mode 100644
index 00000000..3400cef2
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/BucketSort.java
@@ -0,0 +1,50 @@
+import java.util.ArrayList;
+import java.util.Arrays; 
+import java.util.Collections; 
+import java.util.List; 
+/* 
+* Java Program sort an integer array using radix sort algorithm. 
+* input: [80, 50, 30, 10, 90, 60, 0, 70, 40, 20, 50] 
+* output: [0, 10, 20, 30, 40, 50, 50, 60, 70, 80, 90]  
+* Time Complexity of Solution:
+* Best Case O(n); Average Case O(n); Worst Case O(n^2).
+*/
+public class BucketSort { 
+	public static void main(String[] args) {
+		System.out.println("Bucket sort in Java"); 
+		int[] input = { 80, 50, 30, 10, 90, 60, 0, 70, 40, 20, 50 }; 
+		System.out.println("integer array before sorting"); 
+		System.out.println(Arrays.toString(input)); // sorting array using radix Sort Algorithm 
+		bucketSort(input); 
+		System.out.println("integer array after sorting using bucket sort algorithm"); 
+		System.out.println(Arrays.toString(input)); 
+	} 
+	/** * * @param input */ 
+	public static void bucketSort(int[] input) { // get hash codes 
+		final int[] code = hash(input); // create and initialize buckets to ArrayList: O(n) 
+		List[] buckets = new List[code[1]]; 
+		for (int i = 0; i < code[1]; i++) { 
+			buckets[i] = new ArrayList(); 
+		} // distribute data into buckets: O(n) 
+		for (int i : input) { 
+			buckets[hash(i, code)].add(i); } // sort each bucket O(n) 
+			for (List bucket : buckets) { 
+				Collections.sort(bucket); 
+			} 
+			int ndx = 0; // merge the buckets: O(n) 
+			for (int b = 0; b < buckets.length; b++) { 
+				for (int v : buckets[b]) { 
+					input[ndx++] = v; }
+			}
+		} /** * * @param input * @return an array containing hash of input */ 
+		private static int[] hash(int[] input) { 
+			int m = input[0]; 
+			for (int i = 1; i < input.length; i++) { 
+				if (m < input[i]) { 
+					m = input[i]; } 
+				} return new int[] { m, (int) Math.sqrt(input.length) }; 
+			} /** * * @param i * @param code * @return */ 
+		private static int hash(int i, int[] code) { 
+			return (int) ((double) i / code[0] * (code[1] - 1)); 
+		} 
+}
\ No newline at end of file
diff --git a/src/com/jwetherell/algorithms/sorts/CocktailSort.java b/src/com/jwetherell/algorithms/sorts/CocktailSort.java
new file mode 100644
index 00000000..f24b24dd
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/CocktailSort.java
@@ -0,0 +1,74 @@
+// Java program for implementation of Cocktail Sort 
+public class CocktailSort { 
+	void cocktailSort(int a[]) 
+	{ 
+		boolean swapped = true; 
+		int start = 0; 
+		int end = a.length; 
+
+		while (swapped == true) { 
+			// reset the swapped flag on entering the 
+			// loop, because it might be true from a 
+			// previous iteration. 
+			swapped = false; 
+
+			// loop from bottom to top same as 
+			// the bubble sort 
+			for (int i = start; i < end - 1; ++i) { 
+				if (a[i] > a[i + 1]) { 
+					int temp = a[i]; 
+					a[i] = a[i + 1]; 
+					a[i + 1] = temp; 
+					swapped = true; 
+				} 
+			} 
+
+			// if nothing moved, then array is sorted. 
+			if (swapped == false) 
+				break; 
+
+			// otherwise, reset the swapped flag so that it 
+			// can be used in the next stage 
+			swapped = false; 
+
+			// move the end point back by one, because 
+			// item at the end is in its rightful spot 
+			end = end - 1; 
+
+			// from top to bottom, doing the 
+			// same comparison as in the previous stage 
+			for (int i = end - 1; i >= start; i--) { 
+				if (a[i] > a[i + 1]) { 
+					int temp = a[i]; 
+					a[i] = a[i + 1]; 
+					a[i + 1] = temp; 
+					swapped = true; 
+				} 
+			} 
+
+			// increase the starting point, because 
+			// the last stage would have moved the next 
+			// smallest number to its rightful spot. 
+			start = start + 1; 
+		} 
+	} 
+
+	/* Prints the array */
+	void printArray(int a[]) 
+	{ 
+		int n = a.length; 
+		for (int i = 0; i < n; i++) 
+			System.out.print(a[i] + " "); 
+		System.out.println(); 
+	} 
+
+	// Driver method 
+	public static void main(String[] args) 
+	{ 
+		CocktailSort ob = new CocktailSort(); 
+		int a[] = { 5, 1, 4, 2, 8, 0, 2 }; 
+		ob.cocktailSort(a); 
+		System.out.println("Sorted array"); 
+		ob.printArray(a); 
+	} 
+} 
diff --git a/src/com/jwetherell/algorithms/sorts/CombSort.java b/src/com/jwetherell/algorithms/sorts/CombSort.java
new file mode 100644
index 00000000..b99ddb85
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/CombSort.java
@@ -0,0 +1,67 @@
+// Java program for implementation of Comb Sort 
+class CombSort 
+{ 
+	// To find gap between elements 
+	int getNextGap(int gap) 
+	{ 
+		// Shrink gap by Shrink factor 
+		gap = (gap*10)/13; 
+		if (gap < 1) 
+			return 1; 
+		return gap; 
+	} 
+
+	// Function to sort arr[] using Comb Sort 
+	void sort(int arr[]) 
+	{ 
+		int n = arr.length; 
+
+		// initialize gap 
+		int gap = n; 
+
+		// Initialize swapped as true to make sure that 
+		// loop runs 
+		boolean swapped = true; 
+
+		// Keep running while gap is more than 1 and last 
+		// iteration caused a swap 
+		while (gap != 1 || swapped == true) 
+		{ 
+			// Find next gap 
+			gap = getNextGap(gap); 
+
+			// Initialize swapped as false so that we can 
+			// check if swap happened or not 
+			swapped = false; 
+
+			// Compare all elements with current gap 
+			for (int i=0; i<n-gap; i++) 
+			{ 
+				if (arr[i] > arr[i+gap]) 
+				{ 
+					// Swap arr[i] and arr[i+gap] 
+					int temp = arr[i]; 
+					arr[i] = arr[i+gap]; 
+					arr[i+gap] = temp; 
+
+					// Set swapped 
+					swapped = true; 
+				} 
+			} 
+		} 
+	} 
+
+	// Driver method 
+	public static void main(String args[]) 
+	{ 
+		CombSort ob = new CombSort(); 
+		int arr[] = {8, 4, 1, 56, 3, -44, 23, -6, 28, 0}; 
+		ob.sort(arr); 
+
+		System.out.println("sorted array"); 
+		for (int i=0; i<arr.length; ++i) 
+			System.out.print(arr[i] + " "); 
+
+	} 
+} 
+/* This code is contributed by Rajat Mishra */
diff --git a/src/com/jwetherell/algorithms/sorts/CountingSort.java b/src/com/jwetherell/algorithms/sorts/CountingSort.java
index f1593c50..a97a4394 100644
--- a/src/com/jwetherell/algorithms/sorts/CountingSort.java
+++ b/src/com/jwetherell/algorithms/sorts/CountingSort.java
@@ -1,60 +1,54 @@
-package com.jwetherell.algorithms.sorts;
-
-/**
- * Counting sort is an algorithm for sorting a collection of objects according
- * to keys that are small integers; that is, it is an integer sorting algorithm.
- * It operates by counting the number of objects that have each distinct key
- * value, and using arithmetic on those counts to determine the positions of
- * each key value in the output sequence. 
- * <p>
- * Family: Counting.<br>
- * Space: An Array of length r.<br> 
- * Stable: True.<br>
- * <p>
- * Average case = O(n+r)<br>
- * Worst case = O(n+r)<br>
- * Best case = O(n+r)<br>
- * <p> 
- * NOTE: r is the range of numbers (0 to r) to be sorted.
- * <p>
- * @see <a href="https://en.wikipedia.org/wiki/Counting_sort">Counting Sort (Wikipedia)</a>
- * <br>
- * @author Justin Wetherell <phishman3579@gmail.com>
- */
-public class CountingSort {
-
-    private CountingSort() { }
-
-    public static Integer[] sort(Integer[] unsorted) {
-        int maxValue = findMax(unsorted);
-        int[] counts = new int[maxValue + 1];
-        updateCounts(unsorted, counts);
-        populateCounts(unsorted, counts);
-        return unsorted;
-    }
-
-    private static int findMax(Integer[] unsorted) {
-        int max = Integer.MIN_VALUE;
-        for (int i : unsorted) {
-            if (i > max)
-                max = i;
-        }
-        return max;
-    }
-
-    private static void updateCounts(Integer[] unsorted, int[] counts) {
-        for (int e : unsorted)
-            counts[e]++;
-    }
-
-    private static void populateCounts(Integer[] unsorted, int[] counts) {
-        int index = 0;
-        for (int i = 0; i < counts.length; i++) {
-            int e = counts[i];
-            while (e > 0) {
-                unsorted[index++] = i;
-                e--;
-            }
-        }
-    }
-}
+// Java implementation of Counting Sort 
+class CountingSort 
+{ 
+	void sort(char arr[]) 
+	{ 
+		int n = arr.length; 
+
+		// The output character array that will have sorted arr 
+		char output[] = new char[n]; 
+
+		// Create a count array to store count of inidividul 
+		// characters and initialize count array as 0 
+		int count[] = new int[256]; 
+		for (int i=0; i<256; ++i) 
+			count[i] = 0; 
+
+		// store count of each character 
+		for (int i=0; i<n; ++i) 
+			++count[arr[i]]; 
+
+		// Change count[i] so that count[i] now contains actual 
+		// position of this character in output array 
+		for (int i=1; i<=255; ++i) 
+			count[i] += count[i-1]; 
+
+		// Build the output character array 
+		// To make it stable we are operating in reverse order. 
+		for (int i = n-1; i>=0; i--) 
+		{ 
+			output[count[arr[i]]-1] = arr[i]; 
+			--count[arr[i]]; 
+		} 
+
+		// Copy the output array to arr, so that arr now 
+		// contains sorted characters 
+		for (int i = 0; i<n; ++i) 
+			arr[i] = output[i]; 
+	} 
+
+	// Driver method 
+	public static void main(String args[]) 
+	{ 
+		CountingSort ob = new CountingSort(); 
+		char arr[] = {'c', 'o', 'u', 'n', 't', 'i', 'n', 
+					'g', 's', 'o', 'r', 't', 's'
+					}; 
+
+		ob.sort(arr); 
+
+		System.out.print("Sorted character array is "); 
+		for (int i=0; i<arr.length; ++i) 
+			System.out.print(arr[i]); 
+	} 
+}
\ No newline at end of file
diff --git a/src/com/jwetherell/algorithms/sorts/CycleSort.java b/src/com/jwetherell/algorithms/sorts/CycleSort.java
new file mode 100644
index 00000000..275cbf7f
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/CycleSort.java
@@ -0,0 +1,77 @@
+// Java program to implement cycle sort 
+
+import java.util.*; 
+import java.lang.*; 
+
+class CycleSort { 
+	// Function sort the array using Cycle sort 
+	public static void cycleSort(int arr[], int n) 
+	{ 
+		// count number of memory writes 
+		int writes = 0; 
+
+		// traverse array elements and put it to on 
+		// the right place 
+		for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++) { 
+			// initialize item as starting point 
+			int item = arr[cycle_start]; 
+
+			// Find position where we put the item. We basically 
+			// count all smaller elements on right side of item. 
+			int pos = cycle_start; 
+			for (int i = cycle_start + 1; i < n; i++) 
+				if (arr[i] < item) 
+					pos++; 
+
+			// If item is already in correct position 
+			if (pos == cycle_start) 
+				continue; 
+
+			// ignore all duplicate elements 
+			while (item == arr[pos]) 
+				pos += 1; 
+
+			// put the item to it's right position 
+			if (pos != cycle_start) { 
+				int temp = item; 
+				item = arr[pos]; 
+				arr[pos] = temp; 
+				writes++; 
+			} 
+
+			// Rotate rest of the cycle 
+			while (pos != cycle_start) { 
+				pos = cycle_start; 
+
+				// Find position where we put the element 
+				for (int i = cycle_start + 1; i < n; i++) 
+					if (arr[i] < item) 
+						pos += 1; 
+
+				// ignore all duplicate elements 
+				while (item == arr[pos]) 
+					pos += 1; 
+
+				// put the item to it's right position 
+				if (item != arr[pos]) { 
+					int temp = item; 
+					item = arr[pos]; 
+					arr[pos] = temp; 
+					writes++; 
+				} 
+			} 
+		} 
+	} 
+
+	// Driver program to test above function 
+	public static void main(String[] args) 
+	{ 
+		int arr[] = { 1, 8, 3, 9, 10, 10, 2, 4 }; 
+		int n = arr.length; 
+		cycleSort(arr, n); 
+
+		System.out.println("After sort : "); 
+		for (int i = 0; i < n; i++) 
+			System.out.print(arr[i] + " "); 
+	} 
+} 
\ No newline at end of file
diff --git a/src/com/jwetherell/algorithms/sorts/TopologicalSort.java b/src/com/jwetherell/algorithms/sorts/TopologicalSort.java
new file mode 100644
index 00000000..d60b69e6
--- /dev/null
+++ b/src/com/jwetherell/algorithms/sorts/TopologicalSort.java
@@ -0,0 +1,81 @@
+// A Java program to print topological sorting of a DAG 
+import java.io.*; 
+import java.util.*; 
+
+// This class represents a directed graph using adjacency 
+// list representation 
+class TopologicalSort { 
+	private int V; // No. of vertices 
+	private LinkedList<Integer> adj[]; // Adjacency List 
+
+	//Constructor 
+	TopologicalSort(int v) { 
+		V = v; 
+		adj = new LinkedList[v]; 
+		for (int i=0; i<v; ++i) 
+			adj[i] = new LinkedList(); 
+	} 
+
+	void addEdge(int v,int w) { adj[v].add(w); } 
+
+	// A recursive function used by topologicalSort 
+	void topologicalSortUtil(int v, boolean visited[], 
+							Stack stack) 
+	{ 
+		// Mark the current node as visited. 
+		visited[v] = true; 
+		Integer i; 
+
+		// Recur for all the vertices adjacent to this 
+		// vertex 
+		Iterator<Integer> it = adj[v].iterator(); 
+		while (it.hasNext()) 
+		{ 
+			i = it.next(); 
+			if (!visited[i]) 
+				topologicalSortUtil(i, visited, stack); 
+		} 
+
+		// Push current vertex to stack which stores result 
+		stack.push(new Integer(v)); 
+	} 
+
+	// The function to do Topological Sort. It uses 
+	// recursive topologicalSortUtil() 
+	void topologicalSort() 
+	{ 
+		Stack stack = new Stack(); 
+
+		// Mark all the vertices as not visited 
+		boolean visited[] = new boolean[V]; 
+		for (int i = 0; i < V; i++) 
+			visited[i] = false; 
+
+		// Call the recursive helper function to store 
+		// Topological Sort starting from all vertices 
+		// one by one 
+		for (int i = 0; i < V; i++) 
+			if (visited[i] == false) 
+				topologicalSortUtil(i, visited, stack); 
+
+		// Print contents of stack 
+		while (stack.empty()==false) 
+			System.out.print(stack.pop() + " "); 
+	} 
+
+	// Driver method 
+	public static void main(String args[]) 
+	{ 
+		// Create a graph given in the above diagram 
+		TopologicalSort g = new TopologicalSort(6); 
+		g.addEdge(5, 2); 
+		g.addEdge(5, 0); 
+		g.addEdge(4, 0); 
+		g.addEdge(4, 1); 
+		g.addEdge(2, 3); 
+		g.addEdge(3, 1); 
+
+		System.out.println("Following is a Topological " + "sort of the given graph"); 
+		g.topologicalSort(); 
+	} 
+}