C++
मानक लाइब्रेरी एल्गोरिदम

std :: for_each

template<class InputIterator, class Function>
    Function for_each(InputIterator first, InputIterator last, Function f);

प्रभाव:

लागू होता है, श्रेणी में प्रत्येक पुनरावृत्ति के परिणाम के लिए f [first, last) first से शुरू होता है और last - 1 आगे बढ़ता है।

पैरामीटर:

first, last - f को लागू करने की सीमा।

f - कॉल करने योग्य वस्तु जो कि रेंज में प्रत्येक पुनरावृत्ति के परिणाम पर लागू होती है [first, last) ।

प्रतिलाभ की मात्रा:

f (C ++ 11 तक) और std::move(f) (C ++ 11 के बाद से)।

जटिलता:

last - first बार last - first ठीक f लागू होता है।

उदाहरण:

std::vector<int> v { 1, 2, 4, 8, 16 };
std::for_each(v.begin(), v.end(), [](int elem) { std::cout << elem << " "; });

वेक्टर के प्रत्येक तत्व के लिए दिए गए समारोह लागू होता है v करने के लिए इस तत्व मुद्रण stdout ।

std :: next_permutation

template< class Iterator >
bool next_permutation( Iterator first, Iterator last );
template< class Iterator, class Compare >
bool next_permutation( Iterator first, Iterator last, Compare cmpFun );

प्रभाव:
सीमा के डेटा अनुक्रम [पहले, अंतिम) को अगले lexicographically उच्च क्रमपरिवर्तन में ले जाएं। यदि cmpFun प्रदान किया जाता है, तो क्रमपरिवर्तन नियम अनुकूलित किया जाता है।

पैरामीटर:
first - रेंज की शुरुआत को क्रमबद्ध, समावेशी बनाना
last - रेंज के अंत को क्रमबद्ध, अनन्य किया जाना है

प्रतिलाभ की मात्रा:
अगर इस तरह के क्रमपरिवर्तन मौजूद हैं, तो सही है।
अन्यथा सीमा को लेक्सिकोग्राफ़िक रूप से सबसे छोटे क्रमपरिवर्तन के लिए स्वैप कर दिया जाता है और गलत वापस कर दिया जाता है।

जटिलता:
O (n), n first से last दूरी है।

उदाहरण :

std::vector< int > v { 1, 2, 3 };
do
{
   for( int i = 0; i < v.size(); i += 1 )
   {
       std::cout << v[i];
   }
   std::cout << std::endl;
}while( std::next_permutation( v.begin(), v.end() ) );

1,2,3 के सभी क्रमपरिवर्तन मामलों को लेक्सिकोग्राफिक रूप से बढ़ते क्रम में प्रिंट करें।
उत्पादन:

123  
132
213
231
312
321

std :: संचित

शीर्ष लेख <numeric> में परिभाषित किया गया

template<class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init); // (1)

template<class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation f); // (2)

प्रभाव:

एसटीडी :: संचय गुना रेंज ऑपरेशन का उपयोग करते हुए f फ़ंक्शन का उपयोग करता है [first, last) संचय मूल्य के रूप में init शुरू होता है।

प्रभावी रूप से यह इसके बराबर है:

T acc = init;
for (auto it = first; first != last; ++it)
    acc = f(acc, *it);
return acc;

संस्करण में (1) operator+ का उपयोग f स्थान पर किया जाता है, इसलिए कंटेनर के ऊपर जमा करना कंटेनर तत्वों के योग के बराबर है।

पैरामीटर:

first, last - f को लागू करने की सीमा।
init - संचायक का प्रारंभिक मूल्य।
f - बाइनरी फोल्डिंग फंक्शन।

प्रतिलाभ की मात्रा:

f अनुप्रयोगों के संचित मूल्य।

जटिलता:

O (n × k) , जहाँ n first से last दूरी है, O (k) f फ़ंक्शन की जटिलता है।

उदाहरण:

सरल योग उदाहरण:

std::vector<int> v { 2, 3, 4 };
auto sum = std::accumulate(v.begin(), v.end(), 1);
std::cout << sum << std::endl;

आउटपुट:

10

अंकों को संख्या में बदलें:

