logo

TechCodeview

C-programma om een ​​element in een array te zoeken

In dit artikel bespreken we het C-programma om naar een element in een array te zoeken met hun verschillende manieren en voorbeelden.

Wat is een array?

A data structuur genaamd een reeks bevat een reeks items met een vaste lengte van hetzelfde type. Het wordt vaak gebruikt om gegevensverzamelingen op te slaan en te manipuleren, omdat indexering efficiënte toegang mogelijk maakt.

Bijvoorbeeld: intnumbers[] = {10, 20, 30, 40, 50};

veer modules

Een element in een array zoeken

Een typische bewerking bij computerprogrammering is het zoeken naar een bepaald element in een array. De efficiëntie van uw code kan aanzienlijk worden verbeterd door efficiënte zoekalgoritmen te gebruiken, ongeacht of u zoekt naar het bestaan ​​van een bepaalde waarde door de index van een element te lokaliseren, of te verifiëren of een element bestaat. De vele methoden voor het zoeken naar elementen in een array met behulp van de programmeertaal C worden in dit artikel besproken.

Er zijn hoofdzakelijk twee manieren om een ​​element in een array te doorzoeken:

1. Lineair zoeken

Een eenvoudige zoekstrategie die wordt gebruikt om een ​​bepaald element in een array of lijst te lokaliseren, wordt genoemd lineair zoeken , ook wel genoemd sequentieel zoeken . Het werkt door elk arraylid te vergelijken met de doelwaarde om a te vinden overeenkomst of traverse de volledige array iteratief.

De fundamentele stappen bij lineair zoeken zijn als volgt:

    Begin met de bovenste elementen van de array.
  1. De doelwaarde moet worden vergeleken met het huidige element.
  2. De zoekopdracht is succesvol als het huidige element overeenkomt met de gevraagde waarde, waarna het algoritme de index van het element of een andere gewenste uitvoer kan retourneren.
  3. Ga naar het volgende element in de array als het huidige element niet overeenkomt met de gewenste waarde.
  4. Herhaal stap 2-4 totdat er een match is gemaakt of het einde van de array is bereikt.

Programma: 

 #include int linearSearch(int arr[], int n, int target) { for (int i = 0; i<n; i++) { if (arr[i]="=" target) return i; the index target is found } -1; -1 not int main() arr[]="{5," 2, 8, 12, 3}; n="sizeof(arr)" sizeof(arr[0]); calculate number of elements in array result="linearSearch(arr," n, target); (result="=" -1) printf('element found
'); else at %d
', result); 0; < pre> <p> <strong>Output:</strong> </p> <pre> An element found at index 2 </pre> <h3>2. Binary Search</h3> <p>The <strong> <em>binary search</em> </strong> technique is utilized to quickly locate a specific element in a sorted <strong> <em>array</em> </strong> or <strong> <em>list</em> </strong> . It uses a <strong> <em>divide-and-conquer</em> </strong> <strong> <em>strategy</em> </strong> , periodically cutting the search area in half until the target element is located or found to be absent.</p> <p>This is how binary search functions:</p> <ol class="points"> <li>Have a sorted array or list as a base.</li> <li>Establish two pointers, <strong> <em>left</em> </strong> and <strong> <em>right</em> </strong> , with their initial values pointing to the array&apos;s first and end members.</li> <li>Use <strong> <em>(left + right) / 2</em> </strong> to get the index of the center element.</li> <li>Compare the target value to the middle element. <ol class="pointsa"> <li>The search is successful if they are equal, and then the program can return the <strong> <em>index</em> </strong> or any other required result.</li> <li>The right pointer should be moved to the element preceding the <strong> <em>middle element</em> </strong> if the middle element is greater than the target value.</li> <li>Move the <strong> <em>left pointer</em> </strong> to the element following the <strong> <em>middle element</em> </strong> if the middle element&apos;s value is less than the target value.</li> </ol></li> <li>Steps <strong> <em>3</em> </strong> and <strong> <em>4</em> </strong> should be repeated until the target element is located or the left pointer exceeds the right pointer.</li> <li>The desired element is not in the array if it cannot be located.</li> </ol> <p> <strong>Program:</strong> </p> <pre> #include int binarySearch(int arr[], int left, int right, int target) { while (left <= right) { int mid="left" + (right-left) 2; if (arr[mid]="=" target) return mid; the index target is found } < left="mid" 1; else right="mid-1;" -1; -1 not main() arr[]="{2," 5, 8, 12, 20, 23, 28}; n="sizeof(arr)" sizeof(arr[0]); calculate number of elements in array result="binarySearch(arr," 0, - 1, target); (result="=" -1) printf('element found
'); at %d
', result); 0; pre> <p> <strong>Output:</strong> </p> <pre> An element found at index 4 </pre> <hr></=></pre></n;>

2. Binair zoeken

De Binaire zoekopdracht techniek wordt gebruikt om snel een specifiek element in een sortering te lokaliseren reeks of lijst . Het maakt gebruik van een verdeel en heers strategie , waarbij het zoekgebied periodiek doormidden wordt gesneden totdat het doelelement is gelokaliseerd of afwezig blijkt te zijn.

Dit is hoe binair zoeken functioneert:

  1. Zorg voor een gesorteerde array of lijst als basis.
  2. Stel twee aanwijzingen vast, links En rechts , waarbij de initiële waarden verwijzen naar de eerste en eindleden van de array.
  3. Gebruik (links + rechts) / 2 om de index van het middelste element te verkrijgen.
  4. Vergelijk de doelwaarde met het middelste element.
    1. De zoekopdracht is succesvol als ze gelijk zijn, en dan kan het programma de inhoudsopgave of een ander vereist resultaat.
    2. De rechteraanwijzer moet worden verplaatst naar het element dat voorafgaat aan de middelste element als het middelste element groter is dan de doelwaarde.
    3. Verplaats de linker wijzer naar het element dat volgt op de middelste element als de waarde van het middelste element kleiner is dan de doelwaarde.
  5. Stappen 3 En 4 moet worden herhaald totdat het doelelement is gelokaliseerd of de linkeraanwijzer de rechteraanwijzer overschrijdt.
  6. Het gewenste element bevindt zich niet in de array als het niet kan worden gevonden.

Programma: 

 #include int binarySearch(int arr[], int left, int right, int target) { while (left <= right) { int mid="left" + (right-left) 2; if (arr[mid]="=" target) return mid; the index target is found } < left="mid" 1; else right="mid-1;" -1; -1 not main() arr[]="{2," 5, 8, 12, 20, 23, 28}; n="sizeof(arr)" sizeof(arr[0]); calculate number of elements in array result="binarySearch(arr," 0, - 1, target); (result="=" -1) printf(\'element found
\'); at %d
\', result); 0; pre> <p> <strong>Output:</strong> </p> <pre> An element found at index 4 </pre> <hr></=>