Merge pull request #696 from 5ar5kovic/master

Sorting Algorithms

Author: matthewsamuel95

README.md

@@ -165,18 +165,24 @@ ACM-ICPC Algorithms is a collection of important algorithms and data structures
    * [Ternary Search](/Search/TernarySearch)
    * [Interpolation Search](/Search/InterpolationSearch)
 * [Sorting Algorithms](/Sorting)
-   * [Bubble Sort](/Sorting/bubble%20sort)
-   * [Cocktail Shaker Sort](/Sorting/CocktailShakerSort)
-   * [Counting Sort](/Sorting/CountingSort)
-   * [Heap Sort](/Sorting/HeapSort)
-   * [Index Sort](/Sorting/IndexSort)
-   * [Insertion Sort](/Sorting/InsertionSort)
-   * [Merge Sort](/Sorting/MergeSort)
-   * [Pancake Sorting](/Sorting/Pancake%20sorting)
-   * [Quick Sort](/Sorting/QuickSort)
-   * [Radix Sort](/Sorting/RadixSort)
-   * [Selection Sort](/Sorting/SelectionSort)
-   * [Shell Sort](/Sorting/ShellSort)
+   * [BogoSort](/Sorting/BogoSort)
+   * [Bubble Sort](/Sorting/Bubble%20Sort)
+   * [Bucket Sort](/Sorting/Bucket%20Sort)
+   * [Cocktail Shaker Sort](/Sorting/Cocktail%20Shaker%20Sort)
+   * [Comb Sort](/Sorting/Comb%20Sort)
+   * [Counting Sort](/Sorting/Counting%20Sort)
+   * [HeapSort](/Sorting/HeapSort)
+   * [Index Sort](/Sorting/Index%20Sort)
+   * [Insertion Sort](/Sorting/Insertion%20Sort)
+   * [Merge Sort](/Sorting/Merge%20Sort)
+   * [Pancake Sorting](/Sorting/Pancake%20Sorting)
+   * [Patience Sorting](/Sorting/Patience%20Sorting)
+   * [QuickSort](/Sorting/QuickSort)
+   * [Radix Sort](/Sorting/Radix%20Sort)
+   * [Selection Sort](/Sorting/Selection%20Sort)
+   * [ShellSort](/Sorting/ShellSort)
+   * [TimSort](/Sorting/TimSort)
+   * [Topological Sorting](/Sorting/Topological%20Sorting)
 * [String Algorithms](/String)
    * [Anagram](/String/Anagram)
    * [Balanced Parenthesis](/String/Balanced%20Parentheses)

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/Bubble Sort/Brainfuck/Bubble_Sort.bf

@@ -0,0 +1,8 @@
+>>,[>>,]<<[
+[<<]>>>>[
+<<[>+<<+>-]
+>>[>+<<<<[->]>[<]>>-]
+<<<[[-]>>[>+<-]>>[<<<+>>>-]]
+>>[[<+>-]>>]<
+]<<[>>+<<-]<<
+]>>>>[.>>]

Sorting/bubble sort/cpp/Bubble_sort.cpp renamed to Sorting/Bubble Sort/C++/Bubble_Sort_1.cpp

@@ -0,0 +1,32 @@
+package main
+
+import (
+    "fmt"
+)
+
+var toBeSorted [10]int = [10]int{1,3,2,4,8,6,7,2,3,0}
+
+func bubbleSort(input [10]int) {
+    // n is the number of items in our list
+    n := 10
+    swapped := true
+    for swapped {
+        swapped = false
+        for i := 1; i < n-1; i++ {
+            if input[i-1] > input[i] {
+                fmt.Println("Swapping")
+                // swap values using Go's tuple assignment
+                input[i], input[i-1] = input[i-1], input[i]
+                swapped = true
+            }
+        }
+    }
+    fmt.Println(input)
+}
+
+
+func main() {
+    fmt.Println("Hello World")
+    bubbleSort(toBeSorted)
+    
+}

Sorting/bubble sort/cpp/BubbleSort.cpp renamed to Sorting/Bubble Sort/C++/Bubble_Sort_2.cpp

