Problema programma col linguaggio C

Messaggioda Eugvr93 » 27/08/2014, 16:04

Questo è il codice evidentemente sbagliato, ma non riesco a capire dov'è che sbaglio!!
In sintesi l'utente digiterà prima la dimensione dell'array, poi digita i numeri e infine il numero che deve essere cercato (key). Ho dovuto svolgere questo esercizio con la ricorsione, ma il programma si blocca e non capisco il perchè!
PS: uso il "dev C++ " per programmare col linguaggio C.



#include <stdio.h>
#include <stdlib.h>

//protos

int linear_search(const int a[], int key, int low, int high);
void implemention_sort(int a[], int size);

//il programma inizia col main
int main(int argc, char *argv[]){

int size, count, key;

printf("quanti numeri devi inserire? : \t");
scanf("%d\n", &size);

int array[size];

printf("inserisci i numeri:\n");
for (count = 0; count < size; count++){
scanf("%d\n\n", &array[count]);//non gli sto mettendo il & e mi ha detto che ho sbagliato
}//fine for

implemention_sort(array, size);

printf("ecco l'array ordinato: \n");

for(count = 0; count < size; count++){
printf("\n %d \n", array[count]);
}//fine for

printf("inserisci il numero da cercare: \t");
scanf("%d\n", &key);

printf("\n\n[%d]", linear_search(array, key, 0, size - 1));

system("PAUSE");
}//fine main

//funzioni

int linear_search(const int array[], int key, int low, int high){

int middle = (low + high)/2;

if (key < array[middle]){

linear_search(array, key, 0, middle - 1);

}//fine if esterno

else if(key > array[middle]){

linear_search(array, key, middle + 1, high);

}//fine else if esterno

else if(key == array[middle]){
return middle;
}//fine secondo else if

else{
printf("-1 significa che non è stato trovato.");
return -1;
}//fine else

}//fine funzione


//alra funzione

void implemention_sort(int a[], int size){

int j; //contatore
int temp;

if (size == 0){

}//fine if

else{
for (j = 0; j < size; j++){
if (a[j + 1] < a[j]){
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}//fine for
}//fine for
implemention_sort(a, size - 1);
}//fine else
}//fine funzione


Grazie mille dell'aiuto :)
Eugvr93
Starting Member
Starting Member
 
Messaggio: 1 di 10
Iscritto il: 27/08/2014, 15:53

Re: Problema programma col linguaggio C

Messaggioda sapo93 » 27/08/2014, 18:43

ciao, ci sono un pochino di imperfezioni:

Codice:

   int size, count, key;

   printf("quanti numeri devi inserire? : \t");
   scanf("%d", &size); // Scanf corretto

   printf ("\nnumero inserito\n");

   int array[size];

   printf("inserisci i numeri:\n");

   for (count = 0; count < size; count++){

         scanf("%d\n\n", &array[count]);//non gli sto mettendo il & e mi ha detto che ho sbagliato

   }//fine for



nella scanf come primo argomento devi mettere solo il tipo di dato che si aspetta, senza altri caratteri. Per andare a capo devi mettere un printf("\n") separato

Codice:

implemention_sort(array, size);



l'algoritmo di sort dell'array è quello che incasina il tutto, infatti se per prova fai un print dell'array prima di fare il sort, avrai degli elementi diversi da quelli dopo il sort. Questo perchè durante il sort, l'algoritmo pesca degli elementi in locazioni di memoria esterne all'array. Questo avviene per il controllo a[j + 1] < a[j] in

Codice:

for (j = 0; j < size; j++) {

   if (a[j + 1] < a[j]){

      temp = a[j];

      a[j] = a[j + 1];

      a[j + 1] = temp;

   }//fine for

}//fine for



cosi facendo, quando arrivi all'ultimo j del ciclo, vai fuori dall'array a prendere un altro valore in memoria, inserendolo nell'array come ultimo valore al posto di quello già presente se più piccolo. Cosi facendo introduci nell'array un nuovo valore e ne togli uno di quelli inseriti dall'utente.

Per risolvere il problema devi riscrivere il ciclo for con j < size-1 , ovvero:

Codice:

for (j = 0; j < size-1; j++) {

   if (a[j + 1] < a[j]){

      temp = a[j];

      a[j] = a[j + 1];

      a[j + 1] = temp;

   }//fine for

}//fine for



