new staff and cleaning

Author: 5ar5kovic

Diff for: Sorting/BogoSort/Python/BogoSort.py

@@ -0,0 +1,36 @@
+import random
+import unittest
+
+# returns the sorted version of the given array by 
+# checking first if its sorted, and then if not
+# randomly shuffles elements in the given array
+# and recursivly calls itself with the newly
+# shuffled array as an arguement.
+def monkeySort(arr1):
+    for i in range(1, len(arr1)):
+        if arr1[i-1] > arr1[i]:
+            random.shuffle(arr1)
+            return monkeySort(arr1)
+    return arr1
+
+class testMonkeySort(unittest.TestCase):
+
+    def test_regular_arr(self):
+        arrPractice = [3, 4, 2, 1 ,5]
+        self.assertEqual(monkeySort(arrPractice), [1, 2, 3, 4, 5])
+    
+    def test_same_arr(self):
+        arrPractice = [1, 1, 1, 1, 1]
+        self.assertEqual(monkeySort(arrPractice), arrPractice)   
+
+    def test_empty_arr(self):
+        arrPractice = []
+        self.assertEqual(monkeySort(arrPractice), arrPractice)    
+
+    def test_duplicate_arr(self):
+        arrPractice = [4, 2, 2, 1, 1]
+        arrSolution = [1, 1, 2, 2, 4]
+        self.assertEqual(monkeySort(arrPractice), arrSolution)    
+    
+if __name__ == "__main__":
+    unittest.main()

Diff for: Sorting/BogoSort/README.md

@@ -0,0 +1,4 @@
+<h1>BogoSort</h1>
+<p>In computer science, bogosort (also permutation sort, stupid sort, slowsort, shotgun sort or monkey sort) is a highly ineffective sorting function based on the generate and test paradigm. The function successively generates permutations of its input until it finds one that is sorted. It is not useful for sorting, but may be used for educational purposes, to contrast it with more efficient algorithms.</p>
+
+<a href="https://en.wikipedia.org/wiki/Bogosort">Source: Wikipedia</a>

Diff for: Sorting/Bucket Sort/C++/Bucket_Sort.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+ 
+ 
+void bucketSort(float a[], int n)
+{
+    vector<float> t[n];
+    
+    for (int i=0; i<n; i++)
+    {
+       int x = n*a[i];
+       t[x].push_back(a[i]);
+    }
+ 
+    for (int i=0; i<n; i++)
+       sort(t[i].begin(), t[i].end());
+ 
+    int k= 0;
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < t[i].size(); j++)
+          a[k++] = t[i][j];
+}
+ 
+int main()
+{
+    float a[] = {0.765, 0.324, 0.111, 0.951, 0.245, 0.48};
+    int n = sizeof(a)/sizeof(a[0]);
+    cout << "Elements before Sorting\n";
+    for (int i=0; i<n; i++)
+    cout << a[i] << " ";
+    
+    bucketSort(a, n);
+    
+    cout << "\nElements After Sorting \n";
+    for (int i=0; i<n; i++)
+       cout << a[i] << " ";
+    return 0;
+}

Diff for: Sorting/Bucket Sort/Java/Bucket_Sort.java

@@ -0,0 +1,40 @@
+import java.util.*;
+ //O(nlogn)
+public class BucketSort{
+
+   public static void bucketSort(int[] a) {
+	  int maxVal=a[0];
+	  for(int i=0;i<a.length;i++){
+		  if(a[i]>maxVal){
+			  maxVal=a[i];
+		  }
+	  }
+      int [] bucket=new int[maxVal+1];
+ 
+	  System.out.println("\n");
+      for (int i=0; i<a.length; i++) {
+         bucket[a[i]]++;
+		 //System.out.print(bucket[a[i]-1]);
+      }
+ 
+      int outPos=0;
+      for (int i=0; i<bucket.length; i++) {
+		if(bucket[i]!=0){
+			for (int j=0; j<bucket[i]; j++) {
+				a[outPos++]=i;
+				System.out.println(bucket[i]);
+			}
+		}
+      }
+   }
+   
+ 
+ 
+   public static void main(String[] args) {
+      int [] data= {10,23,53,22,1,1,100,32,58,34,42,64}; 
+ 
+      System.out.println("Before: " + Arrays.toString(data));
+      bucketSort(data);
+      System.out.println("After:  " + Arrays.toString(data));
+   }
+}

