b'\n_START_ARTICLE_\nRicerca sequenziale\n_START_SECTION_\nLinguaggio C\n_START_PARAGRAPH_\nEcco un\'implementazione in C di detto algoritmo. Il parametro insieme \xc3\xa8 un array in cui cercare, x \xc3\xa8 l\'elemento da cercare e infine n \xc3\xa8 il numero di elementi contenuti nell\'array._NEWLINE_ int ricercaSequenziale(int insieme[], int x, int n) {_NEWLINE_     int i;_NEWLINE_     for (i = 0; i < n; ++i) {_NEWLINE_       // Interrompe la ricerca con successo alla prima corrispondenza trovata_NEWLINE_       if (insieme[i] == x) return i;_NEWLINE_     }_NEWLINE_     // L\'intera sequenza \xc3\xa8 stata esaurita senza trovare corrispondenze_NEWLINE_     return -1;_NEWLINE_ }\n_START_SECTION_\nJava\n_START_PARAGRAPH_\nEcco l\'algoritmo della ricerca sequenziale per elementi interi implementato in linguaggio Java:_NEWLINE_/*  *  Ricerca sequenziale, scandisce tutto l\'array di interi per trovare la "chiave"(key) cercata * *  @param array l\'array di elementi interi *  @param key l\'elemento intero da cercare *  @return la posizione dell\'elemento cercato*/_NEWLINE_ public int ricercaSequenziale(int [] array , int key) {_NEWLINE_     for (int i=0; i<array.length; i++)_NEWLINE_          if (array[i]==key)_NEWLINE_              return i;_NEWLINE_     return -1; //restituisce -1 se non trova l\'elemento da cercare_NEWLINE_ }\n_START_SECTION_\nPython\n_START_PARAGRAPH_\nEcco una variante in linguaggio Python. Funziona con qualunque tipo di iterabile, incluse liste e stringhe._NEWLINE_def RicercaSequenziale(lista,chiave):_NEWLINE_    for i in range(len(lista)):_NEWLINE_        if lista[i] == chiave:_NEWLINE_            return i_NEWLINE_    return False\n_START_SECTION_\nVariante con sentinella\n_START_PARAGRAPH_\nL\'algoritmo classico richiede che, dopo ciascun elemento non corrispondente, si verifichi se ci si trova al termine della sequenza per decidere se terminare (con esito negativo) o proseguire con l\'elemento successivo. Tale verifica pu\xc3\xb2 essere evitata se l\'algoritmo ha la possibilit\xc3\xa0 di modificare l\'insieme su cui avviene la ricerca: aggiungendo un ulteriore elemento, pari a quello cercato, al termine della sequenza, l\'algoritmo ha la certezza di trovare almeno una corrispondenza. La ricerca avr\xc3\xa0, nel suo complesso, esito positivo se la corrispondenza \xc3\xa8 stata trovata in una posizione precedente all\'ultima._NEWLINE_Questa variante, pur introducendo una semplificazione del passo iterativo, non altera l\'ordine di complessit\xc3\xa0 dell\'algoritmo nel suo complesso, che rimane lineare.\n_START_SECTION_\nImplementazione in linguaggio C\n_START_PARAGRAPH_\nEccone un\'implementazione in linguaggio C:_NEWLINE_ // Si assume che "lista" abbia capacit\xc3\xa0 di almeno n+1 elementi, ovvero_NEWLINE_ // che lista[n] sia una valida locazione di memoria._NEWLINE_ int ricercaSequenzialeConSentinella(int lista[], int x, int n) {_NEWLINE_     // Aggiunta della sentinella_NEWLINE_     lista[n]=x;_NEWLINE__NEWLINE_     // Scansione sino alla prima corrispondenza_NEWLINE_     int i = 0;_NEWLINE_     while (lista[i] != x) i++;_NEWLINE__NEWLINE_     // Identificazione dell\'esito_NEWLINE_     return (i < n) ? i : -1;_NEWLINE_ }'