Inserimento elemento in posizione specifica array C++

Inserimento di un Elemento in un Array

Questo programma C++ mostra come inserire un nuovo elemento in una posizione specifica di un array, mantenendo l'ordine degli altri elementi.

Cosa fa il programma

Il programma prende un array con alcuni numeri già inseriti e aggiunge un nuovo numero in una posizione che scegliamo noi, spostando tutti gli elementi successivi verso destra.

Analisi del codice

Dichiarazione delle variabili

const int CAPACITA = 10;
int a[CAPACITA] = {7, 3, 9, 1, 5};
int n = 5;
int pos = 2;
int valore = 4;

• CAPACITA: dimensione massima dell'array (10 elementi)
• a[]: l'array che contiene inizialmente i numeri {7, 3, 9, 1, 5}
• n: numero di elementi attualmente presenti nell'array (5)
• pos: posizione dove vogliamo inserire il nuovo elemento (posizione 2)
• valore: il numero che vogliamo inserire (4)

I controlli di sicurezza

Prima di inserire l'elemento, il programma effettua due controlli importanti:

1. Controllo spazio disponibile:

   if (n == CAPACITA)

   Verifica se c'è ancora spazio nell'array. Se è pieno, non possiamo aggiungere nulla.

2. Controllo posizione valida:

   else if (pos < 0 || pos > n)

   Controlla che la posizione sia valida (tra 0 e n compreso). Possiamo inserire dalla posizione 0 fino alla posizione n (che significa "alla fine").

L'algoritmo di inserimento

Se i controlli sono superati, avviene l'inserimento:

for (int i = n; i > pos; i--)
    a[i] = a[i - 1];
a[pos] = valore;
n++;

Come funziona lo spostamento:

1. Si parte dalla fine dell'array e si va verso la posizione di inserimento
2. Ogni elemento viene spostato una posizione a destra
3. Si inserisce il nuovo valore nella posizione liberata
4. Si incrementa n per aggiornare il numero di elementi

Esempio pratico

Con i valori del programma:

• Array iniziale: [7, 3, 9, 1, 5]
• Vogliamo inserire 4 nella posizione 2

Processo di spostamento:

1. a[5] = a[4] → sposta il 5 in posizione 5
2. a[4] = a[3] → sposta l'1 in posizione 4
3. a[3] = a[2] → sposta il 9 in posizione 3
4. a[2] = 4 → inserisce il 4 in posizione 2

Risultato finale: [7, 3, 4, 9, 1, 5]

Perché si parte dalla fine?

È fondamentale partire dalla fine per evitare di sovrascrivere i dati. Se partissimo dall'inizio, perderemmo gli elementi durante lo spostamento!

Questo algoritmo è molto utile quando dobbiamo mantenere un array ordinato o quando vogliamo inserire elementi in posizioni specifiche senza perdere i dati esistenti.

// INSERIMENTO IN UNA POSIZIONE
#include <iostream>
using namespace std;

int main() {
    const int CAPACITA = 10;
    int a[CAPACITA] = {7, 3, 9, 1, 5};
    int n = 5;
    int pos = 2;                     // dove inserire
    int valore = 4;                  // cosa inserire

    cout << "Prima:  ";
    for (int i = 0; i < n; i++) cout << a[i] << " ";
    cout << endl;

    // CONTROLLO 1: c'è ancora spazio?
    if (n == CAPACITA) {
        cout << "Errore: array pieno!" << endl;
    }
    // CONTROLLO 2: la posizione è valida? (da 0 a n compreso)
    else if (pos < 0 || pos > n) {
        cout << "Errore: posizione non valida!" << endl;
    }
    // tutto ok: inserisco
    else {
        // si sposta a destra PARTENDO DALLA FINE
        for (int i = n; i > pos; i--)
            a[i] = a[i - 1];
        a[pos] = valore;
        n++;
    }

    cout << "Dopo:   ";
    for (int i = 0; i < n; i++) cout << a[i] << " ";
    cout << endl;

    return 0;
}