Diff for: Sorting/Bucket Sort/README.md

@@ -0,0 +1,5 @@
+<h1>Bucket Sort</h1>
+<p>Bucket sort, or bin sort, is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm. It is a distribution sort, a generalization of pigeonhole sort, and is a cousin of radix sort in the most-to-least significant digit flavor. Bucket sort can be implemented with comparisons and therefore can also be considered a comparison sort algorithm. The computational complexity estimates involve the number of buckets.</p>
+<img src="https://upload.wikimedia.org/wikipedia/commons/5/54/Sorting_bubblesort_anim.gif">
+
+<a href="https://en.wikipedia.org/wiki/Bucket_sort">Source: Wikipedia</a>

Diff for: Sorting/CocktailShakerSort/cocktail_shaker_sort.js renamed to Sorting/Cocktail Shaker Sort/JavaScript/Cocktail_Shaker_Sort.js

@@ -0,0 +1,5 @@
+<h1>Cocktail Shaker Sort</h1>
+<p>Cocktail shaker sort, also known as bidirectional bubble sort, cocktail sort, shaker sort (which can also refer to a variant of selection sort), ripple sort, shuffle sort, or shuttle sort, is a variation of bubble sort that is both a stable sorting algorithm and a comparison sort. The algorithm differs from a bubble sort in that it sorts in both directions on each pass through the list. This sorting algorithm is only marginally more difficult to implement than a bubble sort, and solves the problem of turtles in bubble sorts. It provides only marginal performance improvements, and does not improve asymptotic performance; like the bubble sort, it is not of practical interest (insertion sort is preferred for simple sorts), though it finds some use in education.</p>
+<img src="https://en.wikipedia.org/wiki/Cocktail_shaker_sort">
+
+<a href="https://en.wikipedia.org/wiki/Bubble_sort">Source: Wikipedia</a>

Diff for: Sorting/CocktailShakerSort/cocktail_shaker_sort.py renamed to Sorting/Cocktail Shaker Sort/Python/Cocktail_Shaker_Sort.py

@@ -0,0 +1,5 @@
+<h1>Comb Sort</h1>
+<p>Comb sort is a relatively simple sorting algorithm originally designed by Włodzimierz Dobosiewicz in 1980. Later it was rediscovered by Stephen Lacey and Richard Box in 1991. Comb sort improves on bubble sort.</p>
+<img src="https://upload.wikimedia.org/wikipedia/commons/4/46/Comb_sort_demo.gif">
+
+<a href="https://en.wikipedia.org/wiki/Comb_sort">Source: Wikipedia</a>

Diff for: Sorting/Cocktail Shaker Sort/README.md

@@ -0,0 +1,40 @@
+# Comb Sort is mainly an improvement over Bubble Sort. Bubble sort always
+# compares adjacent values. So all inversions are removed one by one. Comb Sort
+# improves on Bubble Sort by using gap of size more than 1. The gap starts with
+# a large value and shrinks by a factor of 1.3 in every iteration until it
+# reaches the value 1. Thus Comb Sort removes more than one inversion counts
+# with one swap and performs better than Bublle Sort.
+#
+# More on: https://www.geeksforgeeks.org/comb-sort/
+# Illustration gif: https://upload.wikimedia.org/wikipedia/commons/4/46/Comb_sort_demo.gif
+
+def combsort(array, shrink = 1.247330950103979)
+  sorted = array.dup
+  gap = array.size
+  swapped = false
+
+  until gap == 1 && !swapped
+    gap = (gap / shrink).to_i
+    gap = 1 if gap < 1
+
+    swapped = false
+
+    gap.upto(sorted.size - 1) do |i|
+      next if sorted[i - gap] <= sorted[i]
+
+      sorted[i - gap], sorted[i] = sorted[i], sorted[i - gap]
+      swapped = true
+    end
+  end
+
+  sorted
+end
+
+# Test case
+if $PROGRAM_NAME == __FILE__
+  unsorted = Array.new(20) { rand(10_000) }
+  sorted = combsort(unsorted)
+  puts "Sorting: #{unsorted}"
+  puts "Sorted:  #{sorted}"
+  puts "Correct? #{sorted == unsorted.sort}"
+end

Diff for: Sorting/CocktailShakerSort/README.md

