Merge pull request #116 from diwakar1593/main

Create CocktailSort.java

Author: Ritikraja07

CocktailSort.java

@@ -0,0 +1,79 @@
+// 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 code
+	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);
+	}
+}

PigeonholeSort.java

@@ -0,0 +1,54 @@
+/* Java program to implement Pigeonhole Sort */
+
+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] + " ");
+	}
+
+}
+
+

bubblesort.java

@@ -1,35 +1,27 @@
-public class BubbleSortExample {  
-    static void bubbleSort(int[] arr) {  
-        int n = arr.length;  
-        int temp = 0;  
-         for(int i=0; i < n; i++){  
-                 for(int j=1; j < (n-i); j++){  
-                          if(arr[j-1] > arr[j]){  
-                                 //swap elements  
-                                 temp = arr[j-1];  
-                                 arr[j-1] = arr[j];  
-                                 arr[j] = temp;  
-                         }  
-                          
-                 }  
-         }  
-  
-    }  
-    public static void main(String[] args) {  
-                int arr[] ={3,60,35,2,45,320,5};  
-                 
-                System.out.println("Array Before Bubble Sort");  
-                for(int i=0; i < arr.length; i++){  
-                        System.out.print(arr[i] + " ");  
-                }  
-                System.out.println();  
-                  
-                bubbleSort(arr);//sorting array elements using bubble sort  
-                 
-                System.out.println("Array After Bubble Sort");  
-                for(int i=0; i < arr.length; i++){  
-                        System.out.print(arr[i] + " ");  
-                }  
-   
-        }  
-}  
+import java.util.Scanner;
+public class BubbleSort {
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        System.out.println("Enter the  number of elements");
+        int n = sc.nextInt();
+        
+        int[] arr = new int[n];
+        System.out.println("Enter the elements");
+        for(int i = 0 ; i<n;i++){
+            arr[i]=sc.nextInt();
+        }
+            for(int i = 0 ; i<n;i++){
+                for(int j=0;j<n-i-1;j++){
+                    if(arr[j]> arr[j+1]){
+                        int temp = arr[j];
+                        arr[j]= arr[j+1];
+                        arr[j+1]= temp;
+                    }
+                }
+            }
+            System.out.println("sorted array is ");
+            for(int i = 0;i<n;i++){
+                System.out.println(arr[i]+" ");
+            }
+    }}     
+       

heapsort.java

@@ -1,71 +1,72 @@
-// Java program for implementation of Heap Sort
+import java.util.*;
 public class HeapSort {
-	public void sort(int arr[])
-	{
-		int n = arr.length;
-
-		// Build heap (rearrange array)
-		for (int i = n / 2 - 1; i >= 0; i--)
-			heapify(arr, n, i);
-
-		// One by one extract an element from heap
-		for (int i = n - 1; i >= 0; i--) {
-			// Move current root to end
-			int temp = arr[0];
-			arr[0] = arr[i];
-			arr[i] = temp;
-
-			// call max heapify on the reduced heap
-			heapify(arr, i, 0);
+		public void sort(int arr[])
+		{
+			int N = arr.length;
+
+			for (int i = N / 2 - 1; i >= 0; i--)
+				heapify(arr, N, i);
+
+			for (int i = N - 1; i > 0; i--) {
+
+				int x = arr[0];
+				arr[0] = arr[i];
+				arr[i] = x;
+
+				heapify(arr, i, 0);
+			}
+		}
+
+		void heapify(int arr[], int N, int i)
+		{
+			int largest = i; 
+			int l = 2 * i + 1; 
+			int r = 2 * i + 2; 
+
+			if (l < N && arr[l] > arr[largest])
+				largest = l;
+
+			if (r < N && arr[r] > arr[largest])
+				largest = r;
+
+			if (largest != i) {
+				int swap = arr[i];
+				arr[i] = arr[largest];
+				arr[largest] = swap;
+
+				heapify(arr, N, largest);
+			}
 		}
-	}
-
-	// To heapify a subtree rooted with node i which is
-	// an index in arr[]. n is size of heap
-	void heapify(int arr[], int n, int i)
-	{
-		int largest = i; // Initialize largest as root
-		int l = 2 * i + 1; // left = 2*i + 1
-		int r = 2 * i + 2; // right = 2*i + 2
-
-		// If left child is larger than root
-		if (l < n && arr[l] > arr[largest])
-			largest = l;
-
-		// If right child is larger than largest so far
-		if (r < n && arr[r] > arr[largest])
-			largest = r;
-
-		// If largest is not root
-		if (largest != i) {
-			int swap = arr[i];
-			arr[i] = arr[largest];
-			arr[largest] = swap;
-
-			// Recursively heapify the affected sub-tree
-			heapify(arr, n, largest);
+		static void printArray(int arr[])
+		{
+			int N = arr.length;
+
+			for (int i = 0; i < N; ++i)
+				System.out.print(arr[i] + " ");
+			System.out.println();
+		}
+
+		public static void main(String args[])
+		{
+			 int i, n, arr[];
+
+		      Scanner s = new Scanner(System.in);
+		      System.out.println("Enter no. of elements in aray:");
+		      n = s.nextInt(); 
+
+		      arr = new int[n];
+
+		      System.out.println("Enter " + n + " integers:");
+
+		      for (i = 0;i<n; i++)
+		          arr[i] = s.nextInt();
+
+			HeapSort ob = new HeapSort();
+			ob.sort(arr);
+
+			System.out.println("Sorted array is");
+			printArray(arr);
 		}
-	}
-
-	/* 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 program
-	public static void main(String args[])
-	{
-		int arr[] = { 12, 11, 13, 5, 6, 7 };
-		int n = arr.length;
-
-		HeapSort ob = new HeapSort();
-		ob.sort(arr);
-
-		System.out.println("Sorted array is");
-		printArray(arr);
-	}
+	
+
 }