RBSE Solutions Class 12 Computer Science Chapter 3 सॉर्टिंग

 

प्रश्न 1. बबल एल्गोरिथ्म की जटिलता है
(a) \(O(N)\)
(b) \(O(N^2)\)
(c) \(O(\log N)\)
(d) \(O(N \log N)\)
Answer: (b) \(O(N^2)\)
In simple words: बबल सॉर्ट एल्गोरिथम में, तत्वों को व्यवस्थित करने के लिए सबसे खराब स्थिति में \(N^2\) के बराबर समय लगता है। यह इसे बड़े डेटा सेट के लिए धीमा बनाता है।

🎯 Exam Tip: सॉर्टिंग एल्गोरिथम की जटिलता (complexity) को याद रखना महत्वपूर्ण है, क्योंकि यह उनकी दक्षता को दर्शाता है, खासकर बड़े डेटा सेट के लिए।

 

प्रश्न 2. मर्ज एल्गोरिथ्म की जटिलता है
Answer: मर्ज एल्गोरिथ्म की जटिलता (complexity) \(O(N \log N)\) होती है।

🎯 Exam Tip: मर्ज सॉर्ट एक "डिवाइड एंड कॉन्कर" एल्गोरिथम है, और इसकी \(O(N \log N)\) जटिलता इसे बड़े डेटा सेट के लिए बहुत कुशल बनाती है।

 

प्रश्न 3. चयन एल्गोरिथ्म की जटिलता है
(a) \(O(N)\)
(b) \(O(N^2)\)
(c) \(O(\log N)\)
(d) \(O(N \log N)\)
Answer: (b) \(O(N^2)\)
In simple words: चयन सॉर्ट एल्गोरिथम में, तत्वों को सॉर्ट करने के लिए सबसे खराब स्थिति में \(N^2\) के बराबर समय लगता है। यह इसे मध्यम आकार के डेटा सेट के लिए भी अनुपयोगी बना देता है।

🎯 Exam Tip: सिलेक्शन सॉर्ट की जटिलता बबल सॉर्ट और इंसर्शन सॉर्ट के समान है, जो तीनों को छोटे डेटा सेट के लिए उपयुक्त बनाती है।

 

प्रश्न 4. कौन सा अच्छा सॉर्टिंग एल्गोरिथ्म है?
(a) चयन सॉर्टिग
(b) निवेशन सॉर्टिग
(c) त्वरित सॉर्टिग
(d) कोई नहीं
Answer: (c) त्वरित सॉर्टिग
In simple words: त्वरित सॉर्टिंग आमतौर पर सबसे अच्छी मानी जाती है क्योंकि यह बड़े डेटा सेट को तेजी से व्यवस्थित कर सकती है।

🎯 Exam Tip: एल्गोरिथम की "अच्छा" होना उसकी औसत-केस जटिलता और व्यावहारिक प्रदर्शन पर निर्भर करता है। क्विकसॉर्ट की औसत जटिलता \(O(N \log N)\) होती है।

 

प्रश्न 5. त्वरित क्रमबद्ध एल्गोरिथ्म की जटिलता है।
(a) \(O(N)\)
(b) \(O(\log N)\)
(c) \(O(N^2)\)
(d) \(O(N \log N)\)
Answer: (d) \(O(N \log N)\)
In simple words: क्विकसॉर्ट एक कुशल एल्गोरिथम है जो अधिकांश स्थितियों में \(N \log N\) समय में तत्वों को व्यवस्थित करता है।

🎯 Exam Tip: क्विकसॉर्ट की सबसे खराब स्थिति \(O(N^2)\) हो सकती है, लेकिन यह दुर्लभ है और अच्छे पाइवोट चयन से बचा जा सकता है।

RBSE Class 12 Computer Science Chapter 3 लघु उत्तरीय प्रश्न

 

प्रश्न 1. सॉर्टिंग क्या है?
Answer: सॉर्टिंग एक ऐसी प्रक्रिया है जिसमें डेटा के तत्वों को एक विशेष क्रम में व्यवस्थित किया जाता है। यह क्रम संख्यात्मक (जैसे छोटे से बड़े या बड़े से छोटे) या वर्णानुक्रम (जैसे A से Z) हो सकता है। जब डेटा व्यवस्थित होता है, तो उसे खोजना, संसाधित करना और विश्लेषण करना बहुत आसान हो जाता है, जिससे जानकारी का उपयोग अधिक प्रभावी ढंग से होता है।
In simple words: सॉर्टिंग का मतलब है डेटा को किसी खास क्रम में लगाना, जैसे छोटे से बड़े नंबरों में या वर्णमाला के क्रम में।

🎯 Exam Tip: सॉर्टिंग का मुख्य उद्देश्य डेटा को कुशलतापूर्वक ढूंढना और उपयोग करना है, जिससे डेटा प्रोसेसिंग में गति आती है।

 

प्रश्न 2. स्थिर सॉर्टिंग क्या है?
Answer: स्थिर सॉर्टिंग (Stable Sorting) एक ऐसी एल्गोरिथम है जो समान मान वाले तत्वों की आपेक्षिक क्रम को बनाए रखती है, भले ही सॉर्टिंग के बाद उनकी स्थिति बदल जाए। इसका मतलब है कि यदि दो तत्व समान हैं और उनमें से एक पहले इनपुट में दूसरे से पहले आया था, तो सॉर्टिंग के बाद भी वह पहले वाला तत्व दूसरे से पहले ही रहेगा। यह उन डेटा प्रकारों के लिए महत्वपूर्ण है जिनमें एक से अधिक गुण होते हैं।

In simple words: स्थिर सॉर्टिंग एल्गोरिथम में, यदि दो चीजें एक जैसी हैं, तो उनका शुरुआती क्रम सॉर्ट करने के बाद भी वही रहता है। जैसे, यदि दो 26 थे, तो जो पहले आया वह सॉर्ट करने के बाद भी पहले रहेगा।

🎯 Exam Tip: स्थिर सॉर्टिंग एल्गोरिथम अक्सर तब महत्वपूर्ण होती है जब तत्वों में अतिरिक्त डेटा होता है जिसे उनके मुख्य मानों के अलावा बनाए रखने की आवश्यकता होती है।

 

प्रश्न 3. इन-प्लेस सॉर्टिंग क्या है?
Answer: इन-प्लेस सॉर्टिंग (In-place Sorting) एक सॉर्टिंग एल्गोरिथम है जिसे डेटा को सॉर्ट करने के लिए बहुत कम या कोई अतिरिक्त मेमोरी की आवश्यकता नहीं होती है। यह इनपुट ऐरे के भीतर ही तत्वों को व्यवस्थित करता है, यानी यह किसी भी सहायक डेटा संरचना का उपयोग नहीं करता है जो इनपुट से काफी बड़ा हो। उदाहरण के लिए, बबल सॉर्ट, सिलेक्शन सॉर्ट और इंसर्शन सॉर्ट इन-प्लेस सॉर्टिंग के उदाहरण हैं। यह मेमोरी बचाने में मदद करता है।
In simple words: इन-प्लेस सॉर्टिंग का मतलब है कि डेटा को सॉर्ट करते समय हमें ज्यादा अतिरिक्त जगह या मेमोरी की जरूरत नहीं पड़ती है। यह डेटा को उसकी मूल जगह पर ही व्यवस्थित कर देता है।

🎯 Exam Tip: इन-प्लेस एल्गोरिथम मेमोरी-कुशल होते हैं, लेकिन इसका मतलब यह नहीं है कि वे हमेशा समय-कुशल भी हों। कुछ इन-प्लेस एल्गोरिथम अभी भी धीरे हो सकते हैं।

 

प्रश्न 4. त्वरित एल्गोरिथ्म के लिए सबसे खराब स्थिति (Worst case) का रन टाइम, क्या है?
Answer: त्वरित (Quick) सॉर्ट एल्गोरिथ्म के लिए सबसे खराब स्थिति का रन टाइम \(O(n^2)\) होता है। यह तब होता है जब पाइवोट तत्व हमेशा सबसे छोटा या सबसे बड़ा तत्व चुना जाता है, जिससे विभाजन असंतुलित हो जाता है।
In simple words: क्विकसॉर्ट कभी-कभी सबसे ज्यादा समय \(N\) वर्ग के अनुपात में ले सकता है, अगर गलत पाइवोट को चुना जाए।

🎯 Exam Tip: क्विकसॉर्ट की सबसे खराब स्थिति से बचने के लिए, एक अच्छा पाइवोट चुनने की रणनीति का उपयोग किया जाता है, जैसे कि रैंडम पाइवोट या माध्यिका का माध्य पाइवोट।

 

