new staff and cleaning

Author: 5ar5kovic

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()

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>

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;
+}

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));
+   }
+}

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>

…cktailShakerSort/cocktail_shaker_sort.js … Sort/JavaScript/Cocktail_Shaker_Sort.jsSorting/CocktailShakerSort/cocktail_shaker_sort.js renamed to Sorting/Cocktail Shaker Sort/JavaScript/Cocktail_Shaker_Sort.js 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>

…cktailShakerSort/cocktail_shaker_sort.py …aker Sort/Python/Cocktail_Shaker_Sort.pySorting/CocktailShakerSort/cocktail_shaker_sort.py renamed to Sorting/Cocktail Shaker Sort/Python/Cocktail_Shaker_Sort.py 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>