(Multiple-Item Search) C++ માં બહુવિધ-આઇટમ શોધ અલ્ગોરિધમ- સમજૂતી, ઉદાહરણ અને કોડ

બહુવિધ-આઇટમ શોધ અલ્ગોરિધમનો ઉપયોગ સૂચિમાં ચોક્કસ તત્વની બધી ઘટનાઓ શોધવા માટે થાય છે. સિંગલ-આઇટમ શોધ અલ્ગોરિધમ્સથી વિપરીત, આ અભિગમ લક્ષ્ય તત્વની બહુવિધ ઘટનાઓનો ટ્રૅક રાખે છે અને તેમની સ્થિતિની સૂચિ આપે છે.

તે કેવી રીતે કામ કરે છે

1. સૂચિની શરૂઆતથી પ્રારંભ કરો.
2. સૂચિમાં દરેક ઘટક દ્વારા પુનરાવર્તન કરો.
3. લક્ષ્ય મૂલ્ય સાથે વર્તમાન તત્વની તુલના કરો.
4. જો વર્તમાન તત્વ લક્ષ્ય મૂલ્યની બરાબર હોય, તો તેની સ્થિતિ રેકોર્ડ કરો.
5. આગલા તત્વ પર ચાલુ રાખો અને પગલાં 3-4 પુનરાવર્તન કરો.
6. સમગ્ર સૂચિમાં પુનરાવર્તિત થયા પછી, રેકોર્ડ કરેલી સ્થિતિની સૂચિ પરત કરો.

ઉદાહરણ

ચાલો પૂર્ણાંકોની સૂચિને ધ્યાનમાં લઈએ અને અમે 23 નંબરની બધી ઘટનાઓ શોધવા માંગીએ છીએ.

સૂચિ: {12, 23, 45, 23, 56, 23, 89, 90}

1. શરૂઆતથી શરૂ કરો: 12. ઇચ્છિત સંખ્યા નથી.
2. આગલા ઘટક પર જાઓ: 23. મેળ મળ્યો, 1 તરીકે સ્થાન રેકોર્ડ કરો.
3. આગલા તત્વ પર જાઓ: 45. ઇચ્છિત સંખ્યા નથી.
4. આગલા ઘટક પર જાઓ: 23. મેળ મળ્યો, 3 તરીકે સ્થાન રેકોર્ડ કરો.
5. આગલા તત્વ પર જાઓ: 56. ઇચ્છિત સંખ્યા નથી.
6. આગલા ઘટક પર જાઓ: 23. મેળ મળ્યો, 5 તરીકે સ્થાન રેકોર્ડ કરો.
7. આગલા તત્વ પર જાઓ: 89. ઇચ્છિત સંખ્યા નથી.
8. આગલા તત્વ પર જાઓ: 90. ઇચ્છિત સંખ્યા નથી.
9. પુનરાવર્તિત કર્યા પછી, સ્થિતિઓની સૂચિ પરત કરો: [1, 3, 5].

C++ માં ઉદાહરણ કોડ

#include <iostream>  
#include <vector>  
  
std::vector<int> multipleItemSearch(const std::vector<int>& arr, int target) {  
    std::vector<int> positions;  
  
    for(int i = 0; i < arr.size(); ++i) {  
        if(arr[i] == target) {  
            positions.push_back(i);  
        }  
    }  
  
    return positions;  
}  
  
int main() {  
    std::vector<int> numbers = {12, 23, 45, 23, 56, 23, 89, 90};  
    int target = 23;  
  
    std::vector<int> result = multipleItemSearch(numbers, target);  
  
    std::cout << "Occurrences of " << target << " found at positions: ";  
    for(int pos: result) {  
        std::cout << pos << ";  
    }  
    std::cout << std::endl;  
  
    return 0;  
}  

આપેલ ઉદાહરણમાં, multipleItemSearch ફંક્શનનો ઉપયોગ પૂર્ણાંકોની સૂચિમાં નંબર 23 ની બધી ઘટનાઓ શોધવા માટે થાય છે. પરિણામ એ વેક્ટર હશે જેમાં તમામ ઘટનાઓની સ્થિતિ હશે(સ્થિતિઓ 0 થી શરૂ થાય છે).