मूल बिंदु से निकटतम स्थान खोजने

Question

मान लीजिए हम निम्नलिखित समस्या है - हम, की (एक्स, वाई) निर्देशांक एक सेट और एक नाम पढ़ने के लिए तो क्रम में उन्हें सॉर्ट, मूल (0, 0 से दूरी बढ़ाने के द्वारा चाहते हैं)। यहाँ एक एल्गोरिथ्म जो बुलबुला तरह सरल का उपयोग करें:

#include<iostream> 
    #include <algorithm> 
    using namespace std; 
    struct point{ 
     float x; 
     float y; 
     char name[20]; 

     }; 
     float dist(point p){ 
      return p.x*p.x+p.y*p.y; 
      } 
     void sorting(point pt[],int n){ 
      bool doMore = true; 
     while (doMore) { 
      doMore = false; // Assume no more passes unless exchange made. 
      for (int i=0; i<n-1; i++) { 
       if (dist(pt[i]) > dist(pt[i+1])) { 
        // Exchange elements 
        point temp = pt[i]; pt[i] = pt[i+1]; pt[i+1] = temp; 
        doMore = true; // Exchange requires another pass. 
       } 
      } 
     } 

     } 
     void display(point pt[],int n){ 
      for (int i=0;i<n;i++){ 
       cout<<pt[i].name<< " "; 
        } 
     } 
    int main(){ 
    point pts[1000]; 
    int n=0; 

    while (cin>>pts[n].name>>pts[n].x>>pts[n].y){ 
     n++; 

    } 
    sorting(pts,n); 
    display(pts,n); 

    return 0; 
    } 

लेकिन मैं एसटीएल छँटाई के बजाय एल्गोरिथ्म बुलबुला तरह लिखना चाहते हैं। ऐसा कैसे करें?

मेरा मतलब है कि, मैं कैसे एसटीएल तरह एल्गोरिथ्म में जिले समारोह इस्तेमाल करना चाहिए?

Answer 1

एसटीएल तरह समारोह std::sort एक वैकल्पिक तीसरा तर्क के रूप में एक उपयोगकर्ता परिभाषित तुलना समारोह (या समारोह वस्तु) ले सकते हैं। तो अगर आप जैसे में अपने आइटम नहीं हैं:

vector<point> points; 

आप उन्हें फोन करके सॉर्ट कर सकते हैं:

sort(points.begin(), points.end(), my_comp); 

जहां my_comp() निम्नलिखित प्रोटोटाइप के साथ एक समारोह है:

bool my_comp(const point &a, const point &b) 

Answer 2

#include <algorithm> 

bool sort_by_dist(point const& p1, point const& p2) { 
    return dist(p1) < dist(p2); 
} 

... 

std::sort(pt, pt + n, sort_by_dist);