प्रश्न 5. त्वरित एल्गोरिथ्म के लिए सबसे खराब स्थिति (Worst case) क्या है?
Answer: त्वरित (Quick) सॉर्ट एल्गोरिथ्म के लिए सबसे खराब स्थिति का रन टाइम \(O(n^2)\) होता है। यह स्थिति तब आती है जब इनपुट ऐरे पहले से पूरी तरह से सॉर्टेड हो या रिवर्स सॉर्टेड हो, और पाइवोट हमेशा ऐरे के पहले या आखिरी तत्व के रूप में चुना जाता है। ऐसे मामलों में, एल्गोरिथम का विभाजन चरण अक्षम हो जाता है।
In simple words: क्विकसॉर्ट सबसे खराब तब चलता है जब डेटा पहले से ही पूरी तरह से क्रम में हो या बिल्कुल उल्टे क्रम में हो। तब इसे \(N^2\) समय लगता है।

🎯 Exam Tip: डुप्लिकेट प्रश्न होने पर भी, यह सुनिश्चित करें कि आपके उत्तर में सभी आवश्यक जानकारी शामिल हो, जैसे रन टाइम और स्थिति का संक्षिप्त विवरण।

RBSE Class 12 Computer Science Chapter 3 निबंधात्मक प्रश्न

 

प्रश्न 1. मर्ज सॉर्टिंग विस्तार में समझाइए।
Answer: मर्ज सॉर्टिंग एक बहुत कुशल सॉर्टिंग एल्गोरिथम है जो "डिवाइड एंड कॉन्कर" (विभाजित करो और जीतो) के सिद्धांत पर काम करती है। यह एल्गोरिथम एक ऐरे को तब तक छोटे-छोटे हिस्सों में बांटती है जब तक प्रत्येक हिस्से में केवल एक तत्व न रह जाए, क्योंकि एक-तत्व वाला ऐरे हमेशा सॉर्टेड होता है। फिर, इन सॉर्टेड हिस्सों को वापस एक साथ मर्ज किया जाता है ताकि एक पूरी तरह से सॉर्टेड ऐरे बन जाए। **मर्ज सॉर्ट के चरण:** 1. **विभाजन (Divide):** ऐरे को दो बराबर हिस्सों में बांटें। यह प्रक्रिया तब तक चलती है जब तक हमें ऐसे उप-ऐरे न मिलें जिनमें केवल एक तत्व हो। 2. **जीत (Conquer):** प्रत्येक उप-ऐरे (जिसमें एक तत्व होता है) को सॉर्टेड माना जाता है। 3. **विलय (Merge):** सॉर्टेड उप-ऐरे को एक साथ वापस मर्ज किया जाता है ताकि बड़े सॉर्टेड ऐरे बन सकें। यह प्रक्रिया तब तक दोहराई जाती है जब तक पूरा मूल ऐरे सॉर्ट न हो जाए। दो सॉर्टेड लिस्ट को मर्ज करते समय, प्रत्येक लिस्ट के पहले तत्वों की तुलना की जाती है और छोटे तत्व को परिणामी लिस्ट में रखा जाता है। **उदाहरण के लिए, हम एक अवर्गीकृत ऐरे लेते हैं:**

**विभाजन चरण:** सबसे पहले, ऐरे को दो बराबर हिस्सों में बांटते हैं:औरफिर इन हिस्सों को और छोटे-छोटे हिस्सों में बांटते हैं, जब तक कि प्रत्येक में एक ही तत्व न रह जाए। यह मूल मानों की उपस्थिति के क्रम को नहीं बदलता है। **विलय चरण:** अब हम इन एक-तत्वीय लिस्ट को सॉर्टेड तरीके से वापस जोड़ना शुरू करते हैं। उदाहरण के लिए, \([14]\) और \([33]\) सॉर्टेड हैं। \([27]\) और \([10]\) को मर्ज करते समय, \([10]\) पहले आएगा और \([27]\) उसके बाद। यह प्रक्रिया सभी उप-ऐरे पर लागू होती है।और**अंतिम विलय के बाद, लिस्ट इस तरह दिखेगी:**मर्ज सॉर्ट की सबसे खराब स्थिति में जटिलता \(O(n \log n)\) होती है, जो इसे बड़े डेटा सेट के लिए बहुत कुशल बनाती है।
In simple words: मर्ज सॉर्ट डेटा को छोटे-छोटे टुकड़ों में बांटता है, हर टुकड़े को सॉर्ट करता है, और फिर उन सभी सॉर्ट किए गए टुकड़ों को एक साथ जोड़ देता है ताकि पूरा डेटा सही क्रम में आ जाए।

🎯 Exam Tip: मर्ज सॉर्ट की स्थिरता (stability) और इसकी औसत-केस जटिलता \(O(n \log n)\) इसे एक लोकप्रिय विकल्प बनाती है, खासकर जब डेटा को बाहरी मेमोरी में सॉर्ट करने की आवश्यकता होती है।

 

प्रश्न 2. कौन-सी सबसे अच्छी सॉर्टिंग एल्गोरिथ्म है और क्यों?
Answer: मर्ज सॉर्टिंग को सबसे अच्छी सॉर्टिंग एल्गोरिथम में से एक माना जाता है, खासकर जब स्थिरता और बड़े डेटा सेट के लिए कुशल प्रदर्शन की आवश्यकता होती है। यह "डिवाइड एंड कॉन्कर" तकनीक पर आधारित है। **मर्ज सॉर्ट अच्छी क्यों है:** * **जटिलता (Complexity):** इसकी औसत और सबसे खराब स्थिति दोनों में समय जटिलता \(O(n \log n)\) है। इसका मतलब है कि यह बड़े डेटा सेट के लिए बहुत कुशल है क्योंकि इसका प्रदर्शन \(N\) के साथ तेजी से नहीं घटता। * **स्थिरता (Stability):** मर्ज सॉर्ट एक स्थिर सॉर्टिंग एल्गोरिथम है। यह समान मान वाले तत्वों के आपेक्षिक क्रम को बनाए रखती है, जो कुछ अनुप्रयोगों में महत्वपूर्ण है। * **गारंटीकृत प्रदर्शन:** क्विकसॉर्ट के विपरीत, जिसकी सबसे खराब स्थिति \(O(n^2)\) हो सकती है, मर्ज सॉर्ट का प्रदर्शन हमेशा \(O(n \log n)\) ही रहता है, भले ही इनपुट डेटा कैसा भी हो। यह इसे उन स्थितियों के लिए भरोसेमंद बनाता है जहां प्रदर्शन की निरंतरता महत्वपूर्ण है। * **एक्सटर्नल सॉर्टिंग:** मर्ज सॉर्ट बाहरी सॉर्टिंग के लिए उपयुक्त है, जहां डेटा मेमोरी में फिट होने के लिए बहुत बड़ा होता है और उसे डिस्क से पढ़ा और लिखा जाता है। इन कारणों से, मर्ज सॉर्ट एक विश्वसनीय और कुशल विकल्प है, खासकर बड़े और संवेदनशील डेटा सेट के लिए।
In simple words: मर्ज सॉर्ट सबसे अच्छी एल्गोरिथम है क्योंकि यह हमेशा तेजी से काम करती है (\(N \log N\) समय में) और यह सुनिश्चित करती है कि समान चीजें अपने मूल क्रम में रहें।

🎯 Exam Tip: एल्गोरिथम की "सर्वोत्तमता" हमेशा उपयोग के मामले पर निर्भर करती है। क्विकसॉर्ट आमतौर पर औसत स्थिति में तेज होता है, लेकिन मर्ज सॉर्ट की गारंटीकृत \(O(n \log n)\) जटिलता इसे अधिक विश्वसनीय बनाती है।

 

प्रश्न 3. त्वरित सॉर्टिंग समझाइए।
Answer: त्वरित सॉर्टिंग (Quick Sort) एक बहुत कुशल "डिवाइड एंड कॉन्कर" सॉर्टिंग एल्गोरिथम है। यह डेटा को छोटे ऐरे में विभाजित करने के सिद्धांत पर आधारित है। **त्वरित सॉर्टिंग के चरण:** 1. **पाइवोट चुनें:** ऐरे से एक तत्व को 'पाइवोट' के रूप में चुना जाता है। यह आमतौर पर पहला, आखिरी, बीच का या एक यादृच्छिक तत्व हो सकता है। 2. **विभाजन (Partition):** ऐरे को दो उप-ऐरे में विभाजित किया जाता है। एक उप-ऐरे में वे सभी तत्व होते हैं जो पाइवोट से छोटे होते हैं, और दूसरे उप-ऐरे में वे सभी तत्व होते हैं जो पाइवोट से बड़े होते हैं। पाइवोट इन दोनों उप-ऐरे के बीच में अपनी सही सॉर्टेड स्थिति में आ जाता है। 3. **रिकर्सिव सॉर्ट:** विभाजन प्रक्रिया को फिर से छोटे उप-ऐरे पर बार-बार (रिकर्सिवली) लागू किया जाता है, जब तक कि प्रत्येक उप-ऐरे में एक ही तत्व न रह जाए या उप-ऐरे खाली न हो जाएं। 4. **विलय:** चूंकि विभाजन प्रक्रिया में तत्व पहले से ही पाइवोट के संबंध में सॉर्ट हो जाते हैं, इसलिए कोई स्पष्ट विलय चरण नहीं होता है; ऐरे को अपने आप ही सॉर्टेड मान लिया जाता है। यह एल्गोरिथम बड़े आकार के डेटा सेट के लिए काफी कुशल है। इसकी औसत (average) स्थिति में जटिलता \(O(n \log n)\) है, जहाँ \(n\) सॉर्ट किए जाने वाले तत्वों की संख्या है। हालाँकि, इसकी सबसे खराब स्थिति में जटिलता \(O(n^2)\) हो सकती है।

