diff --git a/src/main/java/com/williamfiset/algorithms/sorting/Heapsort.java b/src/main/java/com/williamfiset/algorithms/sorting/Heapsort.java
index 60bd89858..693c16d2c 100644
--- a/src/main/java/com/williamfiset/algorithms/sorting/Heapsort.java
+++ b/src/main/java/com/williamfiset/algorithms/sorting/Heapsort.java
@@ -9,8 +9,6 @@
  */
 package com.williamfiset.algorithms.sorting;
 
-import java.util.*;
-
 public class Heapsort implements InplaceSort {
 
   @Override
diff --git a/src/main/java/com/williamfiset/algorithms/sorting/MergeSort.java b/src/main/java/com/williamfiset/algorithms/sorting/MergeSort.java
index 5c290774e..2c40138b1 100644
--- a/src/main/java/com/williamfiset/algorithms/sorting/MergeSort.java
+++ b/src/main/java/com/williamfiset/algorithms/sorting/MergeSort.java
@@ -18,9 +18,7 @@ public class MergeSort implements InplaceSort {
   @Override
   public void sort(int[] values) {
     int[] sortedValues = MergeSort.mergesort(values);
-    for (int i = 0; i < values.length; i++) {
-      values[i] = sortedValues[i];
-    }
+    System.arraycopy(sortedValues, 0, values, 0, values.length);
   }
 
   public static int[] mergesort(int[] ar) {
diff --git a/src/main/java/com/williamfiset/algorithms/sorting/ShellSort.java b/src/main/java/com/williamfiset/algorithms/sorting/ShellSort.java
new file mode 100644
index 000000000..b978be5ce
--- /dev/null
+++ b/src/main/java/com/williamfiset/algorithms/sorting/ShellSort.java
@@ -0,0 +1,47 @@
+/**
+ * Shell sort implementation
+ *
+ * <p>Run with:
+ *
+ * <p>$ ./gradlew run -Palgorithm=sorting.ShellSort
+ *
+ * @author Tan Karageldi, tankarageldi@gmail.com
+ */
+package com.williamfiset.algorithms.sorting;
+
+public class ShellSort implements InplaceSort{
+
+    @Override
+    public void sort(int[] values) {
+        ShellSort.shellSort(values);
+    }
+
+    // The idea of shell sort is sorting the elements that are far away from each other
+    // defined by the interval (inter) and progressively reducing the gap between elements, 
+    // to do an insertion sort when the gap is 1.
+    
+    public static void shellSort(int[] array){
+        int n = array.length;
+        for(int inter = n/2 ; inter > 0 ; inter /= 2){
+            for(int i = inter; i< n; i+= 1){
+                int temp = array[i];
+                int j;
+                for(j = i; j >= inter && array[j - inter] > temp; j -= inter){
+                    array[j] = array[j - inter];
+                }
+                array[j] = temp;
+            }
+        }
+
+    }
+
+    public static void main(String[] args) {
+        InplaceSort sorter = new ShellSort();
+        int[] array = {10, 4, 6, 8, -13, 2, 3};
+        sorter.sort(array);
+        // Prints:
+        // [-13, 2, 3, 4, 6, 8, 10]
+        System.out.println(java.util.Arrays.toString(array));
+      }
+    
+}
diff --git a/src/test/java/com/williamfiset/algorithms/sorting/ShellSortTest.java b/src/test/java/com/williamfiset/algorithms/sorting/ShellSortTest.java
new file mode 100644
index 000000000..3d143a428
--- /dev/null
+++ b/src/test/java/com/williamfiset/algorithms/sorting/ShellSortTest.java
@@ -0,0 +1,44 @@
+package com.williamfiset.algorithms.sorting;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import org.junit.jupiter.api.Test;
+
+public class ShellSortTest {
+
+    @Test
+    public void testPositiveNumbers() {
+        int[] input = {5, 2, 9, 1, 5, 6};
+        int[] expected = {1, 2, 5, 5, 6, 9};
+        ShellSort.shellSort(input);
+        assertArrayEquals(expected, input);
+    }
+
+    @Test
+    public void testNegativeNumbers() {
+        int[] input = {-3, -1, -4, -2, -5};
+        int[] expected = {-5, -4, -3, -2, -1};
+        ShellSort.shellSort(input);
+        assertArrayEquals(expected, input);
+    }
+
+    @Test
+    public void testMixedNumbers() {
+        int[] input = {10, -3, 0, 2, -15, 7};
+        int[] expected = {-15, -3, 0, 2, 7, 10};
+        ShellSort.shellSort(input);
+        assertArrayEquals(expected, input);
+    }
+    @Test
+    public void testSingleElementArray() {
+        int[] input = {42};
+        int[] expected = {42};
+        ShellSort.shellSort(input);
+        assertArrayEquals(expected, input);
+    }
+    @Test
+    public void testEmptyArray() {
+        int[] input = {};
+        int[] expected = {};
+        ShellSort.shellSort(input);
+        assertArrayEquals(expected, input);
+    }
+}
diff --git a/src/test/java/com/williamfiset/algorithms/sorting/SortingTest.java b/src/test/java/com/williamfiset/algorithms/sorting/SortingTest.java
index 94a5765f6..55b5ba53a 100644
--- a/src/test/java/com/williamfiset/algorithms/sorting/SortingTest.java
+++ b/src/test/java/com/williamfiset/algorithms/sorting/SortingTest.java
@@ -1,12 +1,13 @@
 package com.williamfiset.algorithms.sorting;
 
-import static com.google.common.truth.Truth.assertThat;
-
-import com.williamfiset.algorithms.utils.TestUtils;
 import java.util.Arrays;
 import java.util.EnumSet;
+
 import org.junit.jupiter.api.Test;
 
+import static com.google.common.truth.Truth.assertThat;
+import com.williamfiset.algorithms.utils.TestUtils;
+
 // Test all sorting algorithms under various constraints.
 //
 // Not all sorting algorithms are suitable for every type for test. For instance,
@@ -25,6 +26,7 @@ enum SortingAlgorithm {
     QUICK_SORT(new QuickSort()),
     QUICK_SORT3(new QuickSort3()),
     RADIX_SORT(new RadixSort()),
+    SHELL_SORT(new ShellSort()),
     SELECTION_SORT(new SelectionSort());
 
     private InplaceSort algorithm;
@@ -49,6 +51,7 @@ public InplaceSort getSortingAlgorithm() {
           SortingAlgorithm.QUICK_SORT,
           SortingAlgorithm.QUICK_SORT3,
           SortingAlgorithm.RADIX_SORT,
+          SortingAlgorithm.SHELL_SORT,
           SortingAlgorithm.SELECTION_SORT);
 
   @Test