[C] - Ricerca Lineare Ricorsivo

di il
10 risposte

[C] - Ricerca Lineare Ricorsivo

Salve, vorrei un parere sul seguente esercizio:

ES: (Ricerca lineare) scrivete una funzione ricorsiva linearSearch che esegua una ricerca lineare all'interno di un vettore. La funzione dovrà ricevere come argomenti un vettore di interi e la sua dimensione. Nel caso che la chiave di ricerca sia stata trovata, restituirete l'indice del vettore, altrimenti restituirete —1.

Lo devo svolgere e sto cercando di capire come passare la chiave di ricerca non potendo inserirla (da traccia) tra gli argomenti della funzione linearSearch.

La mia idea è quella di inserire la chiave nell'ultima posizione del vettore e poi effettuare la ricerca sui suoi elementi fino al penultimo. Sinceramente non so se possa andare bene, avete qualche altra idea?

Ps: senza il vincolo sugli argomenti della funzione passerei anche la chiave.

10 Risposte

  • Re: [C] - Ricerca Lineare Ricorsivo

    #define KEY 6
    
    int ricerca_lineare(int v[], int dim)
    {
        ... (... == KEY) ...
    }
  • Re: [C] - Ricerca Lineare Ricorsivo

    Una sol vale l'altra
  • Re: [C] - Ricerca Lineare Ricorsivo

    Dato che non puoi passare la chiave

    E che metterla come variabile globale sarebbe sparare sulla crocerossa...


    Tu, prima, togli da ogni elemento del vettore la chiave cercata , essendo int non hai problemi di segno

    E, poi, cerchi, con una funzione ricorsiva, il numero 0

    Che è una costante, risultato della sottrazione tra elemento corretto e chiave cercata
  • Re: [C] - Ricerca Lineare Ricorsivo

    StandardOil ha scritto:


    Dato che non puoi passare la chiave

    E che metterla come variabile globale sarebbe sparare sulla crocerossa...


    Tu, prima, togli da ogni elemento del vettore la chiave cercata , essendo int non hai problemi di segno

    E, poi, cerchi, con una funzione ricorsiva, il numero 0

    Che è una costante, risultato della sottrazione tra elemento corretto e chiave cercata
    Non è thread-safe
    Scherzo, può essere una soluzione
  • Re: [C] - Ricerca Lineare Ricorsivo

    Ho usato i vostri consigli, ecco 3 codici di cui vorrei un parere:

    1) usando una variabile globale come suggeriva @nippolo:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define DIM 10
    #define KEY 7
    
    int ricerca_lineare(const int vett[], int size);
    
    int main()
    {
        int vettore[DIM], i, key, elemento;
    
        srand(time(NULL));
        printf("\nVETTORE CASUALE : ");
    
        for(i = 0; i < DIM; i++)
            printf("%d ", vettore[i] = 1 + rand() % 10);
    
        elemento = ricerca_lineare(vettore, DIM -1);
    
        if(elemento < 0)
        	printf("\n%d elemento non trovato\n\n", elemento);
        else
        	printf("\nPOSIZIONE : %d\n\n", elemento);
        
    	return 0;
    }
    
    int ricerca_lineare(const int vett[], int size)
    {
       if(vett[size] == KEY)
       	  return size;
       if(size == 0)
              return -1;
       return ricerca_lineare(vett, size - 1);
    }
    2) sostituendo 0 alla chiave e cercando 0 (come costante) nella funzione ricorsiva come suggeriva @StandardOil:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define DIM 10
    
    int ricerca_lineare(const int vett[], int size);
    
    int main()
    {
        int vettore[DIM], i, key, elemento;
    
        srand(time(NULL));
        printf("\nVETTORE CASUALE : ");
    
        for(i = 0; i < DIM; i++)
            printf("%d ", vettore[i] = 1 + rand() % 50);
    
        printf("\n\ninserisci l'elemento da cercare : ");
        scanf("%d", &key);
    
        for(i = 0; i < DIM; i++)
           if(vettore[i] == key)
              vettore[i] = 0;
        
        elemento = ricerca_lineare(vettore, DIM -1);
    
        if(elemento < 0)
        	printf("\n%d elemento non trovato\n\n", elemento);
        else
        	printf("\nPOSIZIONE : %d\n\n", elemento);
        
    	return 0;
    }
    
    int ricerca_lineare(const int vett[], int size)
    {
       if(vett[size] == 0)
       	  return size;
       return ricerca_lineare(vett, size - 1);
    }
    3) con la mia idea di partenza :
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define DIM 10
    
    int ricerca_lineare(const int vett[], int size);
    
    int main()
    {
    	int vettore[DIM], i, elemento;
    
        srand(time(NULL));
        printf("\ngenero vettore casuale : ");
    
        for(i = 0; i < DIM - 1; i++)
            printf("%d ", vettore[i] = 1 + rand() % 50);
    
        printf("\n\ninserisci l'elemento da cercare : ");
        scanf("%d", &vettore[i]);
    
        elemento = ricerca_lineare(vettore, i - 1);  // dimensine del vettore senza la chiave 
    
        if(elemento >= 0)
          printf("\nposizione : %d\n\n", elemento);
        else
          printf("\n%d elemento non trovato\n\n", elemento);
    
    	return 0;
    }
    
    int ricerca_lineare(const int vett[], int size)
    {
       if(vett[size] == vett[DIM - 1])
          return size;
       if(size == 0)
          return -1;
       return ricerca_lineare(vett, size - 1);
    }
    Quello che mi interessa sapere è se possono andare come possibili soluzioni (nel senso che rispettano la traccia e il concetto di ricorsione)

    Grazie
  • Re: [C] - Ricerca Lineare Ricorsivo

    Ho dato un'occhiata alla prima versione e va bene.
    In base al discorso fatto nell'altro topic secondo te si tratta di una ricorsione in coda o di una ricorsione non in coda?

    P.S.
    Va specificato che nel caso in cui la funzione ricorsiva torni un valore non negativo, si tratta dell'indice della prima occorrenza trovata partendo dalla fine dell'array.
  • Re: [C] - Ricerca Lineare Ricorsivo

    Nippolo ha scritto:


    Ho dato un'occhiata alla prima versione e va bene.
    In base al discorso fatto nell'altro topic secondo te si tratta di una ricorsione in coda o di una ricorsione non in coda?

    P.S.
    Va specificato che nel caso in cui la funzione ricorsiva torni un valore non negativo, si tratta dell'indice della prima occorrenza trovata partendo dalla fine dell'array.
    int ricerca_lineare(const int vett[], int size)
    {
       if(vett[size] == KEY)
       	  return size;
       if(size == 0)
              return -1;
       return ricerca_lineare(vett, size - 1);
    }
    Secondo me è una ricorsione in coda in quanto la chiamata ricorsiva viene effettuata come ultima istruzione della funzione e a differenza della ricorsione "tradizionale" in quella in coda (come in questo caso) il risultato viene ottenuto all'ultima chiamata senza dover "restituire" i valori delle chiamate a ritroso. Giusto?
  • Re: [C] - Ricerca Lineare Ricorsivo

    Esatto!
  • Re: [C] - Ricerca Lineare Ricorsivo

    g@lil3o ha scritto:


    2) sostituendo 0 alla chiave e cercando 0 (come costante) nella funzione ricorsiva...
    Non avevo detto "sostituendo", ma sottraendo....

    Come hai fatto tu hai stravolto il concetto
    Facendo una ricerca iterativa per poi farne una ricorsiva...
  • Re: [C] - Ricerca Lineare Ricorsivo

    StandardOil ha scritto:


    g@lil3o ha scritto:


    2) sostituendo 0 alla chiave e cercando 0 (come costante) nella funzione ricorsiva...
    Non avevo detto "sostituendo", ma sottraendo....

    Come hai fatto tu hai stravolto il concetto
    Facendo una ricerca iterativa per poi farne una ricorsiva...
    si hai ragione, ho modificato il codice utilizzando il tuo suggerimento:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define DIM 10
    
    int ricerca_lineare(const int vett[], int size);
    
    int main()
    {
    	int vettore[DIM], i, key, elemento;
    
        srand(time(NULL));
        printf("\nVETTORE CASUALE : ");
    
        for(i = 0; i < DIM; i++)
            printf("%d ", vettore[i] = 1 + rand() % 50);
    
        printf("\n\ninserisci l'elemento da cercare : ");
        scanf("%d", &key);
    
        for(i = 0; i < DIM; i++)
           vettore[i] = vettore[i] - key;
        
        elemento = ricerca_lineare(vettore, DIM -1);
    
        if(elemento < 0)
        	printf("\n%d elemento non trovato\n\n", elemento);
        else
        	printf("\nPOSIZIONE : %d\n\n", elemento);
        
    	return 0;
    }
    
    int ricerca_lineare(const int vett[], int size)
    {
       if(vett[size] == 0)
       	  return size;
       return ricerca_lineare(vett, size - 1);
    }
    dove con questo ciclo for sottraggo la chiave ad ogni elemento del vettore e poi con la funzione ricorsiva cerco 0 :
    for(i = 0; i < DIM; i++)
           vettore[i] = vettore[i] - key;
Devi accedere o registrarti per scrivere nel forum
10 risposte