In simple words: क्विकसॉर्ट एक खास नंबर (पाइवोट) चुनता है, फिर बाकी सभी नंबर्स को उस पाइवोट से छोटा या बड़ा होने के हिसाब से अलग-अलग कर देता है। फिर यही काम छोटे हिस्सों पर बार-बार किया जाता है जब तक सब कुछ सही क्रम में न हो जाए।

🎯 Exam Tip: क्विकसॉर्ट की दक्षता बहुत हद तक पाइवोट चयन पर निर्भर करती है। एक अच्छे पाइवोट से लगभग बराबर आकार के विभाजन होते हैं, जिससे एल्गोरिथम की गति बढ़ती है।

 

प्रश्न 4. Selection और Insertion सॉर्टिग के बीच अन्तर बताइए।
Answer: चयन सॉर्टिंग (Selection Sort) और निवेशन सॉर्टिंग (Insertion Sort) दोनों ही इन-प्लेस तुलना-आधारित सॉर्टिंग एल्गोरिथम हैं जिनकी सबसे खराब स्थिति में जटिलता \(O(n^2)\) होती है। हालाँकि, उनके काम करने के तरीके में महत्वपूर्ण अंतर हैं। **चयन सॉर्टिंग (Selection Sort):** यह एल्गोरिथम ऐरे को दो हिस्सों में बांटता है: एक सॉर्ट किया हुआ हिस्सा और एक असॉर्ट किया हुआ हिस्सा। * **कार्यप्रणाली:** यह हर पुनरावृत्ति में असॉर्ट किए हुए हिस्से में से सबसे छोटे तत्व को ढूंढता है और उसे सॉर्ट किए हुए हिस्से के अंत में स्वैप करता है। * **मुख्य विचार:** हर बार, यह सुनिश्चित करता है कि एक और तत्व अपनी सही अंतिम स्थिति में आ गया है। * **उदाहरण:** * प्रारंभिक ऐरे:

* सबसे छोटा तत्व (10) ढूंढने और 14 के साथ स्वैप करने के बाद (पहला तत्व सॉर्टेड): * दो पुनरावृत्तियों के बाद (पहले दो तत्व सॉर्टेड):**निवेशन सॉर्टिंग (Insertion Sort):** यह एल्गोरिथम भी ऐरे को दो हिस्सों में बांटता है: एक सॉर्ट किया हुआ हिस्सा और एक असॉर्ट किया हुआ हिस्सा। * **कार्यप्रणाली:** यह हर पुनरावृत्ति में असॉर्ट किए हुए हिस्से से एक तत्व लेता है और उसे सॉर्ट किए हुए हिस्से में उसकी सही स्थिति में सम्मिलित करता है। इसमें सॉर्ट किए हुए हिस्से के तत्वों को दाईं ओर शिफ्ट करना पड़ सकता है। * **मुख्य विचार:** यह एक कार्ड गेम में पत्तों को सॉर्ट करने जैसा है, जहाँ आप एक नया पत्ता लेते हैं और उसे पहले से सॉर्ट किए हुए पत्तों के बीच सही जगह पर रखते हैं। * **उदाहरण:** * प्रारंभिक ऐरे: * 14 और 33 पहले से सॉर्टेड हैं। 27 की तुलना 33 से: * 10 को सही जगह पर डालने के बाद (सॉर्टेड उप-लिस्ट: 10, 14, 27, 33):**सारांश में:** चयन सॉर्ट एक बार में एक तत्व को अपनी अंतिम स्थिति में रखता है, जबकि निवेशन सॉर्ट एक-एक करके तत्वों को लेता है और उन्हें पहले से सॉर्ट की गई सूची में सही जगह पर सम्मिलित करता है।
In simple words: चयन सॉर्ट हमेशा सबसे छोटा तत्व ढूंढता है और उसे सही जगह पर रखता है। निवेशन सॉर्ट एक-एक करके चीजों को उठाता है और उन्हें पहले से बनी हुई सही सूची में डालता जाता है।

🎯 Exam Tip: इन दोनों एल्गोरिथम के बीच का मुख्य अंतर यह है कि चयन सॉर्ट में स्वैप की संख्या कम होती है (N-1 बार), जबकि निवेशन सॉर्ट में शिफ्टिंग की संख्या अधिक हो सकती है।

 

प्रश्न 5. स्थिर और अस्थिर सॉर्टिंग के बीच क्या अन्तर है?
Answer: स्थिर (Stable) और अस्थिर (Unstable) सॉर्टिंग एल्गोरिथम के बीच का अंतर यह है कि वे समान मान वाले तत्वों के आपेक्षिक क्रम को कैसे संभालते हैं। **स्थिर सॉर्टिंग (Stable Sorting):** * **परिभाषा:** एक स्थिर सॉर्टिंग एल्गोरिथम समान मान वाले तत्वों के मूल आपेक्षिक क्रम को बनाए रखता है। यदि ऐरे में दो तत्व \('A'\) और \('B'\) का मान समान है और \('A'\) इनपुट में \('B'\) से पहले आता है, तो स्थिर सॉर्टिंग के बाद भी \('A'\) \('B'\) से पहले ही आएगा। * **महत्त्व:** यह तब महत्वपूर्ण होता है जब तत्वों में अतिरिक्त डेटा होता है, जैसे कि टुपल में, और आप उस अतिरिक्त डेटा के आधार पर उनका मूल क्रम बनाए रखना चाहते हैं। * **उदाहरण:** मर्ज सॉर्ट और निवेशन सॉर्ट स्थिर एल्गोरिथम हैं। * **उदाहरण प्रदर्शन:** * प्रारंभिक ऐरे:

* सॉर्टेड ऐरे (दोनों '26' का मूल क्रम बना हुआ है):**अस्थिर सॉर्टिंग (Unstable Sorting):** * **परिभाषा:** एक अस्थिर सॉर्टिंग एल्गोरिथम समान मान वाले तत्वों के मूल आपेक्षिक क्रम को बदल सकता है। यदि ऐरे में दो तत्व \('A'\) और \('B'\) का मान समान है और \('A'\) इनपुट में \('B'\) से पहले आता है, तो अस्थिर सॉर्टिंग के बाद \('B'\) \('A'\) से पहले आ सकता है। * **उदाहरण:** क्विकसॉर्ट और चयन सॉर्ट सामान्यतः अस्थिर एल्गोरिथम हैं। * **महत्त्व:** एल्गोरिथम की स्थिरता तब मायने रखती है जब आप मूल तत्वों का क्रम बनाए रखना चाहते हैं। सारांश में, स्थिरता यह सुनिश्चित करती है कि यदि दो आइटमों के मान समान हैं, तो सॉर्ट करने के बाद भी वे उसी क्रम में दिखाई देंगे जिस क्रम में वे मूल सूची में थे।
In simple words: स्थिर सॉर्टिंग में, एक ही मान वाली चीजें सॉर्ट करने के बाद भी अपने पहले वाले क्रम में ही रहती हैं। अस्थिर सॉर्टिंग में, वे अपना क्रम बदल सकती हैं।

🎯 Exam Tip: एक एल्गोरिथम की स्थिरता एक महत्वपूर्ण विचार है, खासकर डेटाबेस या वस्तुओं की सूची को सॉर्ट करते समय जहां मूल क्रम के कुछ पहलू महत्वपूर्ण होते हैं।

RBSE Class 12 Computer Science Chapter 3 अतिलघु उत्तरीय प्रश्न

 

प्रश्न 1. सॉर्टिंग का क्या महत्त्व है?
Answer: सॉर्टिंग का सबसे महत्वपूर्ण लाभ डेटा को खोजना और उपयोग करना आसान बनाना है। जब डेटा एक विशेष क्रम में व्यवस्थित होता है, तो किसी भी आइटम को बहुत तेज़ी से ढूंढा जा सकता है, जिससे डेटा प्रोसेसिंग की गति बढ़ जाती है और जानकारी का विश्लेषण अधिक कुशल हो जाता है।
In simple words: सॉर्टिंग हमें डेटा को आसानी से ढूंढने और उसका सही ढंग से इस्तेमाल करने में मदद करती है।

