• Non ci sono risultati.

Definizione del problema: Trovare il valore minimo tra gli elementi di un array di interi, con cardinalità 50, ed indicarne la posizione

N/A
N/A
Protected

Academic year: 2021

Condividi "Definizione del problema: Trovare il valore minimo tra gli elementi di un array di interi, con cardinalità 50, ed indicarne la posizione"

Copied!
71
0
0

Testo completo

(1)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 1

Esempio

Definizione del problema: Trovare il valore minimo tra gli elementi di un array di interi, con cardinalità 50, ed indicarne la posizione

Definizione dei dati del problema:

I: il riempimento; il valore di ciascun element dello array Pi: il numero degli elementi da inserire (riempimento) non può essere maggiore della cardinalità dell’array

U: il valore minimo; la posizione dell’elemento con valore minimo

Pu: nessuna

Esempio

Nome variabile Descrizione Tipo

riemp riempimento INT VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

MIN Elemento con il valore del minimo INT POS Posizione dove è contenuto MIN INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I Indice array INT

Tabella delle variabili di algoritmo

(2)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 3

Esempio

Descrizione del metodo di elaborazione:

è indicato il numero di quanti elementi si vogliono inserire: tale numero deve essere minore della cardinalità dell’array.

Si legge il valore di ciascun elemento da immettere.

Si pone il minimo uguale al primo elemento dell’array e POS = 0 si verifica se ciascun altro elemento dell’array è inferiore al minimo fissato, in tal caso si aggiorna il valore del minimo e della posizione in cui esso si trova nell’array

si stampa il valore minimo e la posizione in cui esso si trova

Esempio - il programma C

#include<stdio.h>

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp,MIN, POS;

do

{ printf (“quanti elementi vuoi inserire?\n”);

scanf (“%d”, &riemp); } while ( riemp>cardinalita);

// Legge in input gli elementi del vettore for (I= 0; I< riemp; I++)

{ printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

(3)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 5

// Cerca il valore minimo nello array MIN = VET[0]; POS=0;

for (I=1; I< riemp; I++) {

if (VET[I]<MIN) {

MIN=VET[I];

POS=I;

} }

printf(“il valore minimo = %d si trova nella posizione numero%d\n” , MIN, POS);

}

Esempio - il programma C

Esempio

Definizione del problema: Trovare il valore minimo ed il valore massimo tra gli elementi di un array di interi, con cardinalità 50, ed indicarne la posizione

Definizione dei dati del problema:

I: il riempimento; il valore di ciascun elemento

Pi: il numero degli elementi da inserire non può essere maggiore della cardinalità dell’array

U: il valore minimo nello array; il valore massimo nello array; la posizione dell’elemento con valore minimo; la posizione dell’elemento con valore massimo

Pu: nessuna

(4)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 7

Esempio

Nome variabile Descrizione Tipo

riemp riempimento INT VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

MIN Elemento con il valore del minimo INT POSMIN Posizione dove è contenuto MIN INT MAX Elemento con il valore del massimo INT POSMAX Posizione dove è contenuto MAX INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I Indice array INT

Tabella delle variabili di algoritmo

Esempio

Descrizione del metodo di elaborazione:

è indicato il numero di quanti elementi si vogliono inserire: tale numero deve essere minore della cardinalità dell’array e si ripete l’immissione se tale condizione non è rispettata.

Si legge il valore di ciascun elemento da immettere.

Si pone MIN uguale al primo elemento dell’array e POSMIN = 0, Si pone MAX uguale al primo elemento dell’array e POSMAX = 0,

Si verifica se ciascun altro elemento dell’array è inferiore al minimo fissato, in tal caso si aggiorna il valore del minimo e della posizione in cui esso si trova nell’array

Se il valore dell’elemento non è inferiore al minimo si verifica se l’elemento è maggiore del valore massimo, in tal caso si aggiorna il valore del massimo e della posizione in cui esso si trova nell’array

Si stampa il valore minimo e la posizione in cui esso si trova Si stampa il valore massimo e la posizione in cui esso si trova

(5)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 9

Esempio - il programma C

#include<stdio.h>

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp, MIN, MAX, POSMIN, POSMAX;

do

{ printf (“quanti elementi vuoi inserire?\n”);

scanf (“%d”, &riemp); } while ( riemp>cardinalita);

// Legge in input gli elementi del vettore for (I= 0; I< riemp; I++)

{ printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

// Cerca il valore minimo e quello massimo nello array MIN = VET[0]; POSMIN=0;

MAX = VET[0]; POSMAX=0;

for (I=1; I< riemp; I++) { if (VET[I]<MIN)

{ MIN=VET[I];

POSMIN=I;

} else

{if (VET[I]>MAX) { MAX=VET[I];

POSMAX=I;

} } }

Esempio - il programma C

(6)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 11

printf(“il valore minimo = %d si trova nella posizione numero%d\n” , MIN, POSMIN);

printf(“il valore massimo = %d si trova nella posizione numero%d\n” , MAX, POSMAX);

} //fine programma

Esempio - il programma C

Esempio

Analisi e Specifica

Definizione del problema: Inserire i valori di tutti gli elementi di un array monodimensionale di interi, composto da 50 elementi, visualizzare il contenuto dello array così ottenuto, e dopo calcolare la sommatoria degli elementi di indice dispari (l’indice 0 è considerato pari) e la produttoria degli elementi con valore pari.

Definizione dei dati del problema:

I: il valore di ciascun elemento dello array di numeri interi

Pi: il numero degli elementi da inserire non può essere maggiore della cardinalità dell’array

U: lo array ‘riempito’ con i valori di tutti gli elementi, la sommatoria degli elementi di indice dispari, la produttoria degli elementi con valore pari Pu: lo array non può essere ‘vuoto’; la produttoria deve essere un numero pari

(7)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 13

Esempio

Nome variabile Descrizione Tipo

VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

VET array di interi con i valori immessi INT

SommaIndicidispari sommatoria elementi indice dispari INT ProduttoriaPari produttoria elementi con valore pari INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I Indice array INT

Tabella delle variabili di algoritmo

Esempio Progettazione

