Merge pull request #110 from rohits301/rohit

Added some sorting algorithms in Java

Author: argonautica

Java/BitonicSort.java

@@ -0,0 +1,86 @@
+/* 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 function 
+	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); 
+	} 
+} 

Java/CycleSort.java

@@ -0,0 +1,75 @@
+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] + " "); 
+	} 
+} 

Java/PigeonholeSort.java

@@ -0,0 +1,50 @@
+import java.lang.*; 
+import java.util.*; 
+
+public class PigeonholeSort
+{ 
+	public static void pigeonhole_sort(int arr[], 
+										int n) 
+	{ 
+		int min = arr[0]; 
+		int max = arr[0]; 
+		int range, i, j, index; 
+
+		for(int a=0; a<n; a++) 
+		{ 
+			if(arr[a] > max) 
+				max = arr[a]; 
+			if(arr[a] < min) 
+				min = arr[a]; 
+		} 
+
+		range = max - min + 1; 
+		int[] phole = new int[range]; 
+		Arrays.fill(phole, 0); 
+
+		for(i = 0; i<n; i++) 
+			phole[arr[i] - min]++; 
+
+		
+		index = 0; 
+
+		for(j = 0; j<range; j++) 
+			while(phole[j]-->0) 
+				arr[index++]=j+min; 
+
+	} 
+
+	public static void main(String[] args) 
+	{ 
+		PigeonholeSort sort = new PigeonholeSort(); 
+		int[] arr = {8, 3, 2, 7, 4, 6, 8}; 
+
+		System.out.print("Sorted order is : "); 
+
+		sort.pigeonhole_sort(arr,arr.length); 
+		
+		for(int i=0 ; i<arr.length ; i++) 
+			System.out.print(arr[i] + " "); 
+	} 
+
+} 

Java/TreeSort.java

@@ -0,0 +1,87 @@
+
+class TreeSort 
+{ 
+	// Class containing left and 
+	// right child of current 
+	// node and key value 
+	class Node 
+	{ 
+		int key; 
+		Node left, right; 
+
+		public Node(int item) 
+		{ 
+			key = item; 
+			left = right = null; 
+		} 
+	} 
+
+	// Root of BST 
+	Node root; 
+
+	// Constructor 
+	TreeSort() 
+	{ 
+		root = null; 
+	} 
+
+	// This method mainly 
+	// calls insertRec() 
+	void insert(int key) 
+	{ 
+		root = insertRec(root, key); 
+	} 
+	
+	/* A recursive function to 
+	insert a new key in BST */
+	Node insertRec(Node root, int key) 
+	{ 
+
+		/* If the tree is empty, 
+		return a new node */
+		if (root == null) 
+		{ 
+			root = new Node(key); 
+			return root; 
+		} 
+
+		/* Otherwise, recur 
+		down the tree */
+		if (key < root.key) 
+			root.left = insertRec(root.left, key); 
+		else if (key > root.key) 
+			root.right = insertRec(root.right, key); 
+
+		/* return the root */
+		return root; 
+	} 
+	
+	// A function to do 
+	// inorder traversal of BST 
+	void inorderRec(Node root) 
+	{ 
+		if (root != null) 
+		{ 
+			inorderRec(root.left); 
+			System.out.print(root.key + " "); 
+			inorderRec(root.right); 
+		} 
+	} 
+	void treeins(int arr[]) 
+	{ 
+		for(int i = 0; i < arr.length; i++) 
+		{ 
+			insert(arr[i]); 
+		} 
+		
+	} 
+
+	// Driver Code 
+	public static void main(String[] args) 
+	{ 
+		TreeSort tree = new TreeSort(); 
+		int arr[] = {5, 4, 7, 2, 11}; 
+		tree.treeins(arr); 
+		tree.inorderRec(tree.root); 
+	} 
+}