@@ -0,0 +1,23 @@
+-- Bubble sort (also known as sinking sort) is a simple sorting algorithm that
+-- repeatedly steps through the list to be sorted, compares each pair of
+-- adjacent items and swaps them if they are in the wrong order. The pass
+-- through the list is repeated until no swaps are needed, which indicates that
+-- the list is sorted.
+
+local function bubblesort(t)
+  repeat
+    local sorted = true
+    for i=2, #t do
+      if (t[i-1] > t[i]) then
+        t[i-1], t[i] = t[i], t[i-1]
+        sorted = false
+      end
+    end
+  until sorted
+end
+
+local numbers = {5, 1, 4, 2, 8}
+bubblesort(numbers)
+for _, number in ipairs(numbers) do
+  print(number)
+end

Sorting/bubble sort/cpp/buubleDesc.cpp renamed to Sorting/Bubble Sort/C++/Bubble_Sort_3.cpp

@@ -0,0 +1,10 @@
+my @array = ( 5, 6, 3, 1, 7, 3, 2, 9, 10, 4 );
+
+for my $x ( reverse 1 .. $#array ) {
+    for my $y ( 0 .. $x - 1 ) {
+        @array[ $y, $y + 1 ] = @array[ $y + 1, $y ]
+            if $array[$y] > $array[ $y + 1 ];
+    }
+}
+
+print "@array\n";

Sorting/bubble sort/c/Bubble_Sort.c renamed to Sorting/Bubble Sort/C/Bubble_Sort_1.c

@@ -0,0 +1,21 @@
+def bubble_sort(array)
+    size = array.length
+    for i in 0..(size-1)
+        for j in 0..(size-2-i)
+            if array[j] > array[j+1]
+                array[j], array[j+1] = array[j+1], array[j]
+            end
+        end
+    end
+end
+
+# Dummy data for testing 
+test_array = [7, 6, 5, 4, 3, 2, 1]
+# Display unsorted array
+puts "Unsorted Array:"
+puts test_array.join(' ')
+# Call heap sort on the array
+bubble_sort(test_array)
+# Display the sorted results 
+puts "Post Bubble Sort"
+puts test_array.join(' ')

Sorting/bubble sort/c/bubbles-sort.c renamed to Sorting/Bubble Sort/C/Bubble_Sort_2.c

@@ -0,0 +1,21 @@
+import Foundation
+
+var array = [5,3,4,6,8,2,9,1,7,10,11]
+var sortedArray = NSMutableArray(array: array)
+
+var sortedAboveIndex = array.count 
+do {
+    var lastSwapIndex = 0
+    for ( var i = 1; i < sortedAboveIndex; i++ ) {
+        if (sortedArray[i - 1].integerValue > sortedArray[i].integerValue) {
+            sortedArray.exchangeObjectAtIndex(i, withObjectAtIndex: i-1)
+            lastSwapIndex = i
+        }
+    }
+    sortedAboveIndex = lastSwapIndex
+
+} while (sortedAboveIndex != 0)
+
+println(array)
+
+println(sortedArray as Array)

Sorting/Bubble Sort/Go/Bubble_Sort.go

@@ -0,0 +1,4 @@
+[ViewState]
+Mode=
+Vid=
+FolderType=Generic

Sorting/bubble sort/java/bubbleSort.java renamed to Sorting/Bubble Sort/Java/Bubble_Sort_1.java

@@ -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/bubble sort/java/BubbleSortNew.java renamed to Sorting/Bubble Sort/Java/Bubble_Sort_2.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/bubble sort/java/optimizedBubbleSort.java renamed to Sorting/Bubble Sort/Java/Bubble_Sort_Optimized.java

@@ -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>

Sorting/bubble sort/java/recursiveBubbleSort.java renamed to Sorting/Bubble Sort/Java/Bubble_Sort_Recursive.java

@@ -0,0 +1,6 @@
+<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://upload.wikimedia.org/wikipedia/commons/e/ef/Sorting_shaker_sort_anim.gif">
+
+<a href="https://en.wikipedia.org/wiki/Bubble_sort">Source: Wikipedia</a>

Sorting/bubble sort/js/BubbleSort.js renamed to Sorting/Bubble Sort/JavaScript/Bubble_Sort.js

@@ -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>

Sorting/Bubble Sort/Lua/Bubble_Sort.lua

@@ -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

Sorting/bubble sort/php/bubblesort.php renamed to Sorting/Bubble Sort/PHP/Bubble_Sort.php

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

Sorting/Bubble Sort/Perl/Bubble_Sort.pl

@@ -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>