@@ -13,7 +13,9 @@
             "./src/primes/",
             "./src/others/",
             "./src/searching/",
-            "./src/sets/"
+            "./src/sets/",
+            "./src/shuffle/",
+            "./src/sorting/"
         ],
         "includePattern": ".+\\.js(doc)?$",
         "excludePattern": "docs"
 
@@ -1,12 +1,21 @@
 (function (exports) {
+
   'use strict';
 
   /**
    * The shuffling algorithm of
-   * Fisher-Yates. Complexity O(n)
+   * Fisher-Yates.<br><br>
+   * Time complexity: O(N).
+   *
+   * @example
+   * var shuffle = require('path-to-algorithms/src/' +
+   * 'shuffle/fisheryates').shuffle;
+   * console.log(shuffle([1, 2, 3, 4, 5])); // shuffled array
    *
-   * @param {array} array The array which should be shuffled
-   * @return {array} The shuffled array.
+   * @public
+   * @module shuffle/fisheryates
+   * @param {Array} array Array which should be shuffled.
+   * @return {Array} Shuffled array.
    */
   function shuffle(array) {
     var size = array.length;
@@ -23,4 +32,4 @@
 
   exports.shuffle = shuffle;
 
-}(typeof exports === 'undefined' ? window : exports));
+})(typeof window === 'undefined' ? module.exports : window);
@@ -1,17 +1,22 @@
 (function (exports) {
+
   'use strict';
 
   /**
    * Shuffle of an array elements.
    * This algorithm is modified version of Fisher-Yates shuffle
-   * algorithm and is introduced by Richard Durstenfeld.
-   */
-
-  /**
-   * Shuffles an array. Complexity O(n).
+   * algorithm and is introduced by Richard Durstenfeld.<br><br>
+   * Time complexity: O(N).
+   *
+   * @example
+   * var shuffle = require('path-to-algorithms/src/shuffle' +
+   * '/richarddurstenfeld').shuffle;
+   * console.log(shuffle([1, 2, 3, 4, 5])); // random shuffled
    *
-   * @param {array} array An array which should be shuffled
-   * @returns {array} Shuffled array
+   * @public
+   * @module shuffle/richarddurstenfeld
+   * @param {Array} array An array which should be shuffled.
+   * @return {Array} Shuffled array.
    */
   function shuffle(array) {
     var arraySize = array.length - 1;
 
@@ -1,10 +1,6 @@
 (function (exports) {
   'use strict';
 
-  /**
-   * Effective inplace string sorting algorithm.
-   * The algorithm is NOT stable.
-   */
   var quicksort = (function () {
 
     function charAt(str, i) {
@@ -48,6 +44,21 @@
       quicksort(arr, highPointer + 1, hi, d);
     }
 
+    /**
+     * Effective inplace string sorting algorithm.
+     * Algorithm is NOT stable.
+     *
+     * @example
+     *
+     * var sort = require('path-to-algorithms/src/sorting'+
+     * '/3-way-string-quicksort').quicksort;
+     * console.log(sort(['bb', 'aa', 'cc'])); // [ 'aa', 'bb', 'cc' ]
+     *
+     * @public
+     * @module sorting/3-way-string-quicksort
+     * @param arr {Array} array which should be sorted.
+     * @return {Array} Sorted array.
+     */
     return function sort(arr) {
       quicksort(arr, 0, arr.length - 1, 0);
       return arr;
@@ -56,4 +67,4 @@
 
   exports.quicksort = quicksort;
 
-}(typeof exports === 'undefined' ? window : exports));
+})(typeof window === 'undefined' ? module.exports : window);
@@ -6,11 +6,21 @@
   }
 
   /**
-   * The bubblesort algorithm. Complexity O(n^2).
+   * Bubble sort algorithm.<br><br>
+   * Complexity: O(N^2).
+   *
+   * @example
+   * var sort = require('path-to-algorithms/src/' +
+   * 'sorting/bubblesort').bubbleSort;
+   * console.log(sort([2, 5, 1, 0, 4])); // [ 0, 1, 2, 4, 5 ]
    *
    * @public
-   * @param {array} array Input array
-   * @returns {array} array Sorted array
+   * @module sorting/bubblesort
+   * @param {Array} array Input array.
+   * @param {Function} cmp Optional. A function that defines an
+   * alternative sort order. The function should return a negative,
+   * zero, or positive value, depending on the arguments.
+   * @return {Array} Sorted array.
    */
   function bubbleSort(array, cmp) {
     cmp = cmp || comparator;
@@ -29,4 +39,4 @@
 
   exports.bubbleSort = bubbleSort;
 
-}(typeof exports === 'undefined' ? window : exports));
+})(typeof window === 'undefined' ? module.exports : window);
@@ -1,12 +1,7 @@
 (function (exports) {
+
   'use strict';
 
-  /**
-   * Bucket sort. This algorithm has complexity O(n) in case the
-   * data is with uniform distribution.
-   *
-   * @public
-   */
   var bucketSort = (function () {
 
     /**
@@ -90,11 +85,20 @@
     }
 
     /**
-     * Sorts given array with bucketsort
+     * Sorts given array with bucketsort.<br><br>
+     * Time complexity: O(N) in case the
+     * data is with uniform distribution.
+     *
+     * @example
+     *
+     * var sort = require('path-to-algorithms/src/'+
+     * 'sorting/bucketsort').bucketSort;
+     * console.log(sort([2, 5, 1, 0, 4])); // [ 0, 1, 2, 4, 5 ]
      *
      * @public
-     * @param {array} array Input array which should be sorted
-     * @returns {array} Sorted array
+     * @module sorting/bucketsort
+     * @param {Array} array Input array which should be sorted.
+     * @return {Array} Sorted array.
      */
     return function (array) {
       var buckets = createBuckets(array);
@@ -105,4 +109,4 @@
 
   exports.bucketSort = bucketSort;
 
-}(typeof exports === 'undefined' ? window : exports));
+})(typeof window === 'undefined' ? module.exports : window);