class Converter {
public:
    int operator()(int a, int d) const { return a * 10 + d; }
};

const int ds[3] = {1, 2, 3};
int n = std::accumulate(ds, ds + 3, 0, Converter());
std::cout << n << std::endl;

const std::vector<int> ds = {1, 2, 3};
int n = std::accumulate(ds.begin(), ds.end(),
                        0,
                        [](int a, int d) { return a * 10 + d; });
std::cout << n << std::endl;

आउटपुट:

123

std :: खोज

template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);

प्रभाव

सीमा के भीतर घाटी की पहली घटना को पाता है [पहला, अंतिम)

पैरामीटर

first => श्रेणी की शुरुआत की ओर इशारा करते हुए चलने वाला last => श्रेणी के अंत की ओर इशारा करते हुए val = = श्रेणी के भीतर खोजने के लिए मान

वापसी

एक पुनरावृत्त जो कि वैल के बराबर (==) श्रेणी के भीतर पहले तत्व की ओर इशारा करता है, यदि इटालियर अंतिम दिशा में इंगित करता है यदि वैल नहीं पाया जाता है।

उदाहरण

#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

int main(int argc, const char * argv[]) {

  //create a vector
  vector<int> intVec {4, 6, 8, 9, 10, 30, 55,100, 45, 2, 4, 7, 9, 43, 48};

  //define iterators
  vector<int>::iterator  itr_9; 
  vector<int>::iterator  itr_43; 
  vector<int>::iterator  itr_50; 

  //calling find
  itr_9 = find(intVec.begin(), intVec.end(), 9); //occurs twice
  itr_43 = find(intVec.begin(), intVec.end(), 43); //occurs once

  //a value not in the vector
  itr_50 = find(intVec.begin(), intVec.end(), 50); //does not occur

  cout << "first occurence of: " << *itr_9 << endl;
  cout << "only occurence of: " << *itr_43 << Lendl;


  /*
    let's prove that itr_9 is pointing to the first occurence
    of 9 by looking at the element after 9, which should be 10 
    not 43
  */
  cout << "element after first 9: " << *(itr_9 + 1) << ends;

  /*
    to avoid dereferencing intVec.end(), lets look at the 
    element right before the end
  */
  cout << "last element: " << *(itr_50 - 1) << endl;

  return 0;
}

उत्पादन

first occurence of: 9
only occurence of: 43
element after first 9: 10
last element: 48

std :: गिनती

template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type
count (InputIterator first, InputIterator last, const T& val);

प्रभाव

ऐसे तत्वों की संख्या गिनाता है जो घाटी के बराबर हैं

पैरामीटर

first => श्रेणी की शुरुआत की ओर इशारा करते हुए इट्रेटर
last => श्रेणी की समाप्ति की ओर इशारा करते हुए पुनरावृत्त
val => श्रेणी में इस मान की घटना को गिना जाएगा

वापसी

श्रेणी में उन तत्वों की संख्या जो वैल (==) के बराबर हैं।

उदाहरण

#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

int main(int argc, const char * argv[]) {
  
  //create vector
  vector<int> intVec{4,6,8,9,10,30,55,100,45,2,4,7,9,43,48};
  
  //count occurences of 9, 55, and 101
  size_t count_9 = count(intVec.begin(), intVec.end(), 9); //occurs twice
  size_t count_55 = count(intVec.begin(), intVec.end(), 55); //occurs once
  size_t count_101 = count(intVec.begin(), intVec.end(), 101); //occurs once
  
  //print result
  cout << "There are " << count_9  << " 9s"<< endl;
  cout << "There is " << count_55  << " 55"<< endl;
  cout << "There is " << count_101  << " 101"<< ends;

  //find the first element == 4 in the vector
  vector<int>::iterator itr_4 = find(intVec.begin(), intVec.end(), 4);

  //count its occurences in the vector starting from the first one
  size_t count_4 = count(itr_4, intVec.end(), *itr_4); // should be 2

  cout << "There are " << count_4  << " " << *itr_4 << endl;

  return 0;
}

उत्पादन

There are 2 9s
There is 1 55
There is 0 101
There are 2 4

std :: count_if

