अवलोकन
दूसरों ने अच्छे चित्र उदाहरण दिए हैं, जैसे कि पेड़ के चित्र। मैंने कोई सरल कोड उदाहरण नहीं देखा। इसलिए मेरी व्याख्या के अलावा, मैं अलग-अलग एल्गोरिथ्म श्रेणियों की जटिलता का वर्णन करने के लिए सरल प्रिंट स्टेटमेंट के साथ कुछ एल्गोरिदम प्रदान करूंगा।
सबसे पहले, आप लॉगरिदम का एक सामान्य विचार रखना चाहते हैं, जिसे आप https://en.wikipedia.org/wiki/Logarithm से प्राप्त कर सकते हैं । प्राकृतिक विज्ञान का उपयोग eऔर प्राकृतिक लॉग। इंजीनियरिंग शिष्य log_10 (लॉग बेस 10) का उपयोग करेंगे और कंप्यूटर वैज्ञानिक log_2 (लॉग बेस 2) का बहुत उपयोग करेंगे, क्योंकि कंप्यूटर बाइनरी आधारित हैं। कभी-कभी आपको प्राकृतिक लॉग के संक्षिप्त रूप दिखाई देंगे ln(), इंजीनियर आमतौर पर _10 को छोड़ देते हैं और बस उपयोग करते हैं log()और log_2 को संक्षिप्त रूप में देखा जाता हैlg() । सभी प्रकार के लघुगणक समान रूप से विकसित होते हैं, यही कारण है कि वे उसी श्रेणी को साझा करते हैं log(n)।
जब आप नीचे दिए गए कोड उदाहरणों को देखते हैं, तो मैं O (1), फिर O (n), फिर O (n ^ 2) को देखने की सलाह देता हूं। जब आप उन लोगों के साथ अच्छे होते हैं, तो दूसरों को देखें। मैंने स्वच्छ उदाहरणों के साथ-साथ विविधताओं को भी प्रदर्शित किया है कि सूक्ष्म परिवर्तन अभी भी उसी वर्गीकरण में कैसे परिणत हो सकते हैं।
आप O (1), O (n), O (logn) आदि को विकास की श्रेणी या श्रेणी के रूप में सोच सकते हैं। कुछ श्रेणियों को दूसरों की तुलना में अधिक समय लगेगा। ये श्रेणियां हमें एल्गोरिदम के प्रदर्शन का आदेश देने का एक तरीका देती हैं। इनपुट एन के बढ़ते ही कुछ तेजी से बढ़ता है। निम्न तालिका प्रदर्शित करती है कि विकास संख्यात्मक रूप से हुआ है। नीचे दी गई तालिका में log_2 की छत के रूप में लॉग (n) के बारे में सोचें।
विभिन्न बिग ओ श्रेणियों के सरल कोड उदाहरण:
O (1) - लगातार समय उदाहरण:
एल्गोरिथम 1 एक बार हैलो प्रिंट करता है और यह n पर निर्भर नहीं करता है, इसलिए यह हमेशा स्थिर समय में चलेगा, इसलिए यह है O(1)।
print "hello";
एल्गोरिथम 2 3 बार हैलो प्रिंट करता है, हालांकि यह एक इनपुट आकार पर निर्भर नहीं करता है। यहां तक कि n बढ़ता है, यह एल्गोरिथ्म हमेशा केवल 3 बार हैलो प्रिंट करेगा। कहा जा रहा है कि 3, एक स्थिर है, इसलिए यह एल्गोरिथम भी है O(1)।
print "hello";
print "hello";
print "hello";
O (लॉग (n)) - लॉगरिदमिक उदाहरण:
- एल्गोरिथम 3 - यह "log_2" की तरह कार्य करता है
एल्गोरिथम 3 एक एल्गोरिथम प्रदर्शित करता है जो log_2 (n) में चलता है। ध्यान दें कि लूप के लिए पोस्ट ऑपरेशन i के वर्तमान मूल्य को 2 से गुणा करता है, इसलिए i1 से 2 से 4 से 8 से 16 से 3 तक चला जाता है ...
for(int i = 1; i <= n; i = i * 2)
print "hello";
- एल्गोरिथम 4 - यह "log_3" की तरह कार्य करता है
एल्गोरिथम 4 log_3 प्रदर्शित करता है। नोटिस i1 से 3 से 9 से 27 तक जाता है ...
for(int i = 1; i <= n; i = i * 3)
print "hello";
- एल्गोरिथम 5 - यह "log_1.02" की तरह कार्य करता है
एल्गोरिथम 5 महत्वपूर्ण है, क्योंकि यह दर्शाता है कि जब तक संख्या 1 से अधिक है और परिणाम बार-बार खुद के खिलाफ गुणा किया जाता है, कि आप एक लॉगरिदमिक एल्गोरिदम देख रहे हैं।
for(double i = 1; i < n; i = i * 1.02)
print "hello";
O (n) - रैखिक समय उदाहरण:
यह एल्गोरिथ्म सरल है, जो हैलो एन बार प्रिंट करता है।
for(int i = 0; i < n; i++)
print "hello";
यह एल्गोरिथ्म एक भिन्नता दिखाता है, जहां यह हैलो n / 2 बार प्रिंट करेगा। n / 2 = 1/2 * n। हम 1/2 निरंतरता को अनदेखा करते हैं और देखते हैं कि यह एल्गोरिथ्म O (n) है।
for(int i = 0; i < n; i = i + 2)
print "hello";
O (n * log (n)) - nlog (n) उदाहरण:
का एक संयोजन के रूप में इस के बारे में सोचो O(log(n))और O(n)। छोरों के लिए घोंसले के शिकार हमें प्राप्त करने में मदद करते हैंO(n*log(n))
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
एल्गोरिथ्म 9 एल्गोरिथ्म 8 की तरह है, लेकिन प्रत्येक लूप में भिन्नताएं हैं, जो अभी भी अंतिम परिणाम है O(n*log(n))
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
O (n ^ 2) - n चुकता उदाहरण:
O(n^2) छोरों के लिए मानक घोंसले के शिकार द्वारा आसानी से प्राप्त किया जाता है।
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
एल्गोरिथ्म 10 की तरह, लेकिन कुछ बदलावों के साथ।
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
ओ (एन ^ 3) - एन क्यूबेड उदाहरण:
यह एल्गोरिथ्म 10 की तरह है, लेकिन 2 के बजाय 3 छोरों के साथ।
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
एल्गोरिथ्म 12 की तरह, लेकिन कुछ बदलावों के साथ जो अभी भी उपज देते हैं O(n^3)।
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
सारांश
उपरोक्त कई सीधे आगे के उदाहरण देते हैं, और सूक्ष्म परिवर्तन को प्रदर्शित करने में मदद करने के लिए विविधताएं पेश की जा सकती हैं जो वास्तव में विश्लेषण को नहीं बदलती हैं। उम्मीद है कि यह आपको पर्याप्त जानकारी देता है।