Descrizione del metodo di elaborazione:

• Con un ciclo ripetitivo, si effettua la lettura del valore di ciascun elemento dell’array.

• Si visualizza, sempre usando un ciclo ripetitivo, il contenuto dello array, stampando ad ogni passo del ciclo il valore di ciascun elemento dello array

• Si Inizializza a zero il valore della sommatoria dei valori nelle posizioni di indice dispari, ed a uno la produttoria degli elementi con valore pari.

• Con un ciclo ripetitivo che parte dalla posizione di indice 1 e con step di incremento pari a due si calcola la sommatoria dei valori nelle posizioni di indice dispari. Si stampa il risultato ottenuto.

• Con un ciclo ripetitivo che parte dalla posizione di indice 0 e con step di incremento pari a 1 si visitano gli elementi dello array si verifica se il valore dell’elemento è pari ed in tal caso lo si moltiplica al valore corrente della produttoria. Si stampa il risultato ottenuto.

(8)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 15

#include< stdio. h>

main()

{const int CARD=50;//costante con nome con valore 50 int Vett[CARD], i, SommaIndicidispari,

ProduttoriaPari;

// Legge in input i valori di tutti gli elementi dello array

for (i= 0; i<CARD; i++) {

printf(“Valore di Vett(%d)\ n", i);

scanf("%d", &Vett[ i]);

}

// Stampa tutti gli elementi dello array

for (i= 0; i<CARD; i++)

printf(“Vett(%d)=% d\n", i, Vett[i]);

Esempio - il programma C

// calcola la sommatoria degli elementi di indice dispari

SommaIndicidispari=0;

for (i= 1; i<CARD; i=i+2)

SommaIndicidispari= SommaIndicidispari + Vett[i];

printf(“Sommatoria valori elementi in posti di indice dispari=% d\n", SommaIndicidispari);

Esempio - il programma C

(9)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 17

// calcola la sommatoria degli elementi di indice dispari // un altro modo ma meno efficiente

Sommadispari=0;

for (i= 0; i< CARD; i++)

{if ((i%2)!=0) // verifica se il valore di è // un numero dispari

Sommadispari= Sommadispari+Vett[i];

}

printf(“Sommatoria valori elementi in posti di indice dispari=% d\ n", Sommadispari);

Esempio - il programma C

// calcola la produttoria degli elementi con valore pari

Produttoriapari = 1;

for (i= 0; i<CARD; i++) { if (Vett[i]%2 == 0)

Produttoriapari= Produttoriapari * Vett[i];

}

printf(“Produttoria elementi con valore pari = %d\n”, Produttoriapari);

} // fine programma

Esempio - il programma C

(10)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 19

Esempio

Analisi e Specifica

Definizione del problema: ....

.... Calcolare la produttoria degli elementi con valore multiplo di 5.

Definizione dei dati del problema:

I: il valore di ciascun elemento dello array di numeri interi Pi: il numero degli elementi da inserire non può essere maggiore della cardinalità dell’array

U: lo array ‘riempito’ con i valori di tutti gli elementi, la sommatoria degli elementi di indice dispari; produttoria elementi con valore multiplo di cinque

Pu: lo array non può essere ‘vuoto’

float Produttoria_5;

// calcola la produttoria degli elementi di valore multiplo 5

Produttoria_5 = 1;

for (i= 1; i< CARD; i++) {if (Vett[i] % 5 == 0)

Produttoria_5 = Produttoria_5 * Vett[i];

}

printf(“Produttoria valori multipli di 5 = %f\ n", Produttoria_5);

} // fine programma

Esempio - il programma C

(11)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 21

Esempio

Definizione del problema:

Verificare se in un array monodimensionale di interi, composto da 50 elementi, esiste un determinato valore dato in input.

Se questo valore esiste indicare la posizione del primo elemento che lo contiene, e terminare la ricerca. Lo array può essere ‘riempito’ parzialmente.

Definizione dei dati :

I: il valore di ciascun elemento; il valore da cercare; riempimento Pi: riempimento non può essere maggiore della cardinalità dello array U: la posizione del primo elemento dello array con valore uguale a quello cercato

Pu: la posizione del primo elemento dello array con valore uguale a quello cercato non maggiore del riempimento

Esempio

Nome variabile Descrizione Tipo

riemp riempimento INT

VET(I) elemento dell’array INT

VAL valore da cercare nell’array INT

Nome variabile Descrizione Tipo

TROVATO Indica se esiste un elemento pari a VAL BOOL POS Posizione dove è contenuto VAL INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I indice array INT

Tabella delle variabili di algoritmo

(12)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 23

Esempio

Descrizione del metodo di elaborazione:

è immesso il numero di quanti elementi si vogliono inserire: se immesso un valore maggiore della cardinalità dello array deve essere richiesta

l’iimmissione di un valore valido

Con un ciclo ripetitivo, si legge il valore di ciascun elemento da immettere.

Si immette il valore che si vuole cercare nello array.

Con un ciclo iterativo, si verifica se tale valore esiste nello array: se esiste viene visualizzata la posizione del primo elemento che lo contiene ed il ciclo termina appena lo si trova;

se non esiste viene visualizzata la scritta ‘il valore indicato non esiste nello array’.

#include<stdio.h>

main()

{const int cardinalita=50;

int VET[cardinalita], I, riemp,VAL, POS;

int trovato;

do

{ printf (“quanti elementi vuoi inserire?\n”);

scanf (“%d”, & riemp); } while ( riemp>cardinalita);

// Legge in input gli elementi del vettore for (I= 0; I< riemp; I++)

{ printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

// Immissione valore da cercare

printf (“immetti valore da cercare\n”);

scanf (“%d”, &VAL);

Esempio - il programma C

(13)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 25

//Cerca se il valore immesso esiste in array (ricerca lineare)

POS=0; trovato=0; // trovato = falso I=0;

do

{ if (VET[I] == VAL)

{trovato = 1; // valore trovato in array POS=I;}

I++;

}

while ( (trovato == 0) && ( I < riemp) );

if (trovato == 1)

printf (“valore immesso %d in posizione %d\n’, VAL, POS);

else

printf(“il valore indicato %d non esiste nello array\n”, VAL);

}

// Cerca se valore immesso esiste in array (ricerca lineare)

POS=0; trovato=0; // trovato = falso I=0;

while ((VET[I] != VAL) && ( I < riemp)) I++;

if (I < riemp) {trovato = 1;

POS=I; } if (trovato == 1)

printf (“valore immesso %d in posizione %d\n”, VAL, POS);

else

printf(“il valore indicato %d non esiste nello array\n”, VAL);

}

… un’altra soluzione …

(14)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 27

// Cerca se valore immesso esiste in array (ricerca lineare)

POS=0; trovato=0; // trovato = falso I=0;

while ((VET[I] != VAL) && ( I < riemp)) I++;

if (I < riemp)

{printf (“valore immesso %d in posizione %d\n”, VAL, I);

else

printf(“il valore indicato %d non esiste nello array\n”, VAL);

}

… un’altra soluzione …

// Cerca se valore immesso esiste in array (ricerca lineare)

trovato=0;

I=0;

while ((trovato==0) && (I < riemp))

{trovato = (VET[I]==VAL);//assegna a trovato il risultato //del confronto (0 se falso)

I++;

}

if (trovato != 0)

printf(‘il valore immesso %d in posizione %d\n”, VAL, (I-1));

else

printf(“il valore indicato %d non esiste nello array\n”, VAL);

}

… ancora un’altra soluzione …

(15)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 29

Esempio

Definizione del problema: In un array monodimensionale di interi, composto da 50 elementi e riempito con valori in input da tastiera, contare il numero delle occorrenze di un determinato valore dato in input. Indicare anche le posizioni degli elementi dello array uguali al valore cercato. Lo array può essere ‘riempito’ parzialmente.

Definizione dei dati :

I: il valore di ciascun elemento; il valore da cercare; (eventuale) riempimento

Pi: se usato un riempimento questo non può essere maggiore della cardinalità dello array

U: Numero di occorrenze del valore cercato, gli indici degli elementi dello array con valore uguale a quello cercato

Pu: Numero di occorrenze non negativo, gli indici degli elementi dello array con valore uguale a quello cercato non maggiori del riempimento

Esempio

Nome variabile Descrizione Tipo

riemp riempimento INT

VET(I) elemento dell’array INT

VAL valore da cercare nell’array INT

Nome variabile Descrizione Tipo

NumOccorrenze Numero occorrenze pari a VAL INT I Indice posizione elemento uguale a VAL INT Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I indice array INT

Tabella delle variabili di algoritmo

(16)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 31

Esempio

Descrizione del metodo di elaborazione:

è indicato il numero di quanti elementi si vogliono inserire: tale numero deve essere non maggiore della cardinalità dell’array;

Con un ciclo ripetitivo, si legge il valore di ciascun elemento da immettere;

Si immette il valore di VAL da cercare nell’array;

Si inizializza a zero il valore di NumOccorrenze;

Con un ciclo ripetitivo:

si verifica se ciascun elemento dello array ha il valore uguale a VAL ed in tal caso si incrementa di 1 il valore di NomOccorrenze e si stampa l’indice dell’elemento verificante la condizione di uguaglianza;

Alla fine del ciclo si stampa il valore di NumOccorrenze.

#include<stdio.h>

main()

{const int cardinalita=50;

int VET[cardinalita], I,riemp,VAL,NumOccorrenze=0;

do

{printf (“quanti elementi vuoi inserire?\n”);

scanf (“%d”, & riemp); } while ( riemp>cardinalita);

// Legge in input gli elementi del vettore

for (I= 0; I< riemp; I++)

{printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

// Immissione valore da cercare

printf (“immetti valore da cercare\n”);

scanf (“%d”, &VAL);

Esempio - il programma C

(17)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 33

// Conta le occorrenze di VAL (ricerca lineare)

for (I= 0; I< riemp; I++) { if (VET[I] == VAL)

{NumOccorrenze++;

printf(“Valore %d in posizione %d\n”, VAL, I);

} }

printf(“valore %d trovato %d volte\n”, VAL,

NumOccorrenze);

}

VAL = 23

5 28 23 47 25

VET

0 1 2 3 4 5

…...

49 6

23

riemp = 6

NumOccorrenze = 2

valore 23 trovato 2 volte nelle posizioni:

posizione = 2 posizione = 5

posizione

0 1 2 3 4 5

…...

49 6

2 5

... Una differente soluzione : usando un array in cui memorizzare le posizioni

(18)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 35

... Una differente soluzione

// Conta le occorrenze di VAL (ricerca lineare) // usando un array in cui memorizzare le posizioni

int posizione[cardinalita];

… …

for (I= 0; I< riemp; I++) { if (VET[I] == VAL)

{posizione[NumOccorrenze]=I;

NumOccorrenze++;

} }

printf (“valore %d trovato %d volte\n”, VAL, NumOccorrenze);

printf (“valore trovato nelle posizioni:\n”);

for(I= 0; I < NumOccorrenze; I++)

printf(“posizione = %d\n”, posizione[I]);

}

Visita totale: vengono analizzati tutti gli elementi Si usa un ciclo a conteggio

E’ il caso degli esempi della ricerca del minimo e dell’ordinamento

Visita finalizzata: la visita termina quando un elemento dell’array verifica una certa condizione

Si usa un ciclo iterativo due condizioni di uscita:

una sull’indice di scansione (visitati tutti gli elementi si esce comunque dal ciclo) e

l’altra che dipende dal problema specifico ...

… in ogni caso si termina se si sono visitati tutti gli elementi dell’array senza trovare l’elemento dato

E’ il caso della ricerca di un elemento (termina se l’elemento è stato trovato ...)

Visita degli elementi di un array

(19)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 37

… usando un sottoprogramma per riempire lo array …

#include<stdio.h>

void leggivet_Parz(int Vet1[], int card1, int *riemp1);

/* per il codice di leggivet_Parz(…) vedere la procedure dell’esercizio/esempio visto a tale proposito */

main()

{const int cardinalita=50;

int VET[cardinalita], I, riemp,VAL, POS;

int trovato;

leggivet_Parz(VET, cardinalita, &riemp);

// Immissione valore da cercare

printf (“immetti valore da cercare\n”);

scanf (“%d”, &VAL);

……… // Il programma prosegue come

Esempio - il programma C

Ordinamento di un array monodimensionale Definizione del problema: Ordinare in senso crescente gli elementi di un array monodimensionale di interi e visualizzare l’array risultante.

Definizione dei dati:

I: riempimento; il valore di ciascun elemento dello array Pi: il numero degli elementi da inserire (riempimento) non può essere maggiore della cardinalità dell’array

U: l’array monodimensionale con gli elementi ordinati in senso crescente

Pu:

T[i] T[i+1] " i=1..n dove T è lo array da ordinare

(20)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 39

Tabella delle variabili di ingresso

Nome variabile Descrizione Tipo

VET Array ordinato INT

Tabella delle variabili di uscita

Ordinamento di array: per selezione

Nome variabile Descrizione Tipo

riemp riempimento INT

VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

I indice array INT

???

Tabella delle variabili di algoritmo

Ordinamento di array: per selezione

Descrizione del metodo di elaborazione:

Ordinamento per selezione (detto anche per minimi successivi).

Detto T lo array mono-dimensionale di cardinalità n, per ottenere l’ordinamento desiderato deve verificarsi che sia

T[i] T[i+1] " i=1..n.

• Si trova, allora, il valore minimo T[p] dell’intero array e si scambia il valore di T[p] con quello in prima posizione (T[0]);

• poi, si trova il nuovo minimo T[p] tra tutti gli elementi tra la seconda e l’ultima posizione (T[1] e T[n]) e si scambia il valore di T[p] con quello in seconda posizione (T[1]);

• ... si ha una parte ordinata e una NON ancora ordinata

• si continua in tal modo con tutti gli altri elementi dell’array nella parte NON ancora ordinata, scambiando di posto il primo elemento della parte NON ancora ordinata con il minimo della parte NON ordinata.

• Alla fine sono visualizzati gli elementi dell’array risultante.

(21)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 41

9 5 8 2 4

2 5 8 9 4

2 4 8 9 5

2 4 8 9 5

2 4 5 9 8

2 4 5 9 8

2 4 5 8 9

Ordinamento di array: per selezione

In blu parte già ordinata In rosso minimo della parte NON ancora ordinata

9 5 8 2 4

2 5 8 9 4

Tabella delle variabili di ingresso

Nome variabile Descrizione Tipo

VET Array ordinato INT

Tabella delle variabili di uscita

Ordinamento di array: per selezione

Nome variabile Descrizione Tipo

riemp riempimento INT

VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

I,J indice array INT

temp variabile appoggio per swap INT POS Posizione minimo INT MIN Minimo in parte non ordinata dell’array INT

Tabella delle variabili di algoritmo

(22)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 43

Ordinamento di array: per selezione

Descrizione del metodo di elaborazione:

... inserimento dei valori nello array ….

• Usando un ciclo si visita completamente lo array T[] e ad ogni passo del ciclo:

• Si trova il valore minimo T[p] della parte NON ancora ordinata dello array e si scambia il valore di T[p] con quello in prima posizione della parte NON ancora ordinata (inizialmente la parte non ancora ordinata coincide con l’intero array)

• Alla fine sono visualizzati gli elementi dell’array ordinato risultante.

Il programma in C

Ordinamento di array:

per selezione

#include<stdio.h>

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp, J, POS, temp, MIN;

do

{ printf (“quanti elementi vuoi inserire? (Max=%d)\n”, cardinalita);

scanf (“%d”, & riemp); } while ( riemp>cardinalita);

// Legge in input gli elementi del vettore for (I= 0; I< riemp; I++)

{ printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

(23)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 45

// trova minimo parte non ordinata e scambia for (I=0;I<(riemp-1);I++)

{MIN= VET[I];

POS=I;

for (J=(I+1);J<riemp;J++) { if (VET[J]<MIN)

{ MIN=VET[J];

POS=J;

} }

temp= VET[I];

VET[I]= VET[POS]; // ovvero VET[I]=MIN VET[POS]=temp;

}

// Stampa array ordinato

for (I= 0; I< riemp; I++) printf("% d\ n", VET[ I]);

}

Il programma in C

Ordinamento di array:

per selezione

... swapping ...

temp= VET[I];

VET[I]= VET[POS];

VET[POS]=temp;

Ordinamento di array:

per selezione Lo swapping

9 5 8 2 4 9

temp

2 5 8 9 4 9

temp

2 5 8 9 4

... I=0 ; POS=3; ...

9 5 8 2 4

temp= VET[0];

temp

2 5 8 2 4 9

VET[0]= VET[3];

VET[3]=temp;

(24)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 47

... swapping ...

ATTENZIONE A NON FARE:

VET[I]= VET[POS];

VET[POS]=VET[I];

E’ SBAGLIATO !!!

Ordinamento di array:

per selezione Lo swapping

2 5 8 2 4

... I=0 ; POS=3; ...

VET[0]= VET[3];

VET[3]=VET[0];

9 5 8 2 4

!!??

#include <stdio.h>

void leggivet_riemp(int Vet1[],int card1, int *riemp1);

void stampavet(int Vet1[ ], int riemp1);

void swap(int *a, int *b);

void ordina_vet_selezione(int Vet1[],int riemp1);

Il programma in C strutturato con sottoprogrammi

Ordinamento di array: per selezione

main()

{const int card=20;

int vet[card], i, j,riemp, temp, min, pos;

leggivet_riemp(vet, card, &riemp);

printf("Array immesso:\n");

stampavet(vet, riemp);

ordina_vet_selezione(vet, riemp);

printf("\n \n Array Ordinato:\n");

stampavet(vet, riemp);

}

(25)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 49

void leggivet_riemp(int Vet1[],int card1, int *riemp1) {int I;

do

{printf("quanti elementi vuoi inserire (MAX %d)?\n", card1);

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{ printf("immetti Vet[ %d ]= \n",I) ; scanf("%d", &Vet1[I]);

} }

void stampavet(int Vet1[], int riemp1)

{ int I; ; for (I=0;I<riemp1; I++)

printf("Vet1[ %d ]= %d \n", I, Vet1[I] );

}

void swap(int *a, int *b) {int temp;

temp=*a;

*a=*b;

*b=temp;

}

void ordina_vet_selezione(int Vet1[],int riemp1) {int i, j, min, pos, temp;

min=Vet1[0];pos=0;

for (i=0; i<riemp1-1; i++) {min=Vet1[i]; pos=i;

for (j=i+1; j<riemp1; j++) { if (Vet1[j]<min)

{ min=Vet1[j];

pos=j;

} }

swap(&Vet1[i], &Vet1[pos]);

}

(26)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 51

Ordinamento di array

… una variante …

... si confronta (nella parte non ancora ordinata) un elemento dello array con tutti i successivi e si effettua lo swap se questo è minore dell’elemento in esame ...

Ordinamento di array

9 5 8 2 4

I = 0

5 9 8 2 4

J = 1

5 9 8 2 4

J = 2

2 9 8 5 4

J = 3

2 9 8 5 4

J = 4 I = 1

2 9 8 5 4

J = 2

2 8 9 5 4

2 5 9 8 4

J = 3

2 4 9 8 5

J = 4

2 4 9 8 5

I=2

2 4 8 9 5

J = 3

2 4 5 9 8

J = 4

2 4 5 9 8

I = 3

2 4 5 8 9

J = 4

2 4 5 8 9

… una variante …

... si confronta un elemento dello array con tutti i successivi e si effettua lo swap se questo è minore dell’elemento in esame ...

(27)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 53

….

for (I=0; I<(riemp-1); I++) { for (J=(I+1); J<riemp; J++)

{ if (VET[J]< VET[I]) { temp = VET[I];

VET[I] = VET[J];

VET[J] = temp;

} } }

// Stampa array ordinato

for (I= 0; I< riemp; I++) printf("% d\ n", VET[ I]);

}

Il programma in C

Ordinamento di array

... si confronta un elemento dello array con tutti i successivi e si effettua lo swap se questo è minore dell’elemento in esame ...

… una variante …

void ordina_vet(int Vet1[],int riemp1) {int I, J, temp;

for (I=0; I<(riemp1-1); I++) { for (J=(I+1); J<riemp1; J++)

{ if (Vet1[J]< Vet1[I])

swap(&Vet1[J], &Vet1[I]);

} }

}

… una variante …

... il sottoprogramma per l’ordinamento con scambi successivi...

(28)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 55

Algoritmo

In un ciclo iterativo:

Si confrontano coppie di elementi consecutivi dello array e si scambiano di posizione se essi non sono nel giusto ordine (ossia, caso ordinamento crescente, se il secondo elemento è minore del primo).

Dopo la prima iterazione il valore massimo si troverà nella ultima posizione (quella sua definitiva); dopo la seconda iterazione il secondo massimo si troverà in penultima posizione e così via.

Ad ogni iterazione almeno un elemento va a collocarsi nella sua giusta posizione definitiva.

Il ciclo iterativo termina quando non sono più effettuati scambi.

… bubble sort…

9 5 8 2 4

5 9 8 2 4

5 8 9 2 4

5 8 2 9 4

5 8 2 4 9

5 8 2 4 9

5 8 2 4 9

5 2 8 4 9

5 2 4 8 9

5 2 4 8 9

2 5 4 8 9

2 4 5 8 9

2 4 5 8 9

2 4 5 8 9

bubble sort Scambio ? Si

Scambio ? Si

Scambio ? Si

Scambio ? NO

Iterazione 1 Iterazione 2

Iterazione 3 Iterazione 4

(29)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 57

void bubblesort(int vet1[ ], int riemp1) {int i, scambio = 1;

while (scambio == 1) { scambio = 0;

for(i=0; i < riemp1 - 1; i++) { if (vet1[i] > vet1[i+1])

{ swap(&vet1[i], &vet1[i+1]);

scambio = 1;

} }

riemp1--;

} }

… bubble sort…

... il sottoprogramma per l’ordinamento ...

Esempio

Definizione del problema: Trovare il valore minimo e quello massimo tra gli elementi di un array di interi, con cardinalità 50, ed indicarne la posizione (se vi sono più elementi con lo stesso valore minimo/massimo va indicata la posizione solo del primo elemento ‘minimo’/’massimo’). Lo array può essere

‘riempito’ parzialmente.

Definizione dei dati del problema:

I: il riempimento; il valore di ciascun elemento

Pi: il riempimento non può essere maggiore della cardinalità dell’array U: il valore minimo nello array; la posizione dell’elemento con valore minimo, il valore massimo nello array; la posizione dell’elemento con valore massimo

Pu: la posizione del minimo/massimo non maggiore del riempimento

(30)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 59

Esempio

Nome variabile Descrizione Tipo

riemp riempimento INT

VET(I) elemento dell’array INT

Nome variabile Descrizione Tipo

MIN Elemento con il valore minimo INT POSMIN Posizione dove è contenuto MIN INT MAX Elemento con il valore massimi INT POSMAX Posizione dove è contenuto MAX INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

I Indice array INT

Tabella delle variabili di algoritmo

Esempio

Descrizione del metodo di elaborazione:

... Usando sottoprogrammi ...

È chiamato il sottoprogramma leggivett(int Vet1[], int card1, int *riemp1), per riempire parzialmente lo array.

È chiamato il sottoprogramma stampavet(int Vet1[ ],int riemp1) , per visualizzare i valori immessi nello array

È chiamato il sottoprogramma

trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN, int *PS_MAX, int *PS_MIN, int riemp1);

per trovare i valori minimo e massimo contenuti nello array.

Nel sottoprogramma trovaMax_Min si pone il minimo pari al primo elemento dell’array e la sua posizione pari all’indice zero. Analogamente si pone il massimo pari al primo elemento dell’array e la sua posizione pari all’indice zero.

Usando un ciclo, si ‘visita’ lo array verificando:

se ciascun elemento dell’array è inferiore al minimo fissato, in tal caso si aggiorna il valore del minimo e della posizione in cui esso si trova nell’array

se ciascun elemento dell’array è superior al massimo fissato, in tal caso si aggiorna il valore del massimo e della posizione in cui esso si trova nell’array

Nel main si stampano i valori del minimo e del massimo e le posizioni in cui essi si trovano associati ai paramentri scambiati per riferimento ritornati dal sottoprogramma

(31)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 61

#include<stdio.h>

void leggivett(int Vet1[], int card1, int *riemp1);

void trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN,

int *PS_MAX, int *PS_MIN, int riemp1);

void stampavet(int Vet1[ ],int riemp1);

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp, MIN, POSMIN, MAX, POSMAX;

leggivett (VET, cardinalita, &riemp);

stampavet (VET, riemp);

trovaMax_Min (VET, &MAX, &MIN, &POSMAX, &POSMIN, riemp);

printf("il valore minimo = %d si trova nella posizione di indice %d\n" , MIN, POSMIN);

printf("il valore massimo = %d si trova nella posizione di indice %d\n" , MAX, POSMAX);

system("Pause");

}

Esempio - il programma C Con sottoprogrammi

void leggivett(int Vet1[], int card1, int *riemp1) {int I;

do

{ printf("immetti riemp\n");

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{ printf("immetti Vet[ %d ]= \n",I) ; scanf("%d", &Vet1[I]);

} }

Esempio - il programma C con sottoprogrammi

void stampavet(int Vet1[ ],int riemp1)

{ int I; ; for (I=0;I<riemp1; I++)

printf("Vet1[ %d ]= %d \n", I, Vet1[I] );

}

(32)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 63

void trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN,

int *PS_MAX, int *PS_MIN, int riemp1) {int I;

*F_MIN = Vet1[0]; *PS_MIN=0;

*F_MAX = Vet1[0]; *PS_MAX=0;

for (I= 1; I< riemp1; I++) { if (Vet1[I]<*F_MIN)

{ *F_MIN=Vet1[I];

*PS_MIN=I;

} else

if (Vet1[I]>*F_MAX) { *F_MAX=Vet1[I];

*PS_MAX=I;

} }

}

Esempio - il programma C Con sottoprogrammi

Definizione del problema: Si vuole verificare se in un array i cui valori sono ordinati in senso crescente esiste un elemento con un dato valore e se esso esiste si vuole conoscere la sua posizione. Si vuole usare un algoritmo di ricerca binaria.

Ricerca di un elemento in un array ordinato

Definizione dei dati:

I: lo array monodimensionale ordinato; il valore dell’elemento che si vuole cercare

Pi: lo array è ordinato in senso crescente

U: la posizione dell’elemento con valore pari a quello cercato se esso esiste nello array

Pu: il contenuto dello array resta immutato

(33)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 65

Descrizione del metodo di elaborazione:

Viene letto il valore da cercare;

viene considerato l’elemento dello array (ordinato in senso crescente) in posizione centrale (rispetto al riempimento);

se il valore da cercare è uguale a quello centrale la ricerca è terminata altrimenti:

• se il valore da cercare è minore di quello centrale viene applicato lo stesso algoritmo alla prima parte dello array (quella tra il primo elemento e quello in posizione centrale), se questa ha almeno un elemento, altrimenti

• se il valore da cercare è maggiore di quello centrale viene applicato lo stesso algoritmo alla seconda parte dello array (quella tra l’elemento in posizione centrale e l’ultimo), se questa ha almeno un elemento

Si continua fin quando un elemento centrale è pari a quello cercato o nessuna parte contiene più elementi

Ricerca di un elemento in un array ordinato

Ricerca binaria

93

Posizione elemento centrale:

P=(Sup+Inf)/2=5

3 10 28 31 33 40 57 93 98

Riemp = 9 Card = 12

Inf = 1 Sup = 9

3 10 28 31 33 40 57 93 98

Inf = 6 Sup = 9

Posizione elemento centrale:

P=(Sup+Inf)/2=8

93

3 10 28 31 33 40 57 93 98

Inf = 8 Sup = 9

93

Posizione elemento centrale:

P=(Sup+Inf)/2=7

=?

=?

=?

Deve sempre essere Inf <= Sup

Se Inf >=Sup l’elemento non esiste nello array

(34)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 67

#include<stdio.h>

#include <..… /leggivet.h>

#include <….. /stampavet.h>

#include <….. /ordinavet.h>

main ()

{ const card=50;

int Vet[card], I, riemp, elem, trovato, centro, inf, sup;

leggivet(Vet, card, &riemp);

stampavet (Vet, riemp);

ordinavet(Vet, riemp);

// immissione valore da ricercare printf("immetti valore da cercare \n”);

scanf(“%d”, &elem);

trovato=0;

inf=0; sup=riemp - 1;

Ricerca di un elemento in un array ordinato

Il programma C strutturato in sottoprogrammi

// ricerca binaria

while ((inf <= sup) && (trovato = = 0)) {

centro = (inf + sup) / 2; // posizione centrale if (Vet[centro] == elem)

trovato = 1; // permette di uscire dal ciclo else if(Vet[centro] > elem)

sup = centro -1; // la ricerca continua nella prima metà else inf = centro+1; // la ricerca continua nella seconda metà }

if(trovato)

printf(“elemento trovato in posizione: %d \n”, centro);

else printf(“elemento non trovato \n”);

}

(35)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 69

#include <stdio.h>

void leggivet(int Vet1[],int card1, int *riemp1) { int I;

do

{printf("immetti riemp\n");

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{printf("immetti Vet[ %d ]= \n",I) ; scanf("%d", &Vet1[I]);

} }

#include <stdio.h>

void stampavet(int Vet1[ ],int card1) { int I;

for (I=0;I<card1; I++)

printf("Vet1[ %d ]= %d \n”, I, Vet1[I] );

}

void ordinavet(int Vet1[ ], int riemp1) {//uno dei sottoprogrammi di ordinamento visti ...

}

Definizione del problema:

Scrivere, producendo la necessaria documentazione, un programma in linguaggio C che, data una stringa di 130 caratteri:

• consente di riempire la stringa leggendone il valore da tastiera;

• Elimina nell’array tutti i caratteri che sono cifre compattando, ad ogni eliminazione, la stringa (lo array che la contiene) e alla fine stampa la stringa risultante.

Esempio

(36)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 71

Cancellazione di un elemento in un array e compattazione

a S P 3 k B 8 E V \0

riemp = 9

for (j= pos; j<riemp-1; j++) VET[j]=VET[j+1];

riemp--;

a S P k B 8 E V \0

riemp = 8

a S P k B E V \0

riemp = 7 pos = 4

pos = 6

Esempio

Definizione dei dati del problema:

I: La stringa in cui eliminare caratteri cifra Pi: la stringa contiene al Massimo 130 caratteri U: la stringa senza caratteri cifra

Pu: la stringa non contiene caratteri cifra

(37)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 73

Esempio

Nome variabile Descrizione Tipo

VET stringa, array monomensionale di char CHAR

Nome variabile Descrizione Tipo

VET stringa senza caratteri cifra CHAR Tabella delle variabili di ingresso

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

i , j indice INT

riemp riempimento dello array VET INT

Tabella delle variabili di algoritmo

Descrizione del metodo di elaborazione:

Si immette la stringa, leggendo da tastiera ciascun carattere che la compone Si aggiunge il carattere di fine stringa ‘\0’

Con un ciclo iterativo si visita lo array VET contenente la stringa fino al carattere di fine stringa ‘\0’

Ad ogni passo del ciclo, si verifica se il carattere in quella posizione è una cifra ed in tal caso si traslano tutti gli elementi successivi a questa di una posizione verso la testa dello array:

sia i la posizione in cui è stata trovata una cifra, con un ciclo che inizia dalla posizione i e termina nell’ultima posizione utilizzata (il

riempimento) dello array:

for (j=i; j<riemp-1; j++) VET[j]=VET[j+1];

Si riduce di 1 il riempimento: riemp--;

Alla fine del ciclo si stampa lo array compattato che non contiene alcun carattere cifra.

(38)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 75

Esempio

#include<stdio.h>

/*Legge una linea in input */

void LeggiLinea(char ln[], int max, int *riemp) {int i = 0; char c;

while( ((c=getchar())!='\n') && (i < max)) { ln[i] = c;

i++;

}

ln[i] = '\0';

*riemp=i;

}

main ( )

{int const card = 131;

char VET[card], c;

int i, j, riemp;

printf("Immetti una stringa \n");

LeggiLinea(VET, card, &riemp);

i=0;

printf("Lunghezza della stringa: %d\n\n", riemp);

printf("\nStringa Immessa:\n");

while (VET[i]!='\0') { printf("%c", VET[i]);

i++;

}

printf("\n\n");

(39)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 77

// Si cercano le cifre in VET e le si cancellano // compattando lo array

i=0;

while (VET[i]!='\0')

{if ((VET[i]>='0') && (VET[i]<= '9')) { for (j=i; j<riemp-1; j++)

VET[j]=VET[j+1];

riemp--;

// Aggiorna posizione fine stringa VET[riemp]='\0';

} else i++;

}

//Stampa stringa compattata senza le cifre

printf("\n Stringa compattata senza le cifre: \n");

if(riemp>0) {i=0;

while(VET[i]!= '\0')

{printf ("%c",VET[i]);

i++;}

}

else printf("stringa vuota\n");

system("Pause");

}

(40)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 79

…… modo alternativo per la stampa …

//Stampa stringa compattata senza le cifre

printf("\n Stringa compattata senza le cifre: \n");

if(riemp>0) puts(VET);

else

printf("stringa vuota\n");

system("Pause");

}

… altra soluzione per compattare, usando un ciclo iterativo … e per la stampa … //Ricerca le cifre in VET le cancella e compatta lo array i=0;

while (VET[i]!='\0')

{if ((VET[i]>='0') && (VET[i]<= '9')) { j=i;

while (VET[j]!='\0') { VET[j]=VET[j+1];

j++;

}

riemp--;

} else i++;

}

printf("\n Stringa compattata senza le cifre: \n");

if(VET[0]!='\0') puts(VET);

else printf("stringa vuota\n");

system("Pause");

}

(41)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 81

Definizione del problema: Si vogliono aggiungere uno o più elementi in un array monodimensionale di interi già parzialmente riempito mantenendo l’ordinamento esistente (crescente) dello array (senza doverlo riordinare) e visualizzare lo array risultante.

Aggiunta di elementi in un array ordinato

Definizione dei dati:

I: lo array monodimensionale parzialmente riempito ed ordinato (crescente); il valore degli elementi che si vogliono aggiungere allo array

Pi: il numero degli elementi da aggiungere non deve superare la cardinalità; l’array è ordinato in senso crescente

U: lo array monodimensionale con gli elementi aggiunti Pu: lo array risultante deve essere ordinato (crescente)

14

Riemp = 9 Card = 12 3 10 14 28 31 33 40 57 93

14 52

3 10 14 28 31 33 40 52 57 93

Riemp = 10 Card = 12 52

Aggiunta di elementi in un array ordinato

Card = 12 3 10 28 31 33 40 57 93

Riemp = 8

VET

(42)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 83

Aggiunta di elementi in un array ordinato

3 10 28 31 33 40 57 93

• bisogna ‘creare lo spazio’ per inserire il nuovo valore …

• Pos, posizione dell’array con il primo elemento con valore maggiore di quello da aggiungere

• si verifica che la quantità degli elementi da aggiungere non superi la cardinalità

• si trasla (si ‘copia’) l’ultimo elemento nella prima successiva posizione libera ...

14

… si continuano a traslare gli altri elementi fino a giungere all’elemento in Pos

Card = 12 3 10 28 31 33 40 57 93

Riemp = 8

3 10 28 31 33 40 57 93 93

Riemp = 9

… in C ...

Riemp++;

I=Riemp - 1;

VET[I]=VET[I-1];

Pos

Aggiunta di elementi in un array ordinato 3 10 28 31 33 40 57 93 93

Riemp = 9

3 10 28 31 33 40 57 57 93

3 10 28 31 31 33 40 57 93

3 10 28 28 31 33 40 57 93

Riemp = 9

…...

Riemp++;

for (I=(Riemp-1);I>Pos;I--) VET[I]=VET[I-1];

(43)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 85

Aggiunta di elementi in un array ordinato 3 10 28 28 31 33 40 57 93

Riemp = 9

14

VET[Pos]= el_da_inserire;

3 10 14 28 31 33 40 57 93

Riemp = 9

Un errore tipico consiste nell’eseguire il ciclo a conteggio scandendo le posizioni in senso crescente

Il risultato è il ricopiamento a destra dell’elemento che si trova in posizione inferiore:

for (i=pos; i<riemp;i++) vet[i+1]=vet[i]; // ERRORE !!!

Errore tipico

3 10 28 28 33 40 57 93 3 10 28 31 33 40 57 93

pos

3 10 28 28 28 40 57 93

(44)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 87

Tabella delle variabili di ingresso

Nome variabile Descrizione Tipo

Tabella delle variabili di uscita

Nome variabile Descrizione Tipo

riemp riempimento INT

.... ... ... ... ...

Nome variabile Descrizione Tipo

Tabella delle variabili di algoritmo

Aggiunta di elementi in un array ordinato

... LO STUDENTE COMPLETI LE TABELLE ....

Descrizione del metodo di elaborazione:

• Allo array T[n], di cardinalità n già ordinatamente riempito con Riemp elementi, si vogliono aggiungere i valori di K elementi;

• si verifica che sia Riemp + K <= n ; se la condizione è verificata:

• con un ciclo ripetitivo si immettono i nuovi K valori

• al fine di mantenere l’ordinamento crescente esistente nello array, i K valori vanno aggiunti ciascuno nella giusta posizione in modo che sia verificato:

T[I-1] < Valore_da_Inserire < T[I]

• Si legge il nuovo valore da aggiungere

• Per trovare la posizione Pos in cui inserire il nuovo valore si usa un ciclo iterativo in cui, partendo dalla prima posizione dello array, si verifica se

Valore_da_Inserire > T[I]

e si termina il ciclo quando questa condizione è falsa (o quando sono stati esaminati tutti i Riemp elementi dello array): il valore di I per cui la condizione è falsa è la posizione Pos dove andrà inserito il nuovo valore

• Bisogna traslare di una posizione tutti gli elementi T[J] per J = Riemp .. I usando un ciclo ripetitivo, dopo aver incrementato di 1 Riemp:

Riemp++; for (I=(Riemp-1);I>Pos;I--) VET[I]=VET[I-1];

• Si visualizza lo array risultante.

Aggiunta di elementi in un array ordinato

(45)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 89

Aggiunta di elementi in un array ordinato

#include<stdio.h>

void leggivet(int Vet1[],int card1, int *riemp1);

void stampavet(int Vet1[ ],int card1);

void ordinavet (int Vet1[], int riemp);

main()

{ const int cardinalita=50;

int i, j, conta1, riemp, k, pos, el_da_inserire , VET[cardinalita] ; leggivet(Vet, cardinalita, &riemp); stampavet(Vet, riemp);

ordinavet (Vet, riemp); stampavet(Vet, riemp);

// richiesta di quanti altri valori si vogliono inserire if(cardinalita>riemp)

{do

{ printf("Lo array ha cardinalità %d\n”, cardinalita);

printf("Lo array contiene %d elementi \n”, riemp);

printf(“Quanti elementi vuoi aggiungere? (Max %d )\n”, (cardinalita - riemp));

scanf(“%d”, &conta1);

} while (conta1>(cardinalita - riemp));

il programma C strutturato con sottoprogrammi

for (i=1; i<=conta1; i++) // immissione nuovi valori { printf("immetti un valore da aggiungere \n”);

scanf(“%d”, &el_da_inserire);

// trova posizione dove inserire k=0;

while ((el_da_inserire>vet[k]) && (k<riemp)) k++;

pos=k;

riemp++;

(46)

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 91

// sposta elementi di una posizione if (pos<riemp-1)

for (j=(riemp-1);j>pos;j--) vet[j]=vet[j-1];

// inserisce nuovo elemento VET[pos]= el_da_inserire;

} // fine for immissione nuovi valori }// fine ramo vero if (cardinalita>riemp)

else printf(“array pieno!! Impossibile aggiungere valori!!\n);

stampavet(Vet, riemp);

System(“Pause”);

}

void leggivet(int Vet1[],int card1, int *riemp1) { int I;

do

{printf("immetti riemp\n");

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{printf("immetti Vet[ %d ]= \n",I) ; scanf("%d", &Vet1[I]);

} }

void stampavet(int Vet1[ ],int card1) { int I;

for (I=0;I<card1; I++)

printf("Vet1[ %d ]= %d \n”, I, Vet1[I] );

}

void ordinavet(int Vet1[ ],...) LO STUDENTE DEFINISCA IL

SOTTOPROGRAMMA PER ORDINARE IN MODO CRESCENTE UN ARRAY MONODIMENSIONALE

Riferimenti

Documenti correlati

– Soluzione: si passa alla funzione un ulteriore parametro di tipo array, che viene “riempito” con il risultato.. E i parametri di

● Se gli estremi degli scaglioni e/o le percentuali cambiano, devo cambiare solo l'array e non il programma che fa la ricerca!.. Algoritmi su

dove numero_elementi deve essere o un valore intero, o un’espressione costante oppure una variabile che sia stata però istanziata prima della definizione dell'array; ad esempio,

I: il valore di ciascun elemento dello array di numeri interi Pi: il numero degli elementi da inserire non può essere maggiore della cardinalità dell’array.. U: lo array

I: riempimento; il valore di ciascun elemento dello array Pi: il numero degli elementi da inserire (riempimento) non può essere maggiore della cardinalità dell’array.. U:

I: il valore di ciascun elemento dello array di numeri interi Pi: il numero degli elementi da inserire non può essere maggiore della cardinalità dell’array.. U: lo array

¨  L’espressione a[i] restituisce il valore della variabile con indice i, quindi il tipo di questa espressione è il tipo base dell'array. Accesso agli elementi di

codice strumento prezzo FLT flauto 2500 VLN violino 8000. $inv_art