ternary search एल्गोरिथ्म न्यूनतम या unimodal function की अधिकतम एक समारोह है कि या तो बढ़ जाती है और उसके बाद कम हो जाती है या कम हो जाती है और उसके बाद बढ़ जाती है को खोजने के लिए एक तेजी से एल्गोरिथ्म है। मान लें कि हम एक ऐसे फ़ंक्शन से निपट रहे हैं जो घटता है, फिर बढ़ता है, और हम न्यूनतम मान खोजना चाहते हैं। टर्नरी सर्च निम्नलिखित रिकर्सन का उपयोग करके काम करता है:क्या इस संबंधित एल्गोरिदम से टर्नरी खोज कम कुशल है?
- यदि खिड़की का आकार "छोटा छोटा" है, तो बस अपना मध्यबिंदु वापस कर दें।
- अन्यथा:
- छोड़ दिया और सही सीमा पर कार्यप्रणाली का मूल्यांकन; मूल्य एल और आर कॉल करें।
- 1/3 और 2/3 अंक पर फ़ंक्शन का मूल्यांकन करें; फोन मूल्यों हूँ और मीटर मीटर < मीटर , तो हम समारोह के बढ़ते क्षेत्र में कर रहे हैं और कम से कम मीटर और आर के बीच नहीं किया जा सकता 2
- हैं ।
- मीटर > मीटर , तो हम समारोह के घटते क्षेत्र में हैं, तो कम से कम मैं और मीटर के बीच नहीं किया जा सकता कर सकते हैं
- रिकर्सिवली खोज 2/3 कि नहीं थे ' टी त्याग दिया।
इस एल्गोरिथ्म जल्दी से काम करता है, क्योंकि यह प्रत्येक यात्रा पर मूल्यों का 1/3 बाहर घालना रख सकते हैं।
हालांकि, मुझे लगता है कि मुझे कुछ याद आ रहा है क्योंकि मुझे विश्वास है कि हम इस एल्गोरिदम को बहुत तेजी से चला सकते हैं। विशेष रूप से, ध्यान दें कि हम हमेशा एक सीमा और जांच बिंदुओं के बीच सीमा के तीसरे भाग में से एक को फेंक रहे हैं। इसका मतलब है कि हम जांच बिंदु और दूसरी सीमा के बीच क्षेत्र को बनाए रखते हैं। चूंकि टर्नरी खोज 1/3 अंक पर जांच बिंदु चुनती है, इसका मतलब है कि हम प्रत्येक बिंदु पर मानों के 2/3 बनाए रखते हैं। क्या होगा यदि 1/3 और 2/3 अंक पर जांच करने की बजाय, हमने 1/2 - और ईपीएसलॉन पर जांच की; और 1/2 + और ईपीएसलॉन; एक बेहद छोटे और ईपीएसलॉन के लिए अंक ;? इसका मतलब यह होगा कि हम 1/2 - और ईपीएसलॉन फेंक देंगे; प्रत्येक चरण पर सीमा का, जिसका मतलब है कि सीमा का आकार बहुत तेज़ हो जाएगा, अगर हम हर बार तत्वों के 1/3 को फेंक रहे थे।
उदाहरण के तौर पर, यदि मैं चुनता हूं और ईपीएसलॉन करता हूं; = 1/1000, हम प्रत्येक पुनरावृत्ति पर खोजने के लिए 999/2000 रेंज को टॉस आउट करते हैं। पुनरावृत्तियों की कुछ संख्या के बाद शेष अंश यहाँ दिखाया गया है (त्रिगुट खोज बाईं तरफ है, मेरे एल्गोरिथ्म सही पर है :)
1 : 1.0 >= 1.0
2 : 0.666666666667 >= 0.5005
3 : 0.444444444444 >= 0.25050025
4 : 0.296296296296 >= 0.125375375125
5 : 0.197530864198 >= 0.0627503752501
6 : 0.131687242798 >= 0.0314065628127
7 : 0.0877914951989 >= 0.0157189846877
8 : 0.0585276634659 >= 0.00786735183621
9 : 0.0390184423106 >= 0.00393760959402
10 : 0.0260122948737 >= 0.00197077360181
11 : 0.0173415299158 >= 0.000986372187705
12 : 0.0115610199439 >= 0.000493679279947
13 : 0.00770734662926 >= 0.000247086479613
14 : 0.00513823108617 >= 0.00
15 : 0.00342548739078 >= 6.18952249147e-05
16 : 0.00228365826052 >= 3.09785600698e-05
17 : 0.00152243884035 >= 1.55047693149e-05
18 : 0.00101495922690 >= 7.76013704213e-06
19 : 0.000676639484599 >= 3.88394858959e-06
एल्गोरिथ्म के इस संशोधित संस्करण है सिर्फ "बेहतर" मूल संस्करण की तुलना में? या क्या मैं यहां कुछ खो रहा हूं जिसका मतलब यह होगा कि मुझे जांच बिंदु चुनने के लिए संशोधित रणनीति का उपयोग नहीं करना चाहिए?
मेरी समझ से, सुनहरा अनुभाग खोज का लाभ यह है समारोह का मूल्यांकन करता है कम बार क्योंकि यह, पुनरावृत्तियों भर में जांच का पुन: उपयोग नहीं कर सकते हैं क्योंकि यह अधिक संख्यानुसार स्थिर है। क्या मैं इसके बारे में गलत हूं? – templatetypedef
यह बिल्कुल मामला है। यह चरम bisecting एल्गोरिदम की तुलना में काफी स्थिर है, क्योंकि मध्य दो बिंदु उचित रूप से फैल गए हैं। – Peteris