template <class InputIterator, class UnaryPredicate>
typename iterator_traits<InputIterator>::difference_type
count_if (InputIterator first, InputIterator last, UnaryPredicate red);

प्रभाव

एक सीमा में उन तत्वों की संख्या गिनाती है जिनके लिए एक निर्दिष्ट विधेय कार्य सत्य है

पैरामीटर

first => श्रेणी की शुरुआत की ओर इशारा करते हुए चलनेवाला last => श्रेणी के अंत की ओर इशारा करते हुए पुनरावृत्त red => विधेय फ़ंक्शन (सही या गलत लौटाता है)

वापसी

निर्दिष्ट सीमा के भीतर उन तत्वों की संख्या जिनके लिए विधेय फ़ंक्शन सही था।

उदाहरण

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

/*
    Define a few functions to use as predicates
*/

//return true if number is odd
bool isOdd(int i){
  return i%2 == 1;
}

//functor that returns true if number is greater than the value of the constructor parameter provided
class Greater {
  int _than;
public:
  Greater(int th): _than(th){}
  bool operator()(int i){
    return i > _than;
  }
};

int main(int argc, const char * argv[]) {
  
  //create a vector
  vector<int> myvec = {1,5,8,0,7,6,4,5,2,1,5,0,6,9,7};

  //using a lambda function to count even numbers
  size_t evenCount = count_if(myvec.begin(), myvec.end(), [](int i){return i % 2 == 0;}); // >= C++11
  
  //using function pointer to count odd number in the first half of the vector
  size_t oddCount = count_if(myvec.begin(), myvec.end()- myvec.size()/2, isOdd);
  
  //using a functor to count numbers greater than 5
  size_t greaterCount = count_if(myvec.begin(), myvec.end(), Greater(5));

  cout << "vector size: " << myvec.size() << endl;
  cout << "even numbers: " << evenCount << " found" << endl;
  cout << "odd numbers: " << oddCount << " found" << endl;
  cout << "numbers > 5: " << greaterCount << " found"<< endl;
  
  return 0;
}

उत्पादन

vector size: 15
even numbers: 7 found
odd numbers: 4 found
numbers > 5: 6 found

std :: find_if

template <class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);

प्रभाव

एक श्रेणी में पहला तत्व ढूँढता है जिसके लिए पूर्ववर्ती फ़ंक्शन pred रिटर्न सही है।

पैरामीटर

first => श्रेणी की शुरुआत की ओर इशारा करते हुए चलने वाला last => श्रेणी last के अंत की ओर इशारा करते हुए pred => कार्य को पूर्व निर्धारित करें (सही या गलत लौटाता है)

वापसी

एक पुनरावृत्ति जो सीमा के भीतर पहले तत्व को इंगित करता है, उसके लिए पूर्ववर्ती फ़ंक्शन प्री रिटर्न सही होता है। वैली न मिलने पर चलने का इशारा करता है

उदाहरण

#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;

/*
    define some functions to use as predicates
*/

//Returns true if x is multiple of 10
bool multOf10(int x) {
  return x % 10 == 0;
}

//returns true if item greater than passed in parameter
class Greater {
  int _than;

public:
  Greater(int th):_than(th){
    
  }
  bool operator()(int data) const 
  {
    return data > _than;
  }
};


int main()
{

  vector<int> myvec {2, 5, 6, 10, 56, 7, 48, 89, 850, 7, 456};
  
  //with a lambda function
  vector<int>::iterator gt10 = find_if(myvec.begin(), myvec.end(), [](int x){return x>10;}); // >= C++11
  
  //with a function pointer
  vector<int>::iterator pow10 = find_if(myvec.begin(), myvec.end(), multOf10);

  //with functor
  vector<int>::iterator gt5 = find_if(myvec.begin(), myvec.end(), Greater(5));

  //not Found
  vector<int>::iterator nf = find_if(myvec.begin(), myvec.end(), Greater(1000)); // nf points to myvec.end()


  //check if pointer points to myvec.end()
  if(nf != myvec.end()) {
    cout << "nf points to: " << *nf << endl;
  }
  else {
    cout << "item not found" << endl;
  }

  
  
  cout << "First item >   10: " << *gt10  << endl;
  cout << "First Item n * 10: " << *pow10 << endl;
  cout << "First Item >    5: " << *gt5   << endl;
  
  return 0;
}