@@ -0,0 +1,19 @@
+function countingSort(arr, min, max)
+  {
+    var i, z = 0, count = [];
+ 
+    for (i = min; i <= max; i++) {
+        count[i] = 0;
+    }
+ 
+    for (i=0; i < arr.length; i++) {
+        count[arr[i]]++;
+    }
+ 
+    for (i = min; i <= max; i++) {
+        while (count[i]-- > 0) {
+            arr[z++] = i;
+        }
+    }
+ return arr;
+}

Diff for: Sorting/Comb Sort/README.md

@@ -0,0 +1,4 @@
+<h1>Counting Sort</h1>
+<p>In computer science, 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. Its running time is linear in the number of items and the difference between the maximum and minimum key values, so it is only suitable for direct use in situations where the variation in keys is not significantly greater than the number of items. However, it is often used as a subroutine in another sorting algorithm, radix sort, that can handle larger keys more efficiently.</p>
+
+<a href="https://en.wikipedia.org/wiki/Counting_sort">Source: Wikipedia</a>

Diff for: Sorting/Comb Sort/Ruby/Comb_Sort.rb

@@ -0,0 +1,117 @@
+using System;
+
+namespace Heap_sort
+{
+	public class MainClass
+	{
+		public static void Main (string[] args)
+		{
+			int[] mykeys = new int[] {2, 5, -4, 11, 0, 18, 22, 67, 51, 6};
+
+			//double[] mykeys = new double[] {2.22, 0.5, 2.7, -1.0, 11.2};
+
+		    //string[] mykeys = new string[] {"Red", "White", "Black", "Green", "Orange"};
+              
+			Console.WriteLine("\nOriginal Array Elements :");  
+			printArray (mykeys);
+
+			heapSort (mykeys);
+           
+		    Console.WriteLine("\n\nSorted Array Elements :");
+			printArray (mykeys);
+            Console.WriteLine("\n");
+		}
+
+		private static void heapSort<T> (T[] array) where T : IComparable<T>
+		{
+			int heapSize = array.Length;
+
+			buildMaxHeap (array);
+
+			for (int i = heapSize-1; i >= 1; i--)
+			{
+				swap (array, i, 0);
+				heapSize--;
+				sink (array, heapSize, 0);
+			}
+		}
+
+		private static void buildMaxHeap<T> (T[] array) where T : IComparable<T>
+		{
+			int heapSize = array.Length;
+
+			for (int i = (heapSize/2) - 1; i >= 0; i--)
+			{
+				sink (array, heapSize, i);
+			}
+		}
+
+		private static void sink<T> (T[] array, int heapSize, int toSinkPos) where T : IComparable<T>
+		{
+			if (getLeftKidPos (toSinkPos) >= heapSize)
+			{
+				// No left kid => no kid at all
+				return;
+			}
+
+
+			int largestKidPos;
+			bool leftIsLargest;
+
+			if (getRightKidPos (toSinkPos) >= heapSize || array [getRightKidPos (toSinkPos)].CompareTo (array [getLeftKidPos (toSinkPos)]) < 0)
+			{
+				largestKidPos = getLeftKidPos (toSinkPos);
+				leftIsLargest = true;
+			} else
+			{
+				largestKidPos = getRightKidPos (toSinkPos);
+				leftIsLargest = false;
+			}
+			
+
+
+			if (array [largestKidPos].CompareTo (array [toSinkPos]) > 0)
+			{
+				swap (array, toSinkPos, largestKidPos);
+
+				if (leftIsLargest)
+				{
+					sink (array, heapSize, getLeftKidPos (toSinkPos));
+
+				} else
+				{
+					sink (array, heapSize, getRightKidPos (toSinkPos));
+				}
+			}
+
+		}
+
+		private static void swap<T> (T[] array, int pos0, int pos1)
+		{
+			T tmpVal = array [pos0];
+			array [pos0] = array [pos1];
+			array [pos1] = tmpVal;
+		}
+
+		private static int getLeftKidPos (int parentPos)
+		{
+			return (2 * (parentPos + 1)) - 1;
+		}
+
+		private static int getRightKidPos (int parentPos)
+		{
+			return 2 * (parentPos + 1);
+		}
+
+		private static void printArray<T> (T[] array)
+		{
+							
+			foreach (T t in array)
+			{
+			    Console.Write(' '+t.ToString()+' ');
+			}
+
+		}
+	}
+
+}