close

(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 నుండి ప్రారంభమవుతాయి).