उत्पादन

item not found
First item >   10: 56
First Item n * 10: 10
First Item >    5: 6

std :: min_element

template <class ForwardIterator>
ForwardIterator min_element (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Compare>
ForwardIterator min_element (ForwardIterator first, ForwardIterator last,Compare comp);

प्रभाव

एक सीमा में न्यूनतम तत्व पाता है

पैरामीटर

first - रेंज की शुरुआत की ओर इशारा करते हुए
last - पुनरावृत्ति श्रेणी comp के अंत की ओर इशारा करते हुए - एक फ़ंक्शन पॉइंटर या फ़ंक्शन ऑब्जेक्ट जो दो तर्क लेता है और यह सही या गलत संकेत देता है कि क्या तर्क तर्क से कम है 2. यह फ़ंक्शन इनपुट को संशोधित नहीं करना चाहिए

वापसी

रेंज में न्यूनतम तत्व के लिए Iterator

जटिलता

तुलना में तत्वों की संख्या से कम में एक रैखिक।

उदाहरण

#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>  //to use make_pair

using namespace std;

//function compare two pairs
bool pairLessThanFunction(const pair<string, int> &p1, const pair<string, int> &p2)
{
  return p1.second < p2.second;
}

int main(int argc, const char * argv[]) {
  
  vector<int> intVec {30,200,167,56,75,94,10,73,52,6,39,43};
  
  vector<pair<string, int>> pairVector = {make_pair("y", 25), make_pair("b", 2), make_pair("z", 26), make_pair("e", 5) };
  
  
  // default using < operator
  auto minInt = min_element(intVec.begin(), intVec.end());
  
  //Using pairLessThanFunction
  auto minPairFunction = min_element(pairVector.begin(), pairVector.end(), pairLessThanFunction);
  
  
  //print minimum of intVector
  cout << "min int from default: " << *minInt << endl;
  
  //print minimum of pairVector
  cout << "min pair from PairLessThanFunction: " << (*minPairFunction).second << endl;
  
  return 0;
}

उत्पादन

min int from default: 6
min pair from PairLessThanFunction: 2

Std :: nth_element का उपयोग करने के लिए मेडियन (या अन्य मात्राएँ) खोजें

std::nth_element एल्गोरिथ्म तीन std::nth_element लेता है: शुरुआत, n वें स्थान और अंत के लिए एक std::nth_element । एक बार फ़ंक्शन वापस आने पर, n वें तत्व (क्रम से) n th सबसे छोटा तत्व होगा। (फ़ंक्शन में अधिक विस्तृत अधिभार हैं, उदाहरण के लिए, कुछ तुलनात्मक रूपांतरणकर्ता ले रहे हैं; सभी विविधताओं के लिए उपरोक्त लिंक देखें।)

नोट यह फ़ंक्शन बहुत कुशल है - इसमें रैखिक जटिलता है।

इस उदाहरण के लिए, आइए लंबाई n के अनुक्रम के माध्य को परिभाषित करें क्योंकि तत्व ⌉n / 2⌈ की स्थिति में होगा। उदाहरण के लिए, लंबाई 5 के अनुक्रम का माध्य 3 सबसे छोटा तत्व है, और इसलिए लंबाई 6 के अनुक्रम का माध्यिका है।

माध्यिका को खोजने के लिए इस फ़ंक्शन का उपयोग करने के लिए, हम निम्नलिखित का उपयोग कर सकते हैं। कहते हैं हम शुरू करते हैं

std::vector<int> v{5, 1, 2, 3, 4};    

std::vector<int>::iterator b = v.begin();
std::vector<int>::iterator e = v.end();

std::vector<int>::iterator med = b;
std::advance(med, v.size() / 2); 

// This makes the 2nd position hold the median.
std::nth_element(b, med, e);    

// The median is now at v[2].

पी वें क्वांटाइल को खोजने के लिए, हम उपरोक्त कुछ लाइनों को बदलेंगे:

const std::size_t pos = p * std::distance(b, e);

std::advance(nth, pos);

और स्थिति pos में मात्रा के लिए देखो।