Added the default method to sort a list to the sort interface

nikitap492 · nikitap492 · commit 874940160ac0 · 2018-04-09T14:04:46.000+03:00
Changes in InsertionSort and CountingSort
diff --git a/Sorts/InsertionSort.java b/Sorts/InsertionSort.java
diff --git a/Sorts/src/sort/CountingSort.java b/Sorts/src/sort/CountingSort.java
@@ -1,20 +1,27 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
+package sort;
+
+import java.util.*;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.Collectors.toMap;
+import static sort.SortUtils.print;
 
 /**
  *
  * @author Youssef Ali (https://github.com/youssefAli11997)
  * @author Podshivalov Nikita (https://github.com/nikitap492)
  *
  */
-class CountingSort {
+class CountingSort implements SortAlgorithm {
+
+
+
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] unsorted) {
+        return sort(Arrays.asList(unsorted)).toArray(unsorted);
+    }
 
     /**
      * This method implements the Generic Counting Sort
@@ -24,7 +31,8 @@ class CountingSort {
      * Sorts the list in increasing order
      * The method uses list elements as keys in the frequency map
      **/
-    public static <T extends Comparable<T>> List<T> countingSort(List<T> list) {
+    @Override
+    public <T extends Comparable<T>> List<T> sort(List<T> list) {
 
         Map<T, Integer> frequency = new TreeMap<>();
         // The final output array
@@ -46,12 +54,12 @@ public static <T extends Comparable<T>> List<T> countingSort(List<T> list) {
 
     /**
      * Stream Counting Sort
-     * The same as method {@link CountingSort#countingSort(List)} but this method uses stream API
+     * The same as method {@link CountingSort#sort(List)} } but this method uses stream API
      *
      * @param list The list to be sorted
      *
      **/
-    public static <T extends Comparable<T>> List<T> streamCountingSort(List<T> list) {
+    private static <T extends Comparable<T>> List<T> streamSort(List<T> list) {
         return  list.stream()
                 .collect(toMap(k -> k, v -> 1, (v1, v2) -> v1 + v2, TreeMap::new))
                 .entrySet()
@@ -64,43 +72,31 @@ public static <T extends Comparable<T>> List<T> streamCountingSort(List<T> list)
     public static void main(String[] args) {
         // Integer Input
         List<Integer> unsortedInts = Stream.of(4, 23, 6, 78, 1, 54, 23, 1, 9, 231, 9, 12).collect(toList());
+        CountingSort countingSort = new CountingSort();
 
         System.out.println("Before Sorting:");
-        printList(unsortedInts);
+        print(unsortedInts);
 
         // Output => 1 1 4 6 9 9 12 23 23 54 78 231
         System.out.println("After Sorting:");
-        printList(countingSort(unsortedInts));
+        print(countingSort.sort(unsortedInts));
         System.out.println("After Sorting By Streams:");
-        printList(streamCountingSort(unsortedInts));
+        print(streamSort(unsortedInts));
 
         System.out.println("\n------------------------------\n");
 
         // String Input
         List<String> unsortedStrings = Stream.of("c", "a", "e", "b","d", "a", "f", "g", "c").collect(toList());
 
         System.out.println("Before Sorting:");
-        printList(unsortedStrings);
+        print(unsortedStrings);
 
         //Output => a a b c c d e f g
         System.out.println("After Sorting:");
-        printList(countingSort(unsortedStrings));
+        print(countingSort.sort(unsortedStrings));
 
         System.out.println("After Sorting By Streams:");
-        printList(streamCountingSort(unsortedStrings));
-
-    }
+        print(streamSort(unsortedStrings));
 
-    /**
-     * Just print list
-     * @param toPrint - a list which should be printed
-     */
-    private static void printList(List<?> toPrint){
-        toPrint.stream()
-                .map(Object::toString)
-                .map(str -> str + " ")
-                .forEach(System.out::print);
-
-        System.out.println();
     }
 }
diff --git a/Sorts/src/sort/InsertionSort.java b/Sorts/src/sort/InsertionSort.java
@@ -0,0 +1,61 @@
+package sort;
+
+import static sort.SortUtils.less;
+import static sort.SortUtils.print;
+
+/**
+ *
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ * @author Podshivalov Nikita (https://github.com/nikitap492)
+ *
+ */
+
+class InsertionSort implements SortAlgorithm {
+
+    /**
+     * This method implements the Generic Insertion Sort
+     * Sorts the array in increasing order
+     *
+     * @param array The array to be sorted
+     *
+     **/
+
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] array) {
+        for (int j = 1; j < array.length; j++) {
+
+            // Picking up the key(Card)
+            T key = array[j];
+            int i = j - 1;
+
+            while (i >= 0 && less(key, array[i])) {
+                array[i + 1] = array[i];
+                i--;
+            }
+            // Placing the key (Card) at its correct position in the sorted subarray
+            array[i + 1] = key;
+        }
+        return array;
+    }
+
+    // Driver Program
+    public static void main(String[] args) {
+        // Integer Input
+        Integer[] integers = {4, 23, 6, 78, 1, 54, 231, 9, 12};
+
+        InsertionSort sort = new InsertionSort();
+
+        sort.sort(integers);
+
+        // Output => 1 4 6 9 12 23 54 78 231
+        print(integers);
+
+        // String Input
+        String[] strings = {"c", "a", "e", "b","d"};
+
+        sort.sort(strings);
+
+        //Output => a	b	c	d	e
+        print(strings);
+    }
+}
diff --git a/Sorts/src/sort/SortAlgorithm.java b/Sorts/src/sort/SortAlgorithm.java
@@ -1,5 +1,8 @@
 package sort;
 
+import java.util.Arrays;
+import java.util.List;
+
 /**
  *  The common interface of most algorithms
  *
@@ -10,4 +13,9 @@ public interface SortAlgorithm {
 
     <T extends Comparable<T>> T[] sort(T[] unsorted);
 
+    @SuppressWarnings("unchecked")
+    default <T extends Comparable<T>> List<T> sort(List<T> unsorted){
+        return Arrays.asList(sort(unsorted.toArray((T[]) new Comparable[unsorted.size()])));
+    }
+
 }