cosi l'array viene ordinato correttamente.

Codice:
printf("inserisci il numero da cercare: \t");

   scanf("%d\n", &key);



altro scanf da correggere.

Ora funziona :)

p.s. aggiungi uno \n alla fine di

Codice:
printf("\n\n[%d]", linear_search(array, key, 0, size - 1));


trasformandolo in

Codice:
printf("\n\n[%d]\n", linear_search(array, key, 0, size - 1));


se no ti si attacca il risultato alla nuova dicitura del prompt dei comandi :)
Java and C++ Developer (Algorithmic Trading)
M.Sc student (applied) Math Unimib
B. Sc Computer Science Unimib
Football coach
Emergency Medical Technician (EMT)
Sorcerer's apprentice

Github: https://github.com/fsaporito
Linkedin: https://www.linkedin.com/in/fsaporito/
sapo93
Junior Member
Junior Member
 
Messaggio: 60 di 402
Iscritto il: 10/03/2013, 14:09

Re: Problema programma col linguaggio C

Messaggioda kobeilprofeta » 27/08/2014, 18:47

Scusa ma l'esercizio consiste solo nell'immissione di numeri in un array e nella ricerca di un valore tra di essi?
Se così:
Testo nascosto, fai click qui per vederlo
#include <stdio.h>
int i,a[100],c,q;
main()
{
printf("quanti numeri vuoi inserire? ");
scanf ("%d",& q);
for (i=0;i<q;i++)
{
printf ("\n");
scanf ("%d",& a[i]);
}
printf ("\nChe numero vuoi cercare?");
scanf ("%d",&c);
for (i=0;i<q;i++)
{
if (a[i]==c) {printf ("\nil valore occupa la posizione %d",i);

}
getch();
}


Se non ti risposto come volevi scusami.
kobeilprofeta
Cannot live without
Cannot live without
 
Messaggio: 714 di 5262
Iscritto il: 24/09/2012, 18:25

Re: Problema programma col linguaggio C

Messaggioda sapo93 » 27/08/2014, 19:05

in pratica i due programmi fanno la stessa cosa, ma mi pare di aver capito che venisse richiesta la ricorsione e l'uso dell'algoritmo di ricerca binario (ricorsivo).

[EDIT] La ricerca binaria è inoltre computazionalmente megllio di quella sequenziale, infatti:

La ricerca sequenziale (cicla tutto fino a che non trovi l'array), ha i seguenti comportamenti:

caso peggiore: $O(n)$ [elemento non presente]
caso medio $O(n/2)$ [elemento nell'array]
caso ottimo: $O(1)$ [elemento come prmo valore dell'array]


La ricerca binaria ha invece i seguenti comportamenti:

caso peggiore: $O(logn)$ [elemento non presente]
caso medio $O(logn)$ [elemento nell'array]
caso ottimo: $O(1)$ [elemento nel centro dell'array]
Ultima modifica di sapo93 il 27/08/2014, 19:16, modificato 3 volte in totale.
Java and C++ Developer (Algorithmic Trading)
M.Sc student (applied) Math Unimib
B. Sc Computer Science Unimib
Football coach
Emergency Medical Technician (EMT)
Sorcerer's apprentice

Github: https://github.com/fsaporito
Linkedin: https://www.linkedin.com/in/fsaporito/
sapo93
Junior Member
Junior Member
 
Messaggio: 61 di 402
Iscritto il: 10/03/2013, 14:09

Re: Problema programma col linguaggio C

Messaggioda kobeilprofeta » 27/08/2014, 19:12

Ok. Perchè se fosse stato solo così, quello sarebbe stato un metodo più veloce. Ciao.
kobeilprofeta
Cannot live without
Cannot live without
 
Messaggio: 716 di 5262
Iscritto il: 24/09/2012, 18:25

Re: Problema programma col linguaggio C

Messaggioda sapo93 » 27/08/2014, 19:47

più veloce da scrivere, ma meno veloce a livello computazionale :D
Java and C++ Developer (Algorithmic Trading)
M.Sc student (applied) Math Unimib
B. Sc Computer Science Unimib
Football coach
Emergency Medical Technician (EMT)
Sorcerer's apprentice

Github: https://github.com/fsaporito
Linkedin: https://www.linkedin.com/in/fsaporito/
sapo93
Junior Member
Junior Member
 
Messaggio: 63 di 402
Iscritto il: 10/03/2013, 14:09

Re: Problema programma col linguaggio C

Messaggioda kobeilprofeta » 27/08/2014, 19:54

Non lo so questo. Ma se lo dici tu mi fido ;)
kobeilprofeta
Cannot live without
Cannot live without
 
Messaggio: 717 di 5262
Iscritto il: 24/09/2012, 18:25

Re: Problema programma col linguaggio C

Messaggioda vict85 » 27/08/2014, 21:00

sapo93 ha scritto:in pratica i due programmi fanno la stessa cosa, ma mi pare di aver capito che venisse richiesta la ricorsione e l'uso dell'algoritmo di ricerca binario (ricorsivo).

[EDIT] La ricerca binaria è inoltre computazionalmente megllio di quella sequenziale, infatti:

La ricerca sequenziale (cicla tutto fino a che non trovi l'array), ha i seguenti comportamenti:

caso peggiore: $O(n)$ [elemento non presente]
caso medio $O(n/2)$ [elemento nell'array]
caso ottimo: $O(1)$ [elemento come prmo valore dell'array]


La ricerca binaria ha invece i seguenti comportamenti:

caso peggiore: $O(logn)$ [elemento non presente]
caso medio $O(logn)$ [elemento nell'array]
caso ottimo: $O(1)$ [elemento nel centro dell'array]


In realtà, nel secondo caso, devi fare l'ordinamento. Quindi devi aggiungere la complessità dell'ordinamento che rende il secondo algoritmo sempre peggio dell'algoritmo base. Inoltre, e questo purtroppo è poco puntualizzato nei corsi, la ricerca binaria produce tantissimi cache missing. Siccome i cache missing sovrastano i tempi delle altre operazioni, questo rende la ricerca binaria molto meno appetibile di quanto possa sembrare. Incomincia sempre dagli algoritmi più semplici.
vict85
Moderatore
Moderatore
 
Messaggio: 6744 di 19253
Iscritto il: 16/01/2008, 00:13
Località: Berlin

Re: Problema programma col linguaggio C

Messaggioda sapo93 » 27/08/2014, 21:39

In realtà invece che poco puntualizzato penso proprio che sia inesistente.
Non so in altri corsi, ma ad informatica in Bicocca tutti i corsi di algoritmi non si interessano dei problemi tecnici, resta tutto a livello teorico. E' prevista una parte applicativa, ma si riduce all'implementazione di quello imparato a lezione, senza ragionamenti sull'effettiva differenza tra prestazioni in teoria e prestazioni in pratica.
Ho sentito parlare di cache missing solo trattando di architettura degli elaboratori :)
Java and C++ Developer (Algorithmic Trading)
M.Sc student (applied) Math Unimib
B. Sc Computer Science Unimib
Football coach
Emergency Medical Technician (EMT)
Sorcerer's apprentice

Github: https://github.com/fsaporito
Linkedin: https://www.linkedin.com/in/fsaporito/
sapo93
Junior Member
Junior Member
 
Messaggio: 64 di 402
Iscritto il: 10/03/2013, 14:09

Re: Problema programma col linguaggio C

Messaggioda vict85 » 27/08/2014, 22:22

Non saprei comunque in che condizioni convenga usare l'uno rispetto all'altro. In questo caso era il passo di ordinamento a rendere la ricerca binaria poco appetibile. D'altra parte se devi fare molte ricerche allora il peso del sort si riduce.

P.S.: Ho notato che nel tuo progetto numC hai definito le matrici come puntatori di puntatori a double. Spesso, in realtà, si preferisce usare un puntatore a double semplice e accedere all'elemento m[i][j] come m[i * row_size + j] oppure m[j * col_size + i]. Tra l'altro il primo è il modo in cui sono memorizzate in memoria gli array multidimensionali in C (il secondo è quello del Fortran). La gestione della memoria è più semplice ed è più facile scrivere buoni codici.
vict85
Moderatore
Moderatore
 
Messaggio: 6745 di 19253
Iscritto il: 16/01/2008, 00:13
Località: Berlin

Prossimo

Torna a Informatica

Chi c’è in linea

Visitano il forum: Nessuno e 1 ospite