close

(Linear Search) C++లో సరళ శోధన అల్గోరిథం- వివరణ, ఉదాహరణ మరియు కోడ్

లీనియర్ సెర్చ్ అల్గోరిథం అనేది జాబితాలోని నిర్దిష్ట మూలకాన్ని కనుగొనడానికి ఉపయోగించే ఒక సాధారణ పద్ధతి. కావలసిన మూలకం కనుగొనబడే వరకు లేదా మొత్తం జాబితాను దాటే వరకు జాబితాలోని ప్రతి మూలకాన్ని వరుసగా తనిఖీ చేయడం ద్వారా ఈ అల్గోరిథం పని చేస్తుంది.

అది ఎలా పని చేస్తుంది

  1. జాబితాలోని మొదటి మూలకం నుండి ప్రారంభించండి.
  2. ప్రస్తుత మూలకాన్ని లక్ష్య విలువతో సరిపోల్చండి.
  3. ప్రస్తుత మూలకం లక్ష్య విలువకు సమానం అయినట్లయితే, అల్గోరిథం ఆగిపోతుంది మరియు మూలకం యొక్క స్థానాన్ని అందిస్తుంది.
  4. కాకపోతే, జాబితాలోని మిగిలిన మూలకాల ద్వారా పునరావృతం చేయడం కొనసాగించండి.
  5. లక్ష్య మూలకాన్ని కనుగొనకుండా మొత్తం జాబితాను దాటినట్లయితే, అల్గోరిథం కనుగొనబడలేదని సూచించే విలువను అందిస్తుంది.

ఉదాహరణ

మన దగ్గర పూర్ణాంకాల జాబితా ఉంది మరియు జాబితాలో 34 సంఖ్యను కనుగొనాలనుకుంటున్నాము.

జాబితా: {12, 45, 67, 89, 34, 56, 23, 90}

  1. మొదటి మూలకం వద్ద ప్రారంభించండి: 12. కావలసిన సంఖ్య కాదు.
  2. తదుపరి మూలకానికి తరలించండి: 45. కావలసిన సంఖ్య కాదు.
  3. మిగిలిన మూలకాలతో కొనసాగించండి: 67, 89, 34. ఎలిమెంట్ 34 కావలసిన సంఖ్యతో సరిపోతుంది.
  4. అల్గోరిథం 34 స్థానాన్ని ముగించి, తిరిగి ఇస్తుంది, ఇది 4.

C++లో ఉదాహరణ కోడ్ 

#include <iostream>  
#include <vector>  
  
int linearSearch(const std::vector<int>& arr, int target) {  
    for(int i = 0; i < arr.size(); ++i) {  
        if(arr[i] == target) {  
            return i;  
        }  
    }  
    return -1;  
}  
  
int main() {  
    std::vector<int> numbers = {12, 45, 67, 89, 34, 56, 23, 90};  
    int target = 34;  
  
    int result = linearSearch(numbers, target);  
  
    if(result != -1) {  
        std::cout << "Element " << target << " found at position " << result << std::endl;  
    } else {  
        std::cout << "Element " << target << " not found in the array" << std::endl;  
    }  
  
    return 0;  
}

ఇచ్చిన ఉదాహరణలో, linearSearch పూర్ణాంకాల జాబితాలో 34 సంఖ్యను కనుగొనడానికి మేము ఫంక్షన్‌ని ఉపయోగించాము. ఫలితం జాబితాలో 34 స్థానం(స్థానాలు 0 నుండి ప్రారంభమవుతాయి) లేదా సంఖ్య కనుగొనబడకపోతే -1 అవుతుంది.