Update Element in Array

Say you have a list of exam scores in an array. Alex’s score got typed in wrong. You do not want to rebuild the whole list. You just want to fix that one spot. That fix is called updating an element.

Updating means changing the value that is already stored at a position in the array. The good news is that this is one of the fastest things an array can do. Let’s see why. Then we will write the code in five languages.

🎯 What Does “Update” Mean Here

Updating an element is simple. You pick a position. You put a new value there. The old value is gone.

The position is called the index. An index is just the number that tells the array which slot you mean. In most languages the first slot is index 0. The next one is index 1. And so on.

So say the array is [10, 20, 30, 40] and you update index 2 with the value 99. Now you get [10, 20, 99, 40]. Only that one slot changed. Everything else stayed the same.

⚡ Why Update Is So Fast

Here is the nice part. Updating an element takes the same tiny amount of time no matter how big the array is. We call that O(1). It means constant time.

Why is it that fast? It comes down to how arrays sit in memory.

• All the elements live next to each other in one block of memory.
• The computer knows where the block starts.
• So to reach index i, it goes straight to “start + i steps”. There is no searching.

This is called direct indexed access. The computer does not check each element one by one. It goes straight to the slot. Then it drops the new value in.

🛡️ Check the Index First

There is one trap here. The index you ask for must actually exist in the array. If the array has 4 elements, the valid indexes are 0, 1, 2, and 3. There is nothing at index 7. There is nothing at index -1 either.

What happens if you try to write to an index that does not exist? In C or C++ you might quietly damage other memory. In Java or Python you get a crash with an error. Either way, it is a real bug.

So before you write the value, you check that the index is in range. The rule is simple. The index must be 0 or greater. And it must be less than the size of the array.

• If the index is valid, write the new value.
• If the index is not valid, print an error and do nothing.

This check is what makes updateAt safe to call with any number.

Steps to update an element in an array

Before we write code, let’s lay out the steps.

1. Create a function updateAt(array, index, value).
2. Inside updateAt:
   • Check if the index is valid. It must be 0 or greater, and less than the array size.
   • If the index is not valid, print an error and return.
   • If the index is valid, assign the new value: array[index] = value.
3. Inside the main function:
   • Create an array with some starting values.
   • Print the array before the update.
   • Call updateAt with an index and a new value.
   • Print the array after the update so you can see the change.

⌨️ Code to Update an Element in an Array

Now let’s see this in different programming languages. Notice how the update itself is just one line. The rest is the safety check and the printing.

#include <stdio.h>

// function to update element at a given index
void updateAt(int *arr, int size, int index, int value) {
    // Check if the index is valid
    if (index < 0 || index >= size) {
        printf("Invalid index %d. Cannot update.\n", index);
        return;
    }

    // Index is valid, so assign the new value
    arr[index] = value;
}

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

// main function
int main() {
    int arr[] = {10, 20, 30, 40};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Before update: ");
    printArray(arr, size);

    // Update index 2 with value 99
    updateAt(arr, size, 2, 99);
    printf("After update:  ");
    printArray(arr, size);

    // Try an invalid index
    updateAt(arr, size, 7, 50);

    return 0;
}

Before update: 10 20 30 40
After update:  10 20 99 40
Invalid index 7. Cannot update.

#include <iostream>
using namespace std;

// function to update element at a given index
void updateAt(int *arr, int size, int index, int value) {
    // Check if the index is valid
    if (index < 0 || index >= size) {
        cout << "Invalid index " << index << ". Cannot update." << endl;
        return;
    }

    // Index is valid, so assign the new value
    arr[index] = value;
}

// helper function to print the array
void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

// main function
int main() {
    int arr[] = {10, 20, 30, 40};
    int size = sizeof(arr) / sizeof(arr[0]);

    cout << "Before update: ";
    printArray(arr, size);

    // Update index 2 with value 99
    updateAt(arr, size, 2, 99);
    cout << "After update:  ";
    printArray(arr, size);

    // Try an invalid index
    updateAt(arr, size, 7, 50);

    return 0;
}

Before update: 10 20 30 40
After update:  10 20 99 40
Invalid index 7. Cannot update.

import java.util.Arrays;

public class UpdateAt {
    // function to update element at a given index
    public static void updateAt(int[] arr, int index, int value) {
        // Check if the index is valid
        if (index < 0 || index >= arr.length) {
            System.out.println("Invalid index " + index + ". Cannot update.");
            return;
        }

        // Index is valid, so assign the new value
        arr[index] = value;
    }

    // main function
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};

        System.out.println("Before update: " + Arrays.toString(arr));

        // Update index 2 with value 99
        updateAt(arr, 2, 99);
        System.out.println("After update:  " + Arrays.toString(arr));

        // Try an invalid index
        updateAt(arr, 7, 50);
    }
}

Before update: [10, 20, 30, 40]
After update:  [10, 20, 99, 40]
Invalid index 7. Cannot update.

# function to update element at a given index
def update_at(arr, index, value):
    # Check if the index is valid
    if index < 0 or index >= len(arr):
        print(f"Invalid index {index}. Cannot update.")
        return

    # Index is valid, so assign the new value
    arr[index] = value

def main():
    arr = [10, 20, 30, 40]

    print("Before update:", arr)

    # Update index 2 with value 99
    update_at(arr, 2, 99)
    print("After update: ", arr)

    # Try an invalid index
    update_at(arr, 7, 50)

if __name__ == "__main__":
    main()

Before update: [10, 20, 30, 40]
After update:  [10, 20, 99, 40]
Invalid index 7. Cannot update.

// function to update element at a given index
function updateAt(arr, index, value) {
    // Check if the index is valid
    if (index < 0 || index >= arr.length) {
        console.log(`Invalid index ${index}. Cannot update.`);
        return;
    }

    // Index is valid, so assign the new value
    arr[index] = value;
}

function main() {
    const arr = [10, 20, 30, 40];

    console.log("Before update:", arr);

    // Update index 2 with value 99
    updateAt(arr, 2, 99);
    console.log("After update: ", arr);

    // Try an invalid index
    updateAt(arr, 7, 50);
}
main();

Before update: [ 10, 20, 30, 40 ]
After update:  [ 10, 20, 99, 40 ]
Invalid index 7. Cannot update.

⚠️ Common Mistakes

A few small things trip people up when updating. Watch out for these.

• Forgetting the index check. Writing to an index that does not exist crashes the program or damages memory. Always check the range first.
• Off-by-one on the last index. The last valid index is size - 1, not size. If the array has 4 elements, the last index is 3.
• Confusing the index with the value. The index is the position. The value is what goes there. Mix up the two and you write the right number to the wrong spot.
• Thinking update is slow. It is not. Update is O(1). It is inserting and deleting in the middle that cost O(n), because of all the shifting.

📊 Complexity Table for Update in Array

🧩 What You’ve Learned

You can now change a value in an array safely and quickly. Here is what you picked up.

• ✅ Updating means putting a new value at an index that already exists, replacing the old value.
• ✅ Arrays give direct indexed access, so update is O(1) constant time no matter the size.
• ✅ Always check the index is valid first. It must be 0 or greater, and less than the array size.
• ✅ The update itself is just one line: array[index] = value.
• ✅ An invalid index should print an error and do nothing. It must never write out of range.

🚀 What’s Next?

You can update any single element now. Next, learn how to visit every element, and how to remove one.

• Array Traversal shows how to visit every element in the array one by one.
• Delete Element from Array covers removing an element, and why that one costs more than an update.