🎯 Exam Tip: सॉर्टिंग केवल खोज को ही नहीं, बल्कि डेटा विश्लेषण, रिपोर्टिंग और डेटाबेस प्रबंधन जैसे कई अन्य कार्यों को भी बेहतर बनाती है।

 

प्रश्न 2. क्या इन-प्लेस सॉर्टिंग एल्गोरिथ्म को अतिरिक्त जगह की आवश्यकता होती है?
Answer: नहीं, इन-प्लेस सॉर्टिंग एल्गोरिथ्म को डेटा को सॉर्ट करने के लिए किसी भी अतिरिक्त मेमोरी या जगह की आवश्यकता नहीं होती है। यह इनपुट ऐरे के भीतर ही सीधे तत्वों को व्यवस्थित करती है, जिससे मेमोरी की बचत होती है और यह मेमोरी-कुशल एल्गोरिथम मानी जाती है।
In simple words: नहीं, इन-प्लेस सॉर्टिंग को अतिरिक्त मेमोरी की जरूरत नहीं होती; यह सीधे उसी जगह पर डेटा को सॉर्ट करती है।

🎯 Exam Tip: इन-प्लेस एल्गोरिथम का उपयोग अक्सर उन प्रणालियों में किया जाता है जहाँ मेमोरी सीमित होती है, जैसे एम्बेडेड सिस्टम या मोबाइल डिवाइस।

 

प्रश्न 3. इन-प्लेस सॉर्टिंग का एक उदाहरण दीजिए।
Answer: बबल सॉर्ट इन-प्लेस सॉर्टिंग का एक सामान्य उदाहरण है। इसके अतिरिक्त, चयन सॉर्ट (Selection Sort) और निवेशन सॉर्ट (Insertion Sort) भी इन-प्लेस एल्गोरिथम हैं, क्योंकि वे डेटा को सॉर्ट करने के लिए अतिरिक्त मेमोरी का उपयोग नहीं करते हैं।
In simple words: बबल सॉर्ट एक इन-प्लेस सॉर्टिंग का अच्छा उदाहरण है।

🎯 Exam Tip: इन-प्लेस एल्गोरिथम के कुछ अन्य उदाहरणों में क्विकसॉर्ट (Quicksort) और हीपसॉर्ट (Heapsort) शामिल हैं।

 

प्रश्न 4. क्या बबल सॉर्ट डेटा सेट के लिए उपयुक्त है?
Answer: नहीं, बबल सॉर्ट बड़े डेटा सेट के लिए उपयुक्त नहीं है। इसकी \(O(n^2)\) की जटिलता (complexity) के कारण, जैसे-जैसे डेटा सेट का आकार बढ़ता है, सॉर्ट करने में लगने वाला समय तेजी से बढ़ता जाता है, जिससे यह बड़े डेटा के लिए बहुत धीमा और अक्षम हो जाता है।
In simple words: नहीं, बबल सॉर्ट बड़े डेटा सेट के लिए ठीक नहीं है क्योंकि यह बहुत धीरे काम करता है।

🎯 Exam Tip: बबल सॉर्ट को छोटे डेटा सेट या शैक्षिक उद्देश्यों के लिए सबसे अच्छा माना जाता है ताकि सॉर्टिंग के मूल सिद्धांतों को समझा जा सके।

 

प्रश्न 5. बबल सॉर्ट की औसत (average) और सबसे खराब स्थिति में कॉम्प्लेक्सिटी क्या है?
Answer: बबल सॉर्ट की औसत (average) और सबसे खराब स्थिति (worst case) दोनों में कॉम्प्लेक्सिटी \(O(n^2)\) है। यहाँ \(n\) सॉर्ट किए जाने वाले तत्वों की संख्या है। इसका अर्थ है कि यदि तत्वों की संख्या दोगुनी हो जाती है, तो एल्गोरिथम को लगने वाला समय लगभग चार गुना बढ़ जाएगा।
In simple words: बबल सॉर्ट में, चाहे डेटा कैसा भी हो, उसे सॉर्ट करने में लगभग हमेशा \(N^2\) के बराबर समय लगता है।

🎯 Exam Tip: बबल सॉर्ट की सबसे अच्छी स्थिति (best case) भी \(O(n^2)\) है, जब तक कि एक अनुकूलित संस्करण (optimized version) का उपयोग न किया जाए जो पहले से सॉर्टेड ऐरे की पहचान कर सके।

 

प्रश्न 7. चयन (Selection) सॉर्टिंग की औसत (average) और सबसे खराब (worst case) स्थिति में कॉम्प्लेक्सिटी क्या है?
Answer: चयन (Selection) सॉर्टिंग की औसत (average) और सबसे खराब (worst case) स्थिति दोनों में कॉम्प्लेक्सिटी \(O(n^2)\) है। यहाँ \(n\) सॉर्ट किए जाने वाले तत्वों की संख्या है। यह एल्गोरिथम हर बार सबसे छोटे तत्व को ढूंढने के लिए पूरे असॉर्ट किए गए हिस्से को स्कैन करता है, चाहे डेटा कितना भी व्यवस्थित क्यों न हो, इसलिए इसकी जटिलता हमेशा \(O(n^2)\) रहती है।
In simple words: सिलेक्शन सॉर्ट में, चाहे डेटा कैसा भी हो, उसे सॉर्ट करने में हमेशा लगभग \(N^2\) समय लगता है।

🎯 Exam Tip: सिलेक्शन सॉर्ट की जटिलता स्थिर रहती है क्योंकि यह हमेशा न्यूनतम तत्व को ढूंढने के लिए प्रत्येक पुनरावृत्ति में पूरी सूची को स्कैन करता है।

 

प्रश्न 8. निवेशन (Insertion) सॉर्टिंग क्या है?
Answer: निवेशन (Insertion) सॉर्टिंग एक इन-प्लेस तुलना-आधारित सॉर्टिंग एल्गोरिथम है। यह ऐरे को दो भागों में बांटता है: एक सॉर्टेड उप-लिस्ट और एक असॉर्टेड उप-लिस्ट। यह एक-एक करके असॉर्टेड उप-लिस्ट से तत्व लेता है और उन्हें पहले से सॉर्ट की गई उप-लिस्ट में उनकी सही स्थिति में सम्मिलित करता है।
In simple words: इंसर्शन सॉर्ट डेटा को एक-एक करके लेता है और उसे पहले से सॉर्ट की हुई सूची में सही जगह पर डालता जाता है।

🎯 Exam Tip: निवेशन सॉर्ट छोटे डेटा सेट और आंशिक रूप से सॉर्ट किए गए डेटा सेट के लिए बहुत कुशल है।

 

प्रश्न 9. निवेशन (Insertion) सॉर्टिंग की औसत और सबसे खराब (worst case) स्थिति में कॉम्प्लेक्सिटी बताइए।
Answer: निवेशन (Insertion) सॉर्टिंग की औसत (average) और सबसे खराब (worst case) स्थिति दोनों में कॉम्प्लेक्सिटी \(O(n^2)\) है। जहाँ \(n\) सॉर्ट किए जाने वाले तत्वों की संख्या है। इसकी सबसे अच्छी स्थिति \(O(n)\) होती है, जब ऐरे पहले से ही सॉर्टेड होता है।
In simple words: इंसर्शन सॉर्ट को आमतौर पर \(N^2\) समय लगता है, लेकिन अगर डेटा थोड़ा-बहुत पहले से ही सॉर्टेड हो, तो यह तेजी से काम कर सकता है।

🎯 Exam Tip: इंसर्शन सॉर्ट की \(O(n)\) की सबसे अच्छी स्थिति इसे लगभग सॉर्ट किए गए डेटा के लिए एक अच्छा विकल्प बनाती है।

 

प्रश्न 10. त्वरित (Quick) सॉर्टिंग से आप क्या समझते हैं?
Answer: त्वरित (Quick) सॉर्टिंग एक कुशल सॉर्टिंग एल्गोरिथम है जो "डिवाइड एंड कॉन्कर" सिद्धांत पर आधारित है। यह एक पाइवोट तत्व चुनकर और ऐरे को दो हिस्सों में बांटकर काम करता है: एक में पाइवोट से छोटे तत्व, और दूसरे में पाइवोट से बड़े तत्व। फिर यह खुद को इन छोटे हिस्सों पर बार-बार लागू करता है जब तक कि पूरा ऐरे सॉर्ट न हो जाए।
In simple words: क्विकसॉर्ट एक पाइवोट चुनता है, डेटा को दो हिस्सों में बांटता है (पाइवोट से छोटा और पाइवोट से बड़ा), और फिर यही काम छोटे हिस्सों पर बार-बार करता है।

🎯 Exam Tip: क्विकसॉर्ट को अक्सर सबसे तेज़ तुलना-आधारित सॉर्टिंग एल्गोरिथम माना जाता है।

 

प्रश्न 11. त्वरित (Quick) सॉर्टिंग की औसत (average) और सबसे खराब (worst case) स्थिति में कॉम्प्लेक्सिटी बताइए।
Answer: त्वरित (Quick) सॉर्टिंग की औसत (average) और सबसे खराब (worst case) स्थिति में कॉम्प्लेक्सिटी \(O(n \log n)\) है। जहाँ \(n\) सॉर्ट किए जाने वाले तत्वों की संख्या है। हालांकि, सबसे खराब स्थिति (जब पाइवोट हमेशा गलत चुना जाता है) में इसकी जटिलता \(O(n^2)\) हो सकती है, लेकिन यह दुर्लभ है।
In simple words: क्विकसॉर्ट को आमतौर पर \(N \log N\) समय लगता है, लेकिन अगर बहुत गलत पाइवोट चुना जाए, तो यह \(N^2\) समय भी ले सकता है।

🎯 Exam Tip: क्विकसॉर्ट का औसत प्रदर्शन इसे अधिकांश वास्तविक दुनिया के अनुप्रयोगों के लिए एक उत्कृष्ट विकल्प बनाता है।

RBSE Class 12 Computer Science Chapter 3 लघु उत्तरीय प्रश्न

 

प्रश्न 1. अडप्टिव और नॉन-अडप्टिव सॉर्टिंग एल्गोरिथ्म के विषय में बताइए।
Answer: सॉर्टिंग एल्गोरिथम को अडप्टिव (Adaptive) या नॉन-अडप्टिव (Non-adaptive) के रूप में वर्गीकृत किया जा सकता है, जो इस बात पर निर्भर करता है कि वे इनपुट डेटा के शुरुआती क्रम का कैसे उपयोग करते हैं। **अडप्टिव सॉर्टिंग (Adaptive Sorting):** * **परिभाषा:** एक अडप्टिव सॉर्टिंग एल्गोरिथम इनपुट डेटा में पहले से मौजूद क्रम का फायदा उठाता है। यदि डेटा आंशिक रूप से सॉर्टेड है, तो यह एल्गोरिथम तेजी से काम करता है। * **कार्यप्रणाली:** यह एल्गोरिथम डेटा के मौजूदा क्रम का पता लगाता है और कम संचालन करके समय बचाता है। * **उदाहरण:** निवेशन सॉर्ट (Insertion Sort) एक अडप्टिव एल्गोरिथम है क्योंकि यह लगभग सॉर्ट किए गए ऐरे पर \(O(n)\) समय में काम करता है। **नॉन-अडप्टिव सॉर्टिंग (Non-adaptive Sorting):** * **परिभाषा:** एक नॉन-अडप्टिव सॉर्टिंग एल्गोरिथम इनपुट डेटा के शुरुआती क्रम से प्रभावित नहीं होता है। यह हमेशा एक ही संख्या में संचालन करता है, चाहे डेटा कितना भी सॉर्टेड क्यों न हो। * **कार्यप्रणाली:** यह हमेशा सभी तत्वों को सॉर्ट करने के लिए समान प्रक्रिया का पालन करता है, जिससे इसका प्रदर्शन इनपुट क्रम पर निर्भर नहीं करता। * **उदाहरण:** चयन सॉर्ट (Selection Sort) एक नॉन-अडप्टिव एल्गोरिथम है क्योंकि यह हमेशा सभी तत्वों को स्कैन करता है, भले ही ऐरे पहले से सॉर्टेड हो। अडप्टिव एल्गोरिथम अधिक कुशल होते हैं यदि आप अक्सर लगभग सॉर्ट किए गए डेटा के साथ काम करते हैं।
In simple words: अडप्टिव सॉर्टिंग एल्गोरिथम पहले से सॉर्टेड डेटा को तेजी से सॉर्ट करते हैं, जबकि नॉन-अडप्टिव सॉर्टिंग एल्गोरिथम की गति पर डेटा के शुरुआती क्रम का कोई फर्क नहीं पड़ता।

🎯 Exam Tip: एल्गोरिथम चुनते समय, विचार करें कि आपका विशिष्ट डेटा आमतौर पर कितना सॉर्ट किया जाता है। यदि डेटा अक्सर लगभग सॉर्ट किया गया होता है, तो अडप्टिव एल्गोरिथम का चयन करें।

 

प्रश्न 2. सॉर्टिंग तकनीकों में प्रयोग होने वाली कुछ शब्दावली का संक्षिप्त परिचय दीजिए।
**अथवा**
**निम्नलिखित पर संक्षिप्त टिप्पणी लिखिए**
(i) बढ़ता क्रम
(ii) घटता क्रम
(iii) गैर-बढ़ता क्रम
(iv) गैर-घटता क्रम
Answer: सॉर्टिंग तकनीकों पर चर्चा के दौरान आमतौर पर कुछ शब्दावली का प्रयोग किया जाता है, यहाँ उनका एक संक्षिप्त परिचय है: **(i) बढ़ता क्रम (Increasing Order):** यह वह क्रम होता है जिसमें संख्याएँ या तत्व छोटे से बड़े मान की ओर बढ़ते हैं। इसमें प्रत्येक तत्व अपने से पहले वाले तत्व से बड़ा होता है। * **उदाहरण:** 1, 3, 4, 6, 8, 9 बढ़ते क्रम में है। * **विशेषता:** इस क्रम में, कोई भी तत्व अपने से पहले वाले तत्व से छोटा नहीं होता। **(ii) घटता क्रम (Decreasing Order):** यह वह क्रम होता है जिसमें संख्याएँ या तत्व बड़े से छोटे मान की ओर घटते हैं। इसमें प्रत्येक तत्व अपने से पहले वाले तत्व से छोटा होता है। * **उदाहरण:** 9, 8, 6, 4, 3, 1 घटते क्रम में है। * **विशेषता:** इस क्रम में, कोई भी तत्व अपने से पहले वाले तत्व से बड़ा नहीं होता। **(iii) गैर-बढ़ता क्रम (Non-increasing Order):** यह एक ऐसा क्रम है जहाँ संख्याएँ या तो घटती हैं या समान रहती हैं, लेकिन कभी बढ़ती नहीं हैं। इसमें प्रत्येक तत्व अपने से पहले वाले तत्व से छोटा या उसके बराबर होता है। * **उदाहरण:** 9, 8, 6, 3, 3, 1 गैर-बढ़ते क्रम में है। * **विशेषता:** यह क्रम डुप्लिकेट मानों को संभालते हुए घटते क्रम का एक अधिक सामान्य रूप है। **(iv) गैर-घटता क्रम (Non-decreasing Order):** यह एक ऐसा क्रम है जहाँ संख्याएँ या तो बढ़ती हैं या समान रहती हैं, लेकिन कभी घटती नहीं हैं। इसमें प्रत्येक तत्व अपने से पहले वाले तत्व से बड़ा या उसके बराबर होता है। * **उदाहरण:** 1, 3, 3, 6, 8, 9 गैर-घटते क्रम में है। * **विशेषता:** यह क्रम डुप्लिकेट मानों को संभालते हुए बढ़ते क्रम का एक अधिक सामान्य रूप है। ये शब्दावलियाँ डेटा को व्यवस्थित करने के विभिन्न तरीकों को स्पष्ट करने में मदद करती हैं।
In simple words: बढ़ता क्रम मतलब छोटे से बड़े की ओर, घटता क्रम मतलब बड़े से छोटे की ओर। गैर-बढ़ता क्रम मतलब या तो घटेगा या समान रहेगा, बढ़ेगा नहीं। गैर-घटता क्रम मतलब या तो बढ़ेगा या समान रहेगा, घटेगा नहीं।

🎯 Exam Tip: "बढ़ता क्रम" और "गैर-घटता क्रम" के बीच का मुख्य अंतर डुप्लिकेट मानों को संभालने में है; गैर-घटता क्रम डुप्लिकेट की अनुमति देता है जबकि बढ़ता क्रम आमतौर पर अद्वितीय मानों के लिए होता है।

 

प्रश्न 3. बबल सॉर्ट के लिए एल्गोरिथ्म लिखिए।
Answer: बबल सॉर्ट एक सरल सॉर्टिंग एल्गोरिथम है जो एक सूची के आसन्न तत्वों की बार-बार तुलना करता है और उन्हें गलत क्रम में होने पर स्वैप करता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक कोई और स्वैप आवश्यक न हो, जो इंगित करता है कि सूची पूरी तरह से सॉर्ट हो गई है। इसका नाम "बबल" है क्योंकि छोटे तत्व धीरे-धीरे 'बुलबुले' की तरह सूची के शीर्ष पर आ जाते हैं। **बबल सॉर्ट एल्गोरिथम के चरण:** 1. ऐरे के पहले तत्व से शुरुआत करें। 2. पहले तत्व की तुलना दूसरे तत्व से करें। 3. यदि पहला तत्व दूसरे से बड़ा है, तो उन्हें स्वैप करें। 4. अब दूसरे तत्व की तुलना तीसरे से करें और यदि आवश्यक हो तो स्वैप करें। 5. इस प्रक्रिया को ऐरे के अंत तक दोहराएं ताकि सबसे बड़ा तत्व अपनी अंतिम स्थिति पर पहुंच जाए। 6. पूरी ऐरे पर इस प्रक्रिया को दोहराएं, लेकिन हर बार अंतिम सॉर्ट किए गए तत्व को छोड़कर (क्योंकि वह पहले से सही जगह पर है)। 7. यह प्रक्रिया तब तक दोहराई जाती है जब तक कि किसी भी पास में कोई स्वैप न हो, जिसका अर्थ है कि ऐरे पूरी तरह से सॉर्ट हो गया है। यह एल्गोरिथम सरल है लेकिन बड़े डेटा सेट के लिए अक्षम है।
In simple words: बबल सॉर्ट में, हम बगल-बगल के नंबर्स की तुलना करते हैं और अगर वे गलत क्रम में हों तो उन्हें बदल देते हैं। यह काम बार-बार करते हैं जब तक सब कुछ सही क्रम में न आ जाए।

🎯 Exam Tip: बबल सॉर्ट की दक्षता \(O(n^2)\) है, जो इसे छोटे डेटा सेट या सीखने के उद्देश्यों के लिए उपयुक्त बनाती है।

 

प्रश्न 4. चयन (Selection) सॉर्ट के लिए एल्गोरिथ्म लिखिए।
Answer: चयन (Selection) सॉर्ट एल्गोरिथम एक इन-प्लेस तुलना-आधारित सॉर्टिंग एल्गोरिथम है। यह हर पुनरावृत्ति में सबसे छोटे तत्व को ढूंढता है और उसे ऐरे के असॉर्ट किए गए हिस्से की शुरुआत में रखता है। **चयन सॉर्ट एल्गोरिथम के चरण:** 1. **न्यूनतम सेट करें:** ऐरे के पहले तत्व को न्यूनतम मान के रूप में मानें। 2. **न्यूनतम खोजें:** ऐरे के असॉर्ट किए गए हिस्से में सबसे छोटे तत्व को ढूंढें। 3. **स्वैप करें:** इस सबसे छोटे तत्व को असॉर्ट किए गए हिस्से के पहले तत्व के साथ स्वैप करें। 4. **न्यूनतम बढ़ाएं:** अब असॉर्ट किए गए हिस्से की शुरुआत को एक स्थान आगे बढ़ाएं (यानी, सॉर्ट किया गया हिस्सा एक तत्व बड़ा हो गया है)। 5. **दोहराएं:** चरण 2 से 4 तक की प्रक्रिया को तब तक दोहराते रहें जब तक पूरा ऐरे सॉर्ट न हो जाए। यह एल्गोरिथम हर पास में एक तत्व को उसकी सही अंतिम स्थिति पर रखता है।
In simple words: सिलेक्शन सॉर्ट में, हम पहले पूरी लिस्ट में सबसे छोटा नंबर ढूंढते हैं, उसे सबसे पहली खाली जगह पर रखते हैं, और फिर बाकी बचे नंबर्स में यही काम बार-बार करते हैं।

🎯 Exam Tip: सिलेक्शन सॉर्ट की जटिलता हमेशा \(O(n^2)\) रहती है, चाहे ऐरे पहले से कितना भी सॉर्टेड क्यों न हो, क्योंकि यह हमेशा सबसे छोटे तत्व को ढूंढने के लिए पूरे असॉर्ट किए गए हिस्से को स्कैन करता है।

 

प्रश्न 5. निवेशन (Insertion) सॉर्ट के लिए एल्गोरिथ्म लिखिए।
Answer: निवेशन (Insertion) सॉर्ट एल्गोरिथम एक सरल, इन-प्लेस तुलना-आधारित सॉर्टिंग एल्गोरिथम है। यह ऐरे को दो भागों में बांटता है: एक सॉर्टेड उप-लिस्ट और एक असॉर्टेड उप-लिस्ट। यह एक-एक करके असॉर्टेड हिस्से से तत्वों को लेता है और उन्हें सॉर्ट किए गए हिस्से में उनकी सही स्थिति में सम्मिलित करता है। **निवेशन सॉर्ट एल्गोरिथम के चरण:** 1. **पहला तत्व:** यदि लिस्ट में केवल एक ही तत्व है, तो उसे सॉर्टेड माना जाता है। 2. **अगला तत्व लें:** असॉर्ट किए गए हिस्से से अगला तत्व चुनें। 3. **शिफ्ट करें:** सॉर्ट किए गए उप-लिस्ट में, चुने हुए तत्व से बड़े सभी तत्वों को एक स्थान दाईं ओर शिफ्ट करें। 4. **मान सम्मिलित करें:** चुने हुए तत्व को शिफ्ट किए गए तत्वों द्वारा बनाई गई खाली जगह में डालें। 5. **दोहराएं:** चरण 2 से 4 तक की प्रक्रिया को तब तक दोहराएं जब तक सभी तत्व सॉर्ट न हो जाएं। यह एल्गोरिथम छोटे डेटा सेट और लगभग सॉर्ट किए गए डेटा के लिए बहुत प्रभावी है।
In simple words: इंसर्शन सॉर्ट एक-एक करके नंबर्स को लेता है और उन्हें पहले से सॉर्ट की हुई लिस्ट में सही जगह पर रखता जाता है, जैसे ताश के पत्तों को जमाते हैं।

🎯 Exam Tip: निवेशन सॉर्ट की सबसे अच्छी स्थिति \(O(n)\) होती है जब ऐरे पहले से सॉर्टेड होता है, क्योंकि इसमें बहुत कम शिफ्टिंग होती है।

 

प्रश्न 6. त्वरित सॉर्ट के लिए एल्गोरिथ्म लिखिए।
Answer: त्वरित सॉर्ट (Quick Sort) एल्गोरिथम एक कुशल, डिवाइड एंड कॉन्कर सॉर्टिंग एल्गोरिथम है। यह एक पाइवोट तत्व चुनकर और ऐरे को दो उप-ऐरे में विभाजित करके काम करता है: एक में पाइवोट से छोटे तत्व, और दूसरे में पाइवोट से बड़े तत्व। फिर यह खुद को इन छोटे हिस्सों पर बार-बार लागू करता है जब तक कि पूरा ऐरे सॉर्ट न हो जाए। **त्वरित सॉर्ट एल्गोरिथम के चरण:** 1. **पाइवोट चुनें:** ऐरे के सबसे दाहिने सूचकांक मान को पाइवोट के रूप में चुनें (या किसी अन्य रणनीति का उपयोग करें)। 2. **ऐरे का विभाजन करें:** पाइवोट मान का उपयोग करके ऐरे को दो उप-ऐरे में विभाजित करें: पाइवोट से छोटे तत्व बाईं ओर, पाइवोट से बड़े तत्व दाईं ओर। पाइवोट अपनी अंतिम सॉर्टेड स्थिति में होगा। 3. **रिकर्सिवली बाएँ विभाजन पर सॉर्ट लगाएं:** पाइवोट के बाईं ओर के उप-ऐरे पर त्वरित सॉर्ट को पुनरावर्ती रूप से लागू करें। 4. **रिकर्सिवली दाएँ विभाजन पर सॉर्ट लगाएं:** पाइवोट के दाईं ओर के उप-ऐरे पर त्वरित सॉर्ट को पुनरावर्ती रूप से लागू करें। यह प्रक्रिया तब तक जारी रहती है जब तक सभी उप-ऐरे सॉर्ट न हो जाएं।
In simple words: क्विकसॉर्ट एक खास नंबर (पाइवोट) चुनता है। फिर लिस्ट को दो हिस्सों में बांटता है - एक में पाइवोट से छोटे नंबर और दूसरे में बड़े नंबर। फिर यही काम छोटे हिस्सों पर बार-बार करता है जब तक सब कुछ क्रम में न आ जाए।

🎯 Exam Tip: पाइवोट का प्रभावी चयन क्विकसॉर्ट के प्रदर्शन के लिए महत्वपूर्ण है। खराब पाइवोट के चयन से एल्गोरिथम की जटिलता \(O(n^2)\) हो सकती है।

 

Question 2. बबल सॉर्ट के द्वारा ऐरे के तत्त्वों को सॉर्ट करने का C प्रोग्राम लिखिए।
Answer: बबल सॉर्ट एल्गोरिथम के लिए C प्रोग्राम यहाँ दिया गया है, जो ऐरे के तत्वों को व्यवस्थित करने में मदद करता है। यह प्रोग्राम संख्याओं की एक लिस्ट को आरोही क्रम में सॉर्ट करता है।
#include<stdio.h>
#include<stdbool.h>
#define MAX 10
int list [MAX] = {1, 8, 4, 6, 0, 3, 5, 2, 7, 9};
void display ()
{
printf("[");
int i;
for(i = 0; i < MAX; i++)
{
printf("%d ", list[i]);
}
printf("]\n");
}

void bubbleSort ()
{
int temp;
int i, j;
bool swapped = false;

// loop through all numbers
for (i = 0; i < MAX-1; i++)
{
swapped = false;

// loop through numbers falling ahead
for (j = 0; j < MAX-1-i; j++)
{
printf("Items compared: [%d,%d]", list[j],list[j+1]);
// check if next number is lesser than current number
// swap the numbers.
// (Bubble up the highest number)
if (list[j]>list[j+1])
{
temp=list[j];
list[j]=list[j+1];
list[j+1]=temp;
swapped=true;
printf("=> swapped [%d,%d]\n", list[j], list[j+1]);
}
else
{
printf ("=>not swapped\n");
}
}

//if no number was swapped that means
// array is sorted now, break the loop.
if(!swapped)
{
break;
}
}
}

int main()
{
printf("Input Array:");
display();
printf("\n");
bubbleSort();
printf ("\nOutput Array:");
display();
return 0;
}

जब उपरोक्त कोड कम्पाइल और रन होगा तो आउटपुट निम्नानुसार होगाः
Input Array: [1 8 4 6 0 3 5 2 7 9 ]
Items compared: [1,8]=> not swapped
Items compared: [8,4]=> swapped [4,8]
Items compared: [8,6]=> swapped [6,8]
Items compared: [8,0]=> swapped [0,8]
Items compared: [8,3]=> swapped [3,8]
Items compared: [8,5]=> swapped [5,8]
Items compared: [8,2]=> swapped [2,8]
Items compared: [8,7]=> swapped [7,8]
Items compared: [8,9]=> not swapped
Iteration 1 #: [1 4 6 0 3 5 2 7 8 9 ]
Items compared: [1,4]=> not swapped
Items compared: [4,6]=> not swapped
Items compared: [6,0]=> swapped [0,6]
Items compared: [6,3]=> swapped [3,6]
Items compared: [6,5]=> swapped [5,6]
Items compared: [6,2]=> swapped [2,6]
Items compared: [6,7]=> not swapped
Items compared: [7,8]=> not swapped
Items compared: [6,7]=> not swapped
Iteration 3 #: [0 1 3 4 2 5 6 7 8 9 ]
Items compared: [1,0]=> swapped [0,1]
Items compared: [1,3]=> not swapped
Items compared: [3,4]=> not swapped
Items compared: [4,2]=> swapped [2,4]
Items compared: [4,5]=> not swapped
Items compared: [5,6]=> not swapped
Iteration 4 #: [0 1 2 3 4 5 6 7 8 9 ]
Items compared: [0,1]=> not swapped
Items compared: [1,3]=> not swapped
Items compared:[3,2]=> swapped [2,3]
Items compared: [3,4]=> not swapped
Items compared: [4,5]=> not swapped
Iteration 5 #: [0 1 2 3 4 5 6 7 8 9 ]
Items compared: [0,1]=> not swapped
Items compared: [1,2]=> not swapped
Items compared: [2,3]=> not swapped
Items compared: [3,4]=> not swapped
Output Array: [0 1 2 3 4 5 6 7 8 9 ]
In simple words: यह कोड बबल सॉर्ट नामक तरीके का उपयोग करके संख्याओं की लिस्ट को छोटे से बड़े क्रम में व्यवस्थित करता है। यह बार-बार पास होकर पास-पास के नंबरों की तुलना करता है और उन्हें सही क्रम में रखता है।

🎯 Exam Tip: C प्रोग्राम लिखते समय, हर फंक्शन के काम को छोटे-छोटे कमेंट्स में समझाएँ और मुख्य लॉजिक को स्पष्ट रखें।

 

Question 3. चयन सॉर्ट द्वारा ऐरे के तत्त्वों को सॉर्ट करने का C प्रोग्राम लिखिए।
Answer: यहाँ चयन सॉर्ट एल्गोरिथम के लिए एक C प्रोग्राम है, जो दी गई ऐरे को आरोही क्रम में सॉर्ट करता है। यह प्रत्येक पास में सबसे छोटे तत्व को ढूंढता है और उसे सही स्थिति में रखता है।
#include<stdio.h>
#include<stdbool.h>
#define MAX 7
int intArray [MAX] = {4, 6, 3, 2, 1, 9, 7};

void display()
{
printf("[");
int i;
for(i=0; i<MAX; i++)
{
printf("%d ", intArray[i]);
}
printf("]\n");
}

void selectionSort()
{
int indexMin, i, j;

//loop through all numbers
for (i=0;i<MAX-1; i++)
{
// set current element as minimum
indexMin =i;

// check the element to be minimum
for(j=i+1;j<MAX; j++)
{
if(intArray[j] < intArray[indexMin])
{
indexMin=j;
}
}
if(indexMin !=i)
{
int temp = intArray[indexMin];
intArray[indexMin] = intArray[i];
intArray[i] = temp;
printf("Item swapped: [%d,%d]\n", intArray[indexMin], intArray[i]);
}
printf("Iteration %d#: ", (i+1));
display();
}
}

int main()
{
printf("Input Array:");
display();
printf("\n");
selectionSort();
printf ("\nOutput Array:");
display();
return 0;
}

जब उपरोक्त कोड कम्पाइल और रन होगा तो आउटपुट निम्नानुसार होगाः
Input Array: [4 6 3 2 1 9 7 ]
Item swapped: [4,1]
Iteration 1#: [1 6 3 2 4 9 7 ]
Item swapped: [6,2]
Iteration 2#: [1 2 3 6 4 9 7 ]
Item swapped: [6,4]
Iteration 3#: [1 2 3 4 6 9 7 ]
Item swapped: [9,7]
Iteration 4#: [1 2 3 4 6 7 9 ]
Output Array: [1 2 3 4 6 7 9 ]
In simple words: यह प्रोग्राम चयन सॉर्ट का उपयोग करता है। यह हर बार लिस्ट में सबसे छोटे नंबर को ढूंढता है और उसे सही जगह पर रखता है। यह प्रक्रिया तब तक चलती है जब तक पूरी लिस्ट सॉर्ट नहीं हो जाती।

🎯 Exam Tip: चयन सॉर्ट के लिए, हमेशा मिनिमम तत्व को ढूंढने और वर्तमान स्थिति के साथ स्वैप करने के लॉजिक पर ध्यान दें।

 

Question 4. मर्ज सॉर्ट द्वारा ऐरे के तत्त्वों को सॉर्ट करने का C प्रोग्राम लिखिए।
Answer: मर्ज सॉर्ट एल्गोरिथम के लिए एक C प्रोग्राम यहाँ दिया गया है, जो 'डिवाइड एंड कॉन्कर' विधि का उपयोग करके ऐरे के तत्वों को सॉर्ट करता है। यह लिस्ट को छोटे-छोटे टुकड़ों में विभाजित करता है, उन्हें सॉर्ट करता है, और फिर उन्हें एक साथ मर्ज करता है।
#include<stdio.h>
#define MAX 10
int a[MAX] = {14, 33, 27, 10, 35, 19, 42, 44, 5, 1}; // Sample unsorted array
int b[MAX]; // Temporary array for merging

void merging (int low, int mid, int high)
{
int l1, l2, i;
for (l1 = low, l2 = mid + 1, i = low; l1 <= mid && l2 <= high; i++)
{
if(a[l1] <= a[l2])
b[i] = a[l1++];
else
b[i] = a[l2++];
}
while (l1 <= mid)
b[i++] = a[l1++];
while (l2 <= high)
b[i++] = a[l2++];
for (i = low; i <= high; i++)
a[i] = b[i];
}

void sort (int low, int high)
{
int mid;
if (low < high)
{
mid = (low + high)/2;
sort (low, mid);
sort (mid + 1, high);
merging (low, mid, high);
}
else
{
return;
}
}

void display()
{
int i;
printf("[");
for(i = 0; i < MAX; i++)
{
printf("%d ", a[i]);
}
printf("]\n");
}

int main()
{
printf("List before sorting: ");
display();
sort(0, MAX - 1);
printf("List after sorting: ");
display();
return 0;
}

जब उपरोक्त कोड कम्पाइल और रन होगा तो आउटपुट निम्नानुसार होगाः
List before sorting: [14 33 27 10 35 19 42 44 5 1 ]
List after sorting: [1 5 10 14 19 27 33 35 42 44 ]
In simple words: यह कोड मर्ज सॉर्ट तकनीक का उपयोग करता है, जो ऐरे को छोटे हिस्सों में बांटता है, उन्हें अलग-अलग सॉर्ट करता है, और फिर उन्हें वापस जोड़कर एक बड़ी सॉर्टेड लिस्ट बनाता है।

🎯 Exam Tip: मर्ज सॉर्ट में 'डिवाइड एंड कॉन्कर' सिद्धांत को समझना महत्वपूर्ण है, जहाँ प्रॉब्लम को छोटे हिस्सों में तोड़कर हल किया जाता है और फिर परिणाम को जोड़ा जाता है।

 

Question 5. निवेशन (Insertion) सॉर्ट द्वारा ऐरे के तत्त्वों को सॉर्ट करने का C प्रोग्राम लिखिए।
Answer: यहाँ निवेशन सॉर्ट एल्गोरिथम के लिए एक C प्रोग्राम है, जो ऐरे के तत्वों को आरोही क्रम में सॉर्ट करता है। यह एल्गोरिथम एक-एक तत्व को लेता है और उसे सॉर्टेड उप-लिस्ट में सही जगह पर सम्मिलित करता है।
#include <stdio.h>
#define MAX 7
int intArray [MAX] = {4, 6, 3, 2, 1, 9, 7};

void display()
{
int i;
printf("[");
for(i=0; i<MAX; i++)
{
printf("%d ", intArray[i]);
}
printf("]\n");
}

void insertionSort()
{
int valueToInsert;
int holePosition;
int i;

// loop through all numbers
for(i=1; i < MAX; i++)
{
// select a value to be inserted.
valueToInsert = intArray[i];
// select the hole position where number is to be inserted
holePosition = i;

// check if previous no. is larger than value to be inserted
while (holePosition > 0 && intArray[holePosition-1] > valueToInsert)
{
intArray[holePosition] = intArray[holePosition-1];
printf("Item moved: %d\n", intArray[holePosition]);
holePosition--;
}
if (holePosition != i)
{
printf("Item inserted: %d, at position: %d\n", valueToInsert, holePosition);
// insert the number at hole position
intArray[holePosition] = valueToInsert;
}
printf ("Iteration %d#: ", i);
display();
}
}

int main()
{
printf("Input Array:");
display();
printf("\n");
insertionSort();
printf ("\nOutput Array:");
display();
return 0;
}

जब उपरोक्त कोड कम्पाइल और रन होगा तो आउटपुट निम्नानुसार होगाः
Input Array: [4 6 3 2 1 9 7 ]
Item moved: 6
Item moved: 4
Item inserted: 3, at position: 0
Iteration 1#: [3 4 6 2 1 9 7 ]
Item moved: 6
Item moved: 4
Item moved: 3
Item inserted: 2, at position: 0
Iteration 2#: [2 3 4 6 1 9 7 ]
Item moved: 6
Item moved: 4
Item moved: 3
Item moved: 2
Item inserted: 1, at position: 0
Iteration 3#: [1 2 3 4 6 9 7 ]
Item moved: 9
Item inserted: 7, at position: 5
Iteration 5#: [1 2 3 4 6 7 9 ]
Output Array: [1 2 3 4 6 7 9 ]
In simple words: यह कोड इन्सर्शन सॉर्ट का इस्तेमाल करता है। यह लिस्ट के हर आइटम को बारी-बारी से उठाता है और उसे पहले से सॉर्ट किए गए हिस्से में सही जगह पर डालता है।

🎯 Exam Tip: इन्सर्शन सॉर्ट में, एक तत्व को सॉर्टेड उप-लिस्ट में सही स्थान पर "शिफ्ट" करने की प्रक्रिया पर ध्यान दें।

 

Question 6. त्वरित (Quick) सॉर्ट द्वारा ऐरे के तत्त्वों को सॉर्ट करने का C प्रोग्राम लिखिए।
Answer: त्वरित सॉर्ट एल्गोरिथम के लिए एक C प्रोग्राम यहाँ दिया गया है, जो 'डिवाइड एंड कॉन्कर' विधि का उपयोग करके ऐरे के तत्वों को सॉर्ट करता है। यह एक 'पाइवोट' तत्व चुनता है और ऐरे को दो उप-ऐरे में विभाजित करता है।
#include <stdio.h>
#define MAX 10
int intArray[MAX] = {1, 8, 4, 6, 0, 3, 5, 2, 7, 9};

void display()
{
int i;
printf("[");
for(i = 0; i < MAX; i++)
{
printf("%d ", intArray[i]);
}
printf("]\n");
}

void swap (int num1, int num2)
{
int temp = intArray[num1];
intArray[num1] = intArray[num2];
intArray[num2] = temp;
}

int partition (int left, int right, int pivot)
{
int leftPointer = left - 1;
int rightPointer = right;

while (1)
{
while (intArray[++leftPointer] < pivot)
{
//do nothing
}

while (rightPointer > 0 && intArray[--rightPointer] > pivot)
{
//do nothing
}

if (leftPointer >= rightPointer)
{
break;
}
else
{
printf("Item swapped : [%d,%d]\n", intArray[leftPointer], intArray[rightPointer]);
swap(leftPointer, rightPointer);
printf ("Updated Array: ");
display();
}
}
printf("Pivot swapped : [%d,%d]\n", intArray[leftPointer], intArray[right]);
swap(leftPointer,right);
printf("Updated Array: ");
display();
return leftPointer;
}

void quickSort (int left, int right)
{
if (right - left <= 0)
{
return;
}
else
{
int pivot = intArray[right];
int partitionPoint = partition(left, right, pivot);
quickSort(left,partitionPoint-1);
quickSort(partitionPoint+1,right);
}
}

int main()
{
printf("Input Array:");
display();
printf("\n");
quickSort(0,MAX-1);
printf ("\nOutput Array:");
display();
return 0;
}

जब उपरोक्त कोड कम्पाइल और रन होगा तो आउटपुट निम्नानुसार होगाः
Input Array: [1 8 4 6 0 3 5 2 7 9 ]
Item swapped : [8,0]
Updated Array: [1 0 4 6 8 3 5 2 7 9 ]
Item swapped : [8,3]
Updated Array: [1 0 4 6 3 8 5 2 7 9 ]
Item swapped : [8,2]
Updated Array: [1 0 4 6 3 2 8 5 7 9 ]
Item swapped : [8,5]
Updated Array: [1 0 4 6 3 2 5 8 7 9 ]
Item swapped : [8,7]
Updated Array: [1 0 4 6 3 2 5 7 8 9 ]
Pivot swapped : [9,8]
Updated Array: [1 0 4 6 3 2 5 7 8 9 ]
Item swapped : [6,0]
Updated Array: [1 0 4 6 3 2 5 7 8 9 ]
Pivot swapped : [1,0]
Updated Array: [0 1 4 6 3 2 5 7 8 9 ]
Item swapped : [4,3]
Updated Array: [0 1 3 6 4 2 5 7 8 9 ]
Item swapped : [4,2]
Updated Array: [0 1 3 2 4 6 5 7 8 9 ]
Pivot swapped : [5,4]
Updated Array: [0 1 3 2 4 6 5 7 8 9 ]
Pivot swapped : [2,3]
Updated Array: [0 1 2 3 4 6 5 7 8 9 ]
Pivot swapped : [5,6]
Updated Array: [0 1 2 3 4 5 6 7 8 9 ]
Output Array: [0 1 2 3 4 5 6 7 8 9 ]
In simple words: यह प्रोग्राम क्विक सॉर्ट का उपयोग करता है। यह लिस्ट में एक ख़ास नंबर (पाइवोट) चुनता है और बाकी नंबर्स को उससे छोटे या बड़े हिस्सों में बांट देता है। फिर यही प्रक्रिया छोटे हिस्सों पर दोबारा चलती है जब तक सब सॉर्ट न हो जाए।

🎯 Exam Tip: क्विक सॉर्ट के प्रदर्शन के लिए पाइवोट का सही चुनाव महत्वपूर्ण है। हमेशा एक ऐसे पाइवोट को चुनें जो लिस्ट को लगभग बराबर हिस्सों में बांट सके।

The provided content from pages 29-31 consists entirely of website navigation elements, SEO titles, and footer links (like "RECENT POSTS", "RBSE Solutions for Class X", "Search the site..."). According to the content processing rules, these types of elements should be ignored and skipped as they do not constitute educational question-answer content. Therefore, there is no content to convert to HTML for the specified page range.