refactor: Enhance docs, code, add tests in InsertDeleteInArray (#6647)

Author: Hardvan

src/main/java/com/thealgorithms/others/InsertDeleteInArray.java

@@ -1,51 +1,172 @@
 package com.thealgorithms.others;
 
+import java.util.Arrays;
 import java.util.Scanner;
 
+/**
+ * Utility class for performing insert and delete operations on arrays.
+ * <p>
+ * This class demonstrates how to insert an element at a specific position and
+ * delete an element from a specific position in an integer array. Since arrays
+ * in Java have fixed size, insertion creates a new array with increased size,
+ * and deletion shifts elements to fill the gap.
+ * </p>
+ *
+ * <p>
+ * <strong>Time Complexity:</strong>
+ * </p>
+ * <ul>
+ * <li>Insert: O(n) - requires copying elements to new array</li>
+ * <li>Delete: O(n) - requires shifting elements</li>
+ * </ul>
+ *
+ * <p>
+ * <strong>Space Complexity:</strong>
+ * </p>
+ * <ul>
+ * <li>Insert: O(n) - new array of size n+1</li>
+ * <li>Delete: O(1) - in-place modification (excluding result array)</li>
+ * </ul>
+ *
+ * @author TheAlgorithms community
+ * @see <a href="https://en.wikipedia.org/wiki/Array_(data_structure)">Array
+ *      Data Structure</a>
+ */
 public final class InsertDeleteInArray {
     private InsertDeleteInArray() {
     }
 
+    /**
+     * Inserts an element at the specified position in the array.
+     * <p>
+     * Creates a new array with size = original array size + 1.
+     * Elements at positions &lt;= insertPos retain their positions,
+     * while elements at positions &gt; insertPos are shifted right by one position.
+     * </p>
+     *
+     * @param array    the original array
+     * @param element  the element to be inserted
+     * @param position the index at which the element should be inserted (0-based)
+     * @return a new array with the element inserted at the specified position
+     * @throws IllegalArgumentException if position is negative or greater than
+     *                                  array length
+     * @throws IllegalArgumentException if array is null
+     */
+    public static int[] insertElement(int[] array, int element, int position) {
+        if (array == null) {
+            throw new IllegalArgumentException("Array cannot be null");
+        }
+        if (position < 0 || position > array.length) {
+            throw new IllegalArgumentException("Position must be between 0 and " + array.length);
+        }
+
+        int[] newArray = new int[array.length + 1];
+
+        // Copy elements before insertion position
+        System.arraycopy(array, 0, newArray, 0, position);
+
+        // Insert the new element
+        newArray[position] = element;
+
+        // Copy remaining elements after insertion position
+        System.arraycopy(array, position, newArray, position + 1, array.length - position);
+
+        return newArray;
+    }
+
+    /**
+     * Deletes an element at the specified position from the array.
+     * <p>
+     * Creates a new array with size = original array size - 1.
+     * Elements after the deletion position are shifted left by one position.
+     * </p>
+     *
+     * @param array    the original array
+     * @param position the index of the element to be deleted (0-based)
+     * @return a new array with the element at the specified position removed
+     * @throws IllegalArgumentException if position is negative or greater than or
+     *                                  equal to array length
+     * @throws IllegalArgumentException if array is null or empty
+     */
+    public static int[] deleteElement(int[] array, int position) {
+        if (array == null) {
+            throw new IllegalArgumentException("Array cannot be null");
+        }
+        if (array.length == 0) {
+            throw new IllegalArgumentException("Array is empty");
+        }
+        if (position < 0 || position >= array.length) {
+            throw new IllegalArgumentException("Position must be between 0 and " + (array.length - 1));
+        }
+
+        int[] newArray = new int[array.length - 1];
+
+        // Copy elements before deletion position
+        System.arraycopy(array, 0, newArray, 0, position);
+
+        // Copy elements after deletion position
+        System.arraycopy(array, position + 1, newArray, position, array.length - position - 1);
+
+        return newArray;
+    }
+
+    /**
+     * Main method demonstrating insert and delete operations on an array.
+     * <p>
+     * This method interactively:
+     * <ol>
+     * <li>Takes array size and elements as input</li>
+     * <li>Inserts a new element at a specified position</li>
+     * <li>Deletes an element from a specified position</li>
+     * <li>Displays the array after each operation</li>
+     * </ol>
+     * </p>
+     *
+     * @param args command line arguments (not used)
+     */
     public static void main(String[] args) {
-        try (Scanner s = new Scanner(System.in)) {
-            System.out.println("Enter the size of the array");
-            int size = s.nextInt();
-            int[] a = new int[size];
-            int i;
-
-            // To enter the initial elements
-            for (i = 0; i < size; i++) {
-                System.out.println("Enter the element");
-                a[i] = s.nextInt();
-            }
+        try (Scanner scanner = new Scanner(System.in)) {
+            // Input: array size and elements
+            System.out.println("Enter the size of the array:");
+            int size = scanner.nextInt();
 
-            // To insert a new element(we are creating a new array)
-            System.out.println("Enter the index at which the element should be inserted");
-            int insertPos = s.nextInt();
-            System.out.println("Enter the element to be inserted");
-            int ins = s.nextInt();
-            int size2 = size + 1;
-            int[] b = new int[size2];
-            for (i = 0; i < size2; i++) {
-                if (i <= insertPos) {
-                    b[i] = a[i];
-                } else {
-                    b[i] = a[i - 1];
-                }
+            if (size <= 0) {
+                System.out.println("Array size must be positive");
+                return;
             }
-            b[insertPos] = ins;
-            for (i = 0; i < size2; i++) {
-                System.out.println(b[i]);
+
+            int[] array = new int[size];
+
+            System.out.println("Enter " + size + " elements:");
+            for (int i = 0; i < size; i++) {
+                array[i] = scanner.nextInt();
             }
 
-            // To delete an element given the index
-            System.out.println("Enter the index at which element is to be deleted");
-            int delPos = s.nextInt();
-            for (i = delPos; i < size2 - 1; i++) {
-                b[i] = b[i + 1];
+            System.out.println("Original array: " + Arrays.toString(array));
+
+            // Insert operation
+            System.out.println("\nEnter the index at which the element should be inserted (0-" + size + "):");
+            int insertPos = scanner.nextInt();
+            System.out.println("Enter the element to be inserted:");
+            int elementToInsert = scanner.nextInt();
+
+            try {
+                array = insertElement(array, elementToInsert, insertPos);
+                System.out.println("Array after insertion: " + Arrays.toString(array));
+            } catch (IllegalArgumentException e) {
+                System.out.println("Error during insertion: " + e.getMessage());
+                return;
             }
-            for (i = 0; i < size2 - 1; i++) {
-                System.out.println(b[i]);
+
+            // Delete operation
+            System.out.println("\nEnter the index at which element is to be deleted (0-" + (array.length - 1) + "):");
+            int deletePos = scanner.nextInt();
+
+            try {
+                array = deleteElement(array, deletePos);
+                System.out.println("Array after deletion: " + Arrays.toString(array));
+            } catch (IllegalArgumentException e) {
+                System.out.println("Error during deletion: " + e.getMessage());
             }
         }
     }