Merge pull request #500 from lq920320/Development

add Test for InsertionSort

src/main/java/com/sorts/InsertionSort.java

@@ -0,0 +1,27 @@
+package src.main.java.com.sorts;
+
+public class InsertionSort {
+
+  /**
+   * This method implements the Generic Insertion Sort
+   * Sorts the array in increasing order
+   *
+   * @param array The array to be sorted
+   **/
+  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 && SortUtils.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;
+  }
+}

src/test/java/com/sorts/BubbleSortTest.java

@@ -5,23 +5,18 @@ import org.junit.Assert;
 import org.junit.Test;
 import src.main.java.com.sorts.BubbleSort;
 
-import java.util.Arrays;
-
 public class BubbleSortTest {
 
   @Test
   public void bubbleSortTest() {
     BubbleSort bubbleSort = new BubbleSort();
+
     Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
     Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    System.out.println(Arrays.toString(bubbleSort.sort(unsortedInt)));
-
     Assert.assertArrayEquals(sortedInt, bubbleSort.sort(unsortedInt));
 
     Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
     Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-    System.out.println(Arrays.toString(bubbleSort.sort(unsortedChar)));
-
     Assert.assertArrayEquals(sortedChar, bubbleSort.sort(unsortedChar));
 
   }

src/test/java/com/sorts/HeapSortTest.java

@@ -5,23 +5,18 @@ import org.junit.Assert;
 import org.junit.Test;
 import src.main.java.com.sorts.HeapSort;
 
-import java.util.Arrays;
-
 public class HeapSortTest {
 
   @Test
   public void heapSortTest() {
     HeapSort heapSort = new HeapSort();
+
     Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
     Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    System.out.println(Arrays.toString(heapSort.sort(unsortedInt)));
-
     Assert.assertArrayEquals(sortedInt, heapSort.sort(unsortedInt));
 
     Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
     Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-    System.out.println(Arrays.toString(heapSort.sort(unsortedChar)));
-
     Assert.assertArrayEquals(sortedChar, heapSort.sort(unsortedChar));
   }
 }

src/test/java/com/sorts/InsertionSortTest.java

@@ -0,0 +1,22 @@
+package src.test.java.com.sorts;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+import src.main.java.com.sorts.InsertionSort;
+
+public class InsertionSortTest {
+
+  @Test
+  public void insertionSortTest() {
+    InsertionSort insertionSort = new InsertionSort();
+
+    Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
+    Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    Assert.assertArrayEquals(sortedInt, insertionSort.sort(unsortedInt));
+
+    Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
+    Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
+    Assert.assertArrayEquals(sortedChar, insertionSort.sort(unsortedChar));
+  }
+}

src/test/java/com/sorts/QuickSortTest.java

@@ -5,23 +5,18 @@ import org.junit.Assert;
 import org.junit.Test;
 import src.main.java.com.sorts.QuickSort;
 
-import java.util.Arrays;
-
 public class QuickSortTest {
 
   @Test
   public void quickSortTest() {
     QuickSort quickSort = new QuickSort();
+
     Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
     Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    System.out.println(Arrays.toString(quickSort.sort(unsortedInt)));
-
     Assert.assertArrayEquals(sortedInt, quickSort.sort(unsortedInt));
 
     Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
     Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-    System.out.println(Arrays.toString(quickSort.sort(unsortedChar)));
-
     Assert.assertArrayEquals(sortedChar, quickSort.sort(unsortedChar));
   }
 }

src/test/java/com/sorts/SelectionSortTest.java

@@ -4,23 +4,18 @@ import org.junit.Assert;
 import org.junit.Test;
 import src.main.java.com.sorts.SelectionSort;
 
-import java.util.Arrays;
-
 public class SelectionSortTest {
 
   @Test
   public void selectionSortTest() {
     SelectionSort selectionSort = new SelectionSort();
+
     Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
     Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    System.out.println(Arrays.toString(selectionSort.sort(unsortedInt)));
-
     Assert.assertArrayEquals(sortedInt, selectionSort.sort(unsortedInt));
 
     Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
     Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-    System.out.println(Arrays.toString(selectionSort.sort(unsortedChar)));
-
     Assert.assertArrayEquals(sortedChar, selectionSort.sort(unsortedChar));
   }
 }

src/test/java/com/sorts/ShellSortTest.java

@@ -4,23 +4,18 @@ import org.junit.Assert;
 import org.junit.Test;
 import src.main.java.com.sorts.ShellSort;
 
-import java.util.Arrays;
-
 public class ShellSortTest {
 
   @Test
   public void shellSortTest() {
     ShellSort shellSort = new ShellSort();
+
     Integer[] unsortedInt = new Integer[]{0, 5, 9, 2, 1, 3, 4, 8, 6, 7};
     Integer[] sortedInt = new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    System.out.println(Arrays.toString(shellSort.sort(unsortedInt)));
-
     Assert.assertArrayEquals(sortedInt, shellSort.sort(unsortedInt));
 
     Character[] unsortedChar = new Character[]{'f', 'h', 'c', 'a', 'b', 'd', 'g', 'e'};
     Character[] sortedChar = new Character[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
-    System.out.println(Arrays.toString(shellSort.sort(unsortedChar)));
-
     Assert.assertArrayEquals(sortedChar, shellSort.sort(unsortedChar));
   }
 }