Write A Program To Insert And Delete An Element In An Array In C

Arrays in C are fixed-size data structures, meaning their capacity is set at compile time or upon declaration. This static nature can make dynamic operations, such as adding or removing elements, challenging compared to more flexible data structures. In this article, you will learn how to implement functions for inserting and deleting elements in an array in C, managing the array's logical size within its fixed physical capacity.

Problem Statement

The primary challenge with C arrays is their static allocation. When an element needs to be inserted, space must be made by shifting existing elements. Conversely, when an element is deleted, the gap created needs to be closed by shifting subsequent elements. Both operations require careful index management and boundary checks to prevent data corruption or program crashes. Effectively managing the current number of elements (logical size) within the array's fixed maximum capacity is crucial for these operations.

Example

Consider an array initially containing [10, 20, 30, 40].

• After inserting 25 at position 2:

The array becomes [10, 20, 25, 30, 40].

• After deleting the element at position 3 (which is 30):

The array becomes [10, 20, 25, 40].

Background & Knowledge Prerequisites

To understand the concepts discussed in this article, you should have a basic understanding of:

• C programming fundamentals: Variables, data types, operators.
• Arrays: Declaration, initialization, accessing elements using indices.
• Loops: for loops for iteration.
• Functions: Defining and calling functions, passing arguments by value and by reference (pointers).
• Pointers: Especially for modifying an integer (like the array's current size) within a function.

Use Cases or Case Studies

Managing dynamic data within fixed arrays is common in several programming scenarios:

• Inventory Management Systems: Adding new items to stock or removing sold items from a limited-capacity storage array.
• Task Schedulers: Inserting new tasks into a queue based on priority or deleting completed tasks.
• Game Development: Managing a player's inventory or a list of active entities in a game world where array sizes might be pre-defined.
• Simple Record Keeping: Maintaining a list of student records or customer details in a system that doesn't require complex dynamic memory allocation.
• Implementing Basic Data Structures: As a foundational step before understanding more complex structures like dynamic arrays (vectors) or linked lists.

Solution Approaches

We will implement two core functions: one for inserting an element and another for deleting an element. Both functions will operate on an array with a defined maximum physical size and a variable current logical size.

Inserting an Element at a Specific Position

This approach involves shifting elements to the right starting from the insertion point to create space for the new element.

• Summary: To insert an element, check if the array is full or the position is invalid. If valid, shift all elements from the desired insertion position to the end, one position to the right, then place the new element at the specified position.

// Array Insertion in C
#include <stdio.h>

#define MAX_SIZE 10 // Define a maximum physical size for the array

// Function to print the array
void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\\n");
}

// Function to insert an element at a specific position
// Returns 1 on success, 0 on failure (e.g., array full or invalid position)
int insertElement(int arr[], int *currentSize, int element, int position) {
    // Step 1: Check if the array is full
    if (*currentSize >= MAX_SIZE) {
        printf("Error: Array is full. Cannot insert.\\n");
        return 0;
    }

    // Step 2: Check for valid insertion position
    // Position must be between 0 and currentSize (inclusive)
    if (position < 0 || position > *currentSize) {
        printf("Error: Invalid position for insertion.\\n");
        return 0;
    }

    // Step 3: Shift elements to the right to make space
    // Start from the last element and move towards the insertion point
    for (int i = *currentSize - 1; i >= position; i--) {
        arr[i + 1] = arr[i];
    }

    // Step 4: Insert the new element
    arr[position] = element;

    // Step 5: Increment the current size of the array
    (*currentSize)++;

    return 1; // Success
}

int main() {
    int arr[MAX_SIZE] = {10, 20, 30, 40, 50}; // Initial elements
    int currentSize = 5; // Current number of elements in the array

    printf("Original array: ");
    printArray(arr, currentSize);

    // Insert 25 at position 2
    printf("Attempting to insert 25 at position 2...\\n");
    if (insertElement(arr, &currentSize, 25, 2)) {
        printf("Array after insertion: ");
        printArray(arr, currentSize);
    }

    // Insert 5 at position 0
    printf("Attempting to insert 5 at position 0...\\n");
    if (insertElement(arr, &currentSize, 5, 0)) {
        printf("Array after insertion: ");
        printArray(arr, currentSize);
    }

    // Try to insert beyond max size (demonstrates error handling)
    printf("Attempting to insert 99 at an invalid position (large index)...\\n");
    insertElement(arr, &currentSize, 99, 15);

    printf("Attempting to insert 60 at position 8 (array full scenario later)...\\n");
    if (insertElement(arr, &currentSize, 60, currentSize)) {
        printf("Array after insertion: ");
        printArray(arr, currentSize);
    }
    printf("Current size after multiple insertions: %d\\n", currentSize);

    return 0;
}

Run

• Sample Output:

Original array: 10 20 30 40 50 
Attempting to insert 25 at position 2...
Array after insertion: 10 20 25 30 40 50 
Attempting to insert 5 at position 0...
Array after insertion: 5 10 20 25 30 40 50 
Attempting to insert 99 at an invalid position (large index)...
Error: Invalid position for insertion.
Attempting to insert 60 at position 8 (array full scenario later)...
Array after insertion: 5 10 20 25 30 40 50 60 
Current size after multiple insertions: 8

• Stepwise Explanation:

1. Check Capacity: The insertElement function first verifies if currentSize is already equal to MAX_SIZE. If it is, the array is full, and insertion is not possible.
2. Validate Position: It then checks if the position provided is within the valid range (0 to currentSize). An invalid position would lead to out-of-bounds access.
3. Shift Elements: A for loop iterates from currentSize - 1 down to position. In each iteration, arr[i] is moved to arr[i + 1]. This makes space for the new element at position.
4. Insert Element: The element is then placed at arr[position].
5. Update Size: Finally, currentSize is incremented by one to reflect the addition of a new element. The * operator is used with currentSize because it's passed as a pointer to allow modification within the function.

Deleting an Element from a Specific Position

This method involves shifting elements to the left, overwriting the element to be deleted and effectively closing the gap.

• Summary: To delete an element, check if the array is empty or the position is invalid. If valid, shift all elements from the position *after* the deleted element one position to the left, effectively overwriting the element to be removed.

// Array Deletion in C
#include <stdio.h>

#define MAX_SIZE 10 // Define a maximum physical size for the array

// Function to print the array (repeated for clarity, but ideally in a common utility)
void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\\n");
}

// Function to delete an element from a specific position
// Returns 1 on success, 0 on failure (e.g., array empty or invalid position)
int deleteElement(int arr[], int *currentSize, int position) {
    // Step 1: Check if the array is empty
    if (*currentSize <= 0) {
        printf("Error: Array is empty. Cannot delete.\\n");
        return 0;
    }

    // Step 2: Check for valid deletion position
    // Position must be between 0 and currentSize - 1 (inclusive)
    if (position < 0 || position >= *currentSize) {
        printf("Error: Invalid position for deletion.\\n");
        return 0;
    }

    // Step 3: Shift elements to the left to overwrite the element at 'position'
    // Start from the element *after* the deletion point
    for (int i = position; i < *currentSize - 1; i++) {
        arr[i] = arr[i + 1];
    }

    // Step 4: Decrement the current size of the array
    (*currentSize)--;

    return 1; // Success
}

int main() {
    int arr[MAX_SIZE] = {5, 10, 20, 25, 30, 40, 50, 60}; // Array after previous insertions
    int currentSize = 8;

    printf("Original array for deletion: ");
    printArray(arr, currentSize);

    // Delete element at position 2 (which is 20)
    printf("Attempting to delete element at position 2...\\n");
    if (deleteElement(arr, &currentSize, 2)) {
        printf("Array after deletion: ");
        printArray(arr, currentSize);
    }

    // Delete element at position 0 (which is 5)
    printf("Attempting to delete element at position 0...\\n");
    if (deleteElement(arr, &currentSize, 0)) {
        printf("Array after deletion: ");
        printArray(arr, currentSize);
    }

    // Delete element at the new last position (which is 60)
    printf("Attempting to delete element at last position (currentSize - 1)...\\n");
    if (deleteElement(arr, &currentSize, currentSize - 1)) {
        printf("Array after deletion: ");
        printArray(arr, currentSize);
    }

    // Try to delete from an invalid position
    printf("Attempting to delete from an invalid position (large index)...\\n");
    deleteElement(arr, &currentSize, currentSize); // currentSize is an invalid index

    printf("Current size after multiple deletions: %d\\n", currentSize);

    return 0;
}

Run

• Sample Output:

Original array for deletion: 5 10 20 25 30 40 50 60 
Attempting to delete element at position 2...
Array after deletion: 5 10 25 30 40 50 60 
Attempting to delete element at position 0...
Array after deletion: 10 25 30 40 50 60 
Attempting to delete element at last position (currentSize - 1)...
Array after deletion: 10 25 30 40 50 
Attempting to delete from an invalid position (large index)...
Error: Invalid position for deletion.
Current size after multiple deletions: 5

• Stepwise Explanation:

1. Check Capacity: The deleteElement function first checks if currentSize is zero or less. If so, the array is empty, and there's nothing to delete.
2. Validate Position: It then ensures that the position is valid (between 0 and currentSize - 1). Deleting at an index equal to currentSize or beyond would be an out-of-bounds access.
3. Shift Elements: A for loop iterates from position up to currentSize - 2. In each iteration, arr[i + 1] is moved to arr[i]. This overwrites the element at position and shifts all subsequent elements one slot to the left, closing the gap.
4. Update Size: Finally, currentSize is decremented by one to reflect the removal of an element.

Conclusion

Working with arrays in C requires careful manual management of elements, especially for insertion and deletion operations. By implementing shifting logic, you can effectively add and remove elements from a logically dynamic array while respecting its fixed physical size. These techniques are fundamental for understanding how data is manipulated in memory and form the basis for more complex data structures.

Summary

• C arrays have a fixed size, making dynamic operations challenging.
• Insertion involves shifting elements to the right to create space for a new element.
• Deletion involves shifting elements to the left to overwrite the element being removed and close the gap.
• Both operations require careful bounds checking to prevent errors.
• A currentSize variable is used to track the logical number of elements within the array's maximum MAX_SIZE.
• Pointers are essential for functions to modify the currentSize variable.