बिग ओ नोटेशन एक गणितीय अवधारणा है जिसका उपयोग इनपुट आकार बढ़ने पर समय और स्थान के संदर्भ में एल्गोरिदम के प्रदर्शन या जटिलता का वर्णन करने के लिए किया जाता है। यह हमें यह समझने में मदद करता है कि बड़े इनपुट के साथ एल्गोरिदम का रनटाइम कैसे बढ़ता है, जिससे विभिन्न एल्गोरिदम की अधिक मानकीकृत तुलना की अनुमति मिलती है।

बिग ओ नोटेशन का उपयोग क्यों करें?

एल्गोरिदम की तुलना करते समय, केवल निष्पादन समय पर भरोसा करना भ्रामक हो सकता है। उदाहरण के लिए, एक एल्गोरिदम एक बड़े डेटासेट को एक घंटे में संसाधित कर सकता है, जबकि दूसरे को चार घंटे लगते हैं। हालाँकि, निष्पादन समय मशीन और अन्य चल रही प्रक्रियाओं के आधार पर भिन्न हो सकता है। इसके बजाय, हम निष्पादित कार्यों की संख्या पर ध्यान केंद्रित करने के लिए बिग ओ नोटेशन का उपयोग करते हैं, जो दक्षता का अधिक सुसंगत माप प्रदान करता है।

उदाहरण: संख्याओं का योग

आइए 1 से n तक की सभी संख्याओं के योग की गणना करने के दो तरीके तलाशें:

विकल्प 1: लूप का उपयोग करना

function addUpTo(n) {
    let total = 0;
    for (let i = 1; i 




  
  
  विकल्प 2: सूत्र का उपयोग करना




function addUpTo(n) {
    return n * (n   1) / 2;
}





  
  
  जटिलता का विश्लेषण


विकल्प 1 में, यदि n 100 है, तो लूप 100 बार चलता है। इसके विपरीत, विकल्प 2 हमेशा एक निश्चित संख्या में ऑपरेशन (गुणा, जोड़ और भाग) निष्पादित करता है। इस प्रकार:

• विकल्प 1 O(n) है: समय जटिलता n के साथ रैखिक रूप से बढ़ती है।
• विकल्प 2 O(1) है: इनपुट आकार की परवाह किए बिना समय जटिलता स्थिर रहती है।

अस्वीकरण

जबकि विकल्प 2 में तीन ऑपरेशन (गुणा, जोड़, भाग) शामिल हैं, हम बिग ओ विश्लेषण में सामान्य प्रवृत्ति पर ध्यान केंद्रित करते हैं। इस प्रकार, इसे O(3n) के रूप में व्यक्त करने के बजाय, हम इसे O(n) तक सरल बनाते हैं। इसी प्रकार, O(n 10) O(n) को सरल बनाता है, और O(n^2 5n 8) O(n^2) को सरल बनाता है। बिग ओ नोटेशन में, हम सबसे खराब स्थिति पर विचार करते हैं, जहां उच्चतम-क्रम वाले शब्द का प्रदर्शन पर सबसे अधिक प्रभाव पड़ता है।

ऊपर सूचीबद्ध सामान्य जटिलताओं से परे संकेतन के अन्य रूप भी हैं, जैसे लॉगरिदमिक समय जटिलता को ओ (लॉग एन) के रूप में व्यक्त किया जाता है।

बिग ओ नोटेशन क्या है?

बिग ओ नोटेशन हमें इनपुट आकार के आधार पर एल्गोरिदम के रनटाइम के विकास को औपचारिक बनाने की अनुमति देता है। विशिष्ट ऑपरेशन गणनाओं पर ध्यान केंद्रित करने के बजाय, हम एल्गोरिदम को व्यापक वर्गों में वर्गीकृत करते हैं जिनमें शामिल हैं:

• निरंतर समय: O(1) - एल्गोरिदम का प्रदर्शन इनपुट आकार के साथ नहीं बदलता है।
• रैखिक समय: O(n) - इनपुट आकार के साथ प्रदर्शन रैखिक रूप से बढ़ता है।
• द्विघात समय: O(n^2) - जैसे-जैसे इनपुट आकार बढ़ता है, प्रदर्शन द्विघात रूप से बढ़ता है।

O(n^2) का उदाहरण

निम्नलिखित फ़ंक्शन पर विचार करें, जो 0 से n तक संख्याओं के सभी जोड़े प्रिंट करता है:

function printAllPairs(n) {
    for (var i = 0; i 



इस मामले में, फ़ंक्शन में दो नेस्टेड लूप होते हैं, इसलिए जब एनएनएन बढ़ता है, तो संचालन की संख्या चतुष्कोणीय रूप से बढ़ जाती है। n= 2 के लिए, 4 ऑपरेशन हैं, और n=3 के लिए, 9 ऑपरेशन हैं, जो O(n^2) की ओर ले जाते हैं।


  
  
  दूसरा उदाहरण: ऊपर और नीचे गिनें




function countUpAndDown(n) {
    console.log("Going up!");
    for (var i = 0; i = 0; j--) {
        console.log(j);
    }
    console.log("Back down. Bye!");
}





पहली नज़र में, कोई सोच सकता है कि यह O(n^2) है क्योंकि इसमें दो लूप हैं। हालाँकि, दोनों लूप स्वतंत्र रूप से चलते हैं और n के साथ रैखिक रूप से स्केल करते हैं। इस प्रकार, समग्र समय जटिलता O(n) है।


  
  
  विश्लेषण को सरल बनाना


कोड जटिलता के हर पहलू का विश्लेषण करना जटिल हो सकता है, लेकिन कुछ सामान्य नियम चीजों को सरल बना सकते हैं:

• अंकगणितीय संक्रियाओं को स्थिर समय माना जाता है।
• परिवर्तनीय कार्य स्थिर समय हैं।
• किसी सरणी (सूचकांक द्वारा) या ऑब्जेक्ट (कुंजी द्वारा) में तत्वों तक पहुंचना निरंतर समय है।
• एक लूप के लिए, जटिलता लूप की लंबाई को लूप के अंदर जो होता है उसकी जटिलता से गुणा किया जाता है।

अंतरिक्ष जटिलता

हालांकि हमने समय जटिलता पर ध्यान केंद्रित किया है, बिग ओ का उपयोग करके स्थान (मेमोरी) जटिलता की गणना करना भी संभव है। कुछ लोग अपनी गणना में इनपुट आकार को शामिल करते हैं, लेकिन एल्गोरिदम द्वारा आवश्यक स्थान पर ध्यान केंद्रित करना अक्सर अधिक उपयोगी होता है स्वयं.

अंतरिक्ष जटिलता के नियम (जावास्क्रिप्ट पर आधारित):

• अधिकांश आदिम मान (बूलियन, संख्याएं, आदि) स्थिर स्थान हैं।
• स्ट्रिंग्स के लिए O(n) स्पेस की आवश्यकता होती है (जहाँ n स्ट्रिंग की लंबाई है)।
• संदर्भ प्रकार (सरणी, ऑब्जेक्ट) आम तौर पर O(n) होते हैं, जहां n सरणी की लंबाई या ऑब्जेक्ट में कुंजियों की संख्या है।

एक उदाहरण

function sum(arr) {
    let total = 0;
    for (let i = ; i 



इस फ़ंक्शन में, अंतरिक्ष जटिलता O(1) है क्योंकि हम इनपुट आकार की परवाह किए बिना एक स्थिर मात्रा में स्थान (दो चर) का उपयोग करते हैं।

एक फ़ंक्शन के लिए जो एक नई सरणी बनाता है:



function double(arr) {
    let newArr = [];
    for (let i = 0; i 



यहाँ, अंतरिक्ष जटिलता O(n) है क्योंकि हम एक नई सरणी के लिए स्थान आवंटित करते हैं जो इनपुट सरणी के आकार के साथ बढ़ती है।


  
  
  निष्कर्ष


बिग ओ नोटेशन एल्गोरिदम की दक्षता का विश्लेषण करने के लिए एक रूपरेखा प्रदान करता है जो हार्डवेयर और विशिष्ट कार्यान्वयन विवरणों से स्वतंत्र है। कुशल कोड विकसित करने के लिए इन अवधारणाओं को समझना महत्वपूर्ण है, खासकर जब डेटा का आकार बढ़ता है। प्रदर्शन के पैमाने पर ध्यान केंद्रित करके, डेवलपर्स अपने अनुप्रयोगों में किस एल्गोरिदम का उपयोग करना है, इसके बारे में सूचित विकल्प बना सकते हैं।