diff --git a/src/main/java/org/example/IntegerListImpl.java b/src/main/java/org/example/IntegerListImpl.java
index 605027a..ed2b52c 100644
--- a/src/main/java/org/example/IntegerListImpl.java
+++ b/src/main/java/org/example/IntegerListImpl.java
@@ -4,7 +4,7 @@
 
 public class IntegerListImpl implements IntegerList {
 
-    private final Integer[] array;
+    private Integer[] array;
     private final int size;
 
     public IntegerListImpl(int size) {
@@ -31,7 +31,10 @@ public Integer add(Integer item) {
 
     @Override
     public Integer add(int index, Integer item) {
-        if (index >= size - 1 || index < 0 || array[size - 1] != null) {
+        if (array[size - 1] != null){
+            grow();
+        }
+        if (index >= size - 1 || index < 0) {
             throw new IndexOutOfBoundsException();
         }
         if (item == null) {
@@ -151,7 +154,7 @@ public boolean equals(IntegerList otherList) {
 
     @Override
     public int size() {
-        int i = size - 1;
+        int i = array.length - 1;
         while (i >= 0) {
             if (array[i] != null) {
                 return i + 1;
@@ -188,15 +191,38 @@ public Integer[] toArray() {
     }
 
     public void sort() {
-        for (int i = 1; i < size(); i++) {
-            Integer temp = array[i];
-            int j = i;
-            while (j > 0 && array[j - 1] >= temp) {
-                array[j] = array[j - 1];
-                j--;
+        quickSort(array,0,size()-1);
+    }
+
+    private void quickSort(Integer[] arr, int begin, int end) {
+        if (begin < end) {
+            int partitionIndex = partition(arr, begin, end);
+
+            quickSort(arr, begin, partitionIndex - 1);
+            quickSort(arr, partitionIndex + 1, end);
+        }
+    }
+
+    private int partition(Integer[] arr, int begin, int end) {
+        int pivot = arr[end];
+        int i = (begin - 1);
+
+        for (int j = begin; j < end; j++) {
+            if (arr[j] <= pivot) {
+                i++;
+
+                swapElements(arr, i, j);
             }
-            array[j] = temp;
         }
+
+        swapElements(arr, i + 1, end);
+        return i + 1;
+    }
+
+    private void swapElements(Integer[] arr, int i, int minElementIndex) {
+        Integer buf = arr[i];
+        arr[i] = arr[minElementIndex];
+        arr[minElementIndex] = buf;
     }
 
     private boolean containsBinary(int element) {
@@ -218,5 +244,10 @@ private boolean containsBinary(int element) {
         }
         return false;
     }
+    private void grow(){
+        Integer[] newArray = new Integer[array.length + array.length/2];
+        System.arraycopy(array, 0, newArray, 0, array.length);
+        array = newArray;
+    }
 
 }
diff --git a/src/test/java/org/example/IntegerListImplTest.java b/src/test/java/org/example/IntegerListImplTest.java
index 97a08ea..b31123b 100644
--- a/src/test/java/org/example/IntegerListImplTest.java
+++ b/src/test/java/org/example/IntegerListImplTest.java
@@ -9,105 +9,108 @@
 
 class IntegerListImplTest {
 
-    IntegerList IntegerList1 = new IntegerListImpl(5);
-    IntegerList IntegerList2 = new IntegerListImpl(0);
+    IntegerList integerList1 = new IntegerListImpl(5);
+    IntegerList integerList2 = new IntegerListImpl(0);
 
     @BeforeEach
     void init() {
-        IntegerList1.add(12);
-        IntegerList1.add(24);
-        IntegerList1.add(36);
+        integerList1.add(12);
+        integerList1.add(24);
+        integerList1.add(36);
     }
 
     @Test
     void add() {
-        Integer expected = IntegerList1.add(32);
-        Integer actual = IntegerList1.get(3);
+        Integer expected = integerList1.add(32);
+        Integer actual = integerList1.get(3);
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(null));
-        assertThrows(ArrayIndexOutOfBoundsException.class, () -> IntegerList2.add(null));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.add(null));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> integerList2.add(null));
     }
 
     @Test
     void testAdd() {
-        Integer expected = IntegerList1.add(2, 32);
-        Integer actual = IntegerList1.get(2);
+        Integer expected = integerList1.add(2, 32);
+        Integer actual = integerList1.get(2);
         assertEquals(expected, actual);
         expected = 36;
-        actual = IntegerList1.get(3);
+        actual = integerList1.get(3);
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(2, null));
-        IntegerList1.add(34);
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(10, 8));
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(-1, 8));
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(1, 8));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.add(2, null));
+        integerList1.add(34);
+        assertThrows(IndexOutOfBoundsException.class, () -> integerList1.add(10, 8));
+        assertThrows(IndexOutOfBoundsException.class, () -> integerList1.add(-1, 8));
+        integerList1.add(1, 8);
+        expected = 6;
+        actual = integerList1.size();
+        assertEquals(expected,actual);
     }
 
     @Test
     void set() {
-        Integer expected = IntegerList1.set(2, 65);
-        Integer actual = IntegerList1.get(2);
+        Integer expected = integerList1.set(2, 65);
+        Integer actual = integerList1.get(2);
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(2, null));
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(10, 8));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.add(2, null));
+        assertThrows(IndexOutOfBoundsException.class, () -> integerList1.add(10, 8));
     }
 
     @Test
     void remove() {
-        Integer expected = IntegerList1.remove((Integer) 36);
+        Integer expected = integerList1.remove((Integer) 36);
         Integer actual = 36;
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.remove((Integer) 36));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.remove((Integer) 36));
     }
 
     @Test
     void testRemove() {
-        Integer expected = IntegerList1.remove(2);
+        Integer expected = integerList1.remove(2);
         Integer actual = 36;
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.remove(2));
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList2.remove(0));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.remove(2));
+        assertThrows(IndexOutOfBoundsException.class, () -> integerList2.remove(0));
     }
 
     @Test
     void contains() {
-        var expected = IntegerList1.contains(36);
+        var expected = integerList1.contains(36);
         var actual = true;
         assertEquals(expected, actual);
-        expected = IntegerList1.contains(88);
+        expected = integerList1.contains(88);
         actual = false;
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.contains(null));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.contains(null));
     }
 
     @Test
     void indexOf() {
-        var expected = IntegerList1.indexOf(36);
+        var expected = integerList1.indexOf(36);
         var actual = 2;
         assertEquals(expected, actual);
-        expected = IntegerList1.indexOf(88);
+        expected = integerList1.indexOf(88);
         actual = -1;
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.indexOf(null));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.indexOf(null));
     }
 
     @Test
     void lastIndexOf() {
-        var expected = IntegerList1.lastIndexOf(36);
+        var expected = integerList1.lastIndexOf(36);
         var actual = 2;
         assertEquals(expected, actual);
-        expected = IntegerList1.lastIndexOf(88);
+        expected = integerList1.lastIndexOf(88);
         actual = -1;
         assertEquals(expected, actual);
-        assertThrows(IllegalArgumentException.class, () -> IntegerList1.lastIndexOf(null));
+        assertThrows(IllegalArgumentException.class, () -> integerList1.lastIndexOf(null));
     }
 
     @Test
     void get() {
-        var expected = IntegerList1.get(2);
+        var expected = integerList1.get(2);
         var actual = 36;
         assertEquals(expected, actual);
-        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.get(-1));
+        assertThrows(IndexOutOfBoundsException.class, () -> integerList1.get(-1));
     }
 
     @Test
@@ -117,65 +120,65 @@ void testEquals() {
         IntegerList3.add(24);
         IntegerList3.add(36);
         var expected = true;
-        var actual = IntegerList1.equals(IntegerList3);
+        var actual = integerList1.equals(IntegerList3);
         assertEquals(expected, actual);
         expected = false;
-        actual = IntegerList1.equals(IntegerList2);
+        actual = integerList1.equals(integerList2);
         assertEquals(expected, actual);
     }
 
     @Test
     void size() {
         var expected = 3;
-        var actual = IntegerList1.size();
+        var actual = integerList1.size();
         assertEquals(expected, actual);
         expected = 0;
-        actual = IntegerList2.size();
+        actual = integerList2.size();
         assertEquals(expected, actual);
     }
 
     @Test
     void isEmpty() {
         var expected = true;
-        var actual = IntegerList2.isEmpty();
+        var actual = integerList2.isEmpty();
         assertEquals(expected, actual);
         expected = false;
-        actual = IntegerList1.isEmpty();
+        actual = integerList1.isEmpty();
         assertEquals(expected, actual);
         expected = true;
-        IntegerList IntegerList3 = new IntegerListImpl(5);
-        actual = IntegerList3.isEmpty();
+        IntegerList integerList3 = new IntegerListImpl(5);
+        actual = integerList3.isEmpty();
         assertEquals(expected, actual);
     }
 
     @Test
     void clear() {
-        IntegerList1.clear();
+        integerList1.clear();
         var expected = true;
-        var actual = IntegerList1.isEmpty();
+        var actual = integerList1.isEmpty();
         assertEquals(expected, actual);
-        IntegerList2.clear();
+        integerList2.clear();
         expected = true;
-        actual = IntegerList2.isEmpty();
+        actual = integerList2.isEmpty();
         assertEquals(expected, actual);
     }
 
     @Test
     void toArray() {
         Integer[] expected = {12, 24, 36};
-        Integer[] actual = IntegerList1.toArray();
+        Integer[] actual = integerList1.toArray();
         assertIterableEquals(Arrays.asList(expected), Arrays.asList(actual));
     }
 
     @Test
     void sortInsertion() {
-        IntegerList IntegerList3 = new IntegerListImpl(5);
-        IntegerList3.add(36);
-        IntegerList3.add(24);
-        IntegerList3.add(12);
-        IntegerList3.sort();
+        IntegerList integerList3 = new IntegerListImpl(5);
+        integerList3.add(36);
+        integerList3.add(24);
+        integerList3.add(12);
+        integerList3.sort();
         Integer[] expected = {12, 24, 36};
-        Integer[] actual = IntegerList3.toArray();
+        Integer[] actual = integerList3.toArray();
         assertIterableEquals(Arrays.asList(expected), Arrays.asList(actual));
 
     }