विश्वविद्यालय में, हमारे एल्गोरिदम पाठ्यक्रमों में, हम सीखते हैं कि अभ्यास में उपयोग किए जाने वाले विभिन्न सरल एल्गोरिदम की जटिलता की गणना कैसे करें, जैसे कि हैश टेबल या त्वरित सॉर्ट।
लेकिन अब एक बड़ी सॉफ्टवेयर परियोजना में, जब हम इसे तेजी से बनाना चाहते हैं, तो हम सब कुछ अलग-अलग टुकड़ों में देखते हैं -A कुछ नेस्टेड लूप्स हैं जो एक तेज हैश तालिका द्वारा प्रतिस्थापित किए जा सकते हैं, यहां एक धीमी गति से खोज की जा सकती है। एक अधिक फैंसी तकनीक- लेकिन हम कभी भी अपनी पूरी पाइपलाइन की जटिलता की गणना नहीं करते हैं।
क्या उसे करने का कोई तरीका है? या लोग व्यवहार में हैं, केवल "स्थानीय रूप से" एक तेज एल्गोरिथ्म का उपयोग करते हुए, संपूर्ण अनुप्रयोग को पूरी तरह से विचार करने के बजाय, पूरे अनुप्रयोग को तेज़ी से बनाने के लिए?
(क्योंकि मुझे यह दिखाने के लिए यह प्रतीत नहीं होता है कि यदि आप बड़ी संख्या में एल्गोरिदम का ढेर लगाते हैं, जो अपने आप बहुत तेजी से ज्ञात हैं, तो आप एक पूरे के रूप में एक तेज एप्लिकेशन के साथ समाप्त होते हैं।)
मैं यह पूछ रहा हूं, क्योंकि मुझे एक बड़ी परियोजना को गति देने का काम सौंपा गया है, जिसमें किसी और ने लिखा है, जहां बहुत सारे एल्गोरिदम बातचीत कर रहे हैं और इनपुट डेटा पर काम कर रहे हैं, इसलिए यह मेरे लिए स्पष्ट नहीं है कि एकल एल्गोरिथ्म पर तेजी से कैसे प्रभाव पड़ता है पूरे आवेदन।
nबढ़ जाती है।