या लेखात आम्ही तुम्हाला काही दाखवणार आहोत व्यावहारिक उदाहरणेवर AWK कसे वापरावे.

परिचय

AWK चे नाव त्याच्या लेखकांच्या नावावर ठेवले आहे: अल्फ्रेड अहो, पीटर वेनबर्गर आणि ब्रायन केर्निघन. AWK खूप आहे उपयोगी भाषामजकूर प्रक्रियेसाठी स्क्रिप्ट. ही भाषा दुभाष्यामध्ये चालते. हे वापरकर्त्याला काही इनपुट प्रक्रिया करण्यास, व्हेरिएबल्स परिभाषित करण्यास, वापरण्यास अनुमती देते तार्किक ऑपरेटर, तार आणि संख्यात्मक कार्ये, डेटा काढा आणि स्वरूपित अहवाल तयार करा. AWK ची वाक्यरचना सी भाषेसारखी आहे आणि ती पर्लचा थेट पूर्ववर्ती आहे. सर्व AWK स्क्रिप्ट्स A2P युटिलिटी वापरून पर्ल स्क्रिप्टमध्ये रूपांतरित केल्या जाऊ शकतात.

पूर्वतयारी

AWK दुभाषी आहे मानक साधन, प्रत्येक Linux वितरणावर आढळते. Gawk पॅकेजमध्ये AWK ची मुक्त-स्रोत आवृत्ती आहे मूळ सांकेतिक शब्दकोश, आणि अवलंबून लिनक्स वितरणपासून स्थापित केले जाऊ शकते स्रोत फाइलकिंवा तुमच्या विशिष्ट Linux वितरणासह समाविष्ट gawk किंवा mawk पॅकेजेस वापरणे.

स्थापना

सुपरयूजर अधिकारांसह

Ssh root@IP_Address

युटिलिटी स्थापित करण्यासाठी कमांड लाइन/Fedora किंवा इतर कोणत्याही RPM-आधारित Linux वितरणावर AWK, खालील आदेश चालवा:

यम इन्स्टॉल गॉक

/ मध्ये, तुम्हाला Gawk स्थापित करण्यासाठी या कमांडला कॉल करणे आवश्यक आहे:

Apt-get install gawk

AWK कमांड उदाहरणे

कमांड लाइनवरून सोप्या awk कमांड्स सहज चालवता येतात, परंतु अधिक क्लिष्ट कामांसाठी फाईलमध्ये awk स्क्रिप्ट म्हणून लिहिल्या पाहिजेत. खाली सूचीबद्ध काही आहेत उपयुक्त उदाहरणे awk आदेश आणि एक्झिक्युटेबल स्क्रिप्ट.

आपण वापरू शकता AWK संघइनपुट फील्डमधून फक्त ठराविक स्तंभ मुद्रित करण्यासाठी. उदाहरणार्थ, खालील आदेश वापरून तुम्ही सर्व्हरशी कनेक्ट केलेल्या IP पत्त्यांची सूची शोधू शकता:

Netstat -anp|grep tcp|awk "($5 प्रिंट)"| cut -d:-f1 | क्रमवारी लावा | uniq -c | क्रमवारी -n

तुमचा सर्व्हर खाली आहे की नाही हे तुम्ही तपासत असाल तर हे खूप उपयुक्त आहे DoS हल्लाकिंवा DDoS.

IN खालील उदाहरणआम्ही शोधासाठी AWK वापरतो विशिष्ट टेम्पलेटठराविक स्तंभांमध्ये आणि परिणामावर आधारित काही क्रिया करा:

एक्झिम -bpr | grep गोठवले | awk("$3 छापा") | xargs exim -श्रीमती

वरील आदेश सर्व गोठलेले संदेश हटवेल ईमेलएक्झिम मेल रांगेतून.

AWK सहसा उपयुक्त कार्य करण्यासाठी वापरले जाते आणि व्यावहारिक प्रक्रियाआणि मजकूर हाताळणी. उदाहरणार्थ, मधील डुप्लिकेट काढण्यासाठी आम्ही AWK वापरू शकतो मजकूर फाइलक्रमवारी न लावता:

Awk "!x[$0]++" फाइल-डुप्लिकेटसह-नवीन-फाइल-विना-डुप्लिकेट

पुढील आदेशपाच मुद्रित करेल यादृच्छिक संख्या 0 ते 999 पर्यंत:

Awk "BEGIN ( साठी (i = 1; i<= 5; i++) print int(1000 * rand()) }"

"sample_file" नावाच्या फाईलमधील ओळींची संख्या मोजण्यासाठी खालील आदेश वापरा:

Awk "END ( प्रिंट NR )" नमुना_फाइल

खालील कमांड फाइल "sample_file" मधील सर्व ओळी मुद्रित करेल ज्यात 'A' किंवा 'a' ने सुरू होणाऱ्या ओळी आहेत आणि त्यानंतर 're':

Awk "/re/(प्रिंट)" /opt/sample_file

तुम्ही अधिक जटिल ऑपरेशन्ससाठी AWK कमांड वापरू शकता. जर तुमची वेबसाइट खूपच हळू चालत असेल, तर तुम्ही I/O डिस्क (आणि/किंवा नेटवर्क, काही दुर्मिळ प्रकरणांमध्ये) मध्ये काही समस्या आहे का हे तपासण्यासाठी खालील आदेश वापरू शकता:

Tac /proc/stat | awk "/^btime/ (up=systime()-$2;print "up " up/86400 "d"); /^cpu / (मुद्रित करा "वापरकर्ता " $2/up "%, छान "$3/up "%, sys " $4/up "%, निष्क्रिय " $5/up "%, iowait " $6/up "%, चोरी "$9/up" %\niowait/वापरले "$6 / ($2+$3+$4)", चोरी/वापरलेले "$9 / ($2+$3+$4))"

IOWAIT म्हणजे I/O, प्रामुख्याने डिस्क स्टोरेज किंवा कदाचित नेटवर्कमध्ये व्यस्त असताना किती काळ प्रक्रिया अवरोधित केल्या जातात. STEAL म्हणजे CPU द्वारे सर्व्हरवर किती काळ प्रक्रिया अवरोधित केली जाते. वरील आयओवेट वापरकर्त्याच्या CPU वेळेसाठी (=USER + NICE + SYSTEM) व्यस्त I/O दर्शविते, वर पाहिलेले चोरी व्यस्त CPU दाखवते.

खालील स्क्रिप्ट एक साधी awk कमांड वापरते जी इनपुट फाइल '/etc/passwd' शोधते आणि शेवटच्या लॉगिनची तारीख आणि वेळ त्यानंतर वापरकर्तानावासह आउटपुट प्रदान करते:

`awk -F: "($1 प्रिंट करा)" /etc/passwd` do echo -n "$user: " finger $user मधील वापरकर्त्यासाठी #!/bin/bash लॉगिन-चेक करा | grep शेवटचे जर [ $? != 0]; नंतर echo fi पूर्ण झाले

स्क्रिप्ट एक्झिक्युटेबल बनवा:

Chmod 755 लॉगिन-चेक

स्क्रिप्ट कार्यान्वित करा:

./login-check

तुम्ही सर्व्हरवर उपलब्ध वापरकर्ता खाती आणि नंतर प्रत्येक वापरकर्त्याच्या शेवटच्या लॉगिनची तारीख आणि वेळ पाहण्यास सक्षम असाल.

निष्कर्ष

पर्ल आणि पायथन सारख्या काही नवीन भाषा आहेत ज्या AWK ऐवजी वापरल्या जाऊ शकतात, परंतु AWK वापरण्याचे अनेक फायदे आहेत:

• AWK ओळखणे खूप सोपे आहे.
• AWK चा वापर विशिष्ट प्रकारच्या समस्या जलद सोडवण्यासाठी आणि इतर साधने/भाषा वापरण्यापेक्षा अधिक कार्यक्षम स्क्रिप्ट तयार करण्यासाठी केला जाऊ शकतो.
• लॉग इत्यादी मोठ्या फाइल्ससह काम करताना AWK खूप उपयुक्त आहे कारण AWK कमांड/स्क्रिप्टच्या मदतीने तुम्ही फिल्टर केलेला आणि वाचण्यायोग्य अहवाल तयार करू शकता.

हा लेख ॲरे सॉर्टिंग अल्गोरिदमची चर्चा करतो. सुरुवातीला, चाचणीसाठी निवडलेले अल्गोरिदम त्यांच्या ऑपरेशनच्या संक्षिप्त वर्णनासह सादर केले जातात, त्यानंतर चाचणी थेट केली जाते, ज्याचे परिणाम टेबलमध्ये प्रविष्ट केले जातात आणि अंतिम निष्कर्ष काढले जातात.

सॉर्टिंग अल्गोरिदम प्रोग्रामिंगमध्ये मोठ्या प्रमाणावर वापरले जातात, परंतु काहीवेळा प्रोग्रामर कोणते अल्गोरिदम सर्वोत्कृष्ट कार्य करते याचा विचार देखील करत नाहीत ("सर्वोत्तम" या शब्दाचा अर्थ लेखन आणि अंमलबजावणी या दोन्हीची गती आणि जटिलता आहे).

या लेखात आपण हे जाणून घेण्याचा प्रयत्न करू. सर्वोत्तम परिणाम सुनिश्चित करण्यासाठी, सर्व सादर केलेले अल्गोरिदम 200 घटकांच्या पूर्णांक ॲरेची क्रमवारी लावतील. ज्या संगणकावर चाचणी केली जाईल त्याची खालील वैशिष्ट्ये आहेत: AMD A6-3400M 4x1.4 GHz प्रोसेसर, 8 GB RAM, Windows 10 x64 बिल्ड 10586.36 ऑपरेटिंग सिस्टम.

अभ्यासासाठी खालील क्रमवारी अल्गोरिदम निवडले गेले:

निवड क्रमवारी- अल्गोरिदमचे सार म्हणजे ॲरेला सुरुवातीपासून शेवटपर्यंत ट्रॅव्हर्स करणे, ॲरेचा किमान घटक शोधणे आणि त्यास सुरुवातीस हलवणे. अशा अल्गोरिदमची जटिलता O(n2) आहे.

बबल क्रमवारी- जर ॲरेचा पहिला घटक दुसऱ्यापेक्षा मोठा असेल तर हा अल्गोरिदम दोन समीप घटक स्वॅप करतो. अल्गोरिदम सर्व क्रमबद्ध न केलेले घटक स्वॅप करेपर्यंत हे चालू राहते. या वर्गीकरण अल्गोरिदमची जटिलता O(n^2) आहे.

घालण्याची क्रमवारी- अल्गोरिदम त्याच्या घटकांमधून जात असताना ॲरेची क्रमवारी लावते. प्रत्येक पुनरावृत्तीवर, एक घटक घेतला जातो आणि ॲरेच्या आधीपासून क्रमवारी लावलेल्या भागातील प्रत्येक घटकाशी तुलना केली जाते, अशा प्रकारे "त्याचे स्थान" शोधले जाते, ज्यानंतर घटक त्याच्या स्थितीत घातला जातो. अल्गोरिदम संपूर्ण ॲरेमधून जाईपर्यंत हे घडते. आउटपुट एक क्रमबद्ध ॲरे आहे. या अल्गोरिदमची जटिलता O(n^2) आहे.

द्रुत क्रमवारी- अल्गोरिदमचे सार ॲरेला दोन सब-ॲरेमध्ये विभाजित करणे आहे, मधली ओळ ॲरेच्या अगदी मध्यभागी असलेला घटक आहे. अल्गोरिदमच्या ऑपरेशन दरम्यान, सरासरीपेक्षा लहान घटक डावीकडे आणि मोठे घटक उजवीकडे हलविले जातील. समान क्रिया उप-ॲरेसह पुनरावृत्ती होईल; विभाजित करण्यासाठी काहीही नसल्याशिवाय ते आणखी दोन उप-ॲरेमध्ये विभागले जातील (एक घटक शिल्लक आहे). आउटपुट एक क्रमबद्ध ॲरे आहे. अल्गोरिदमची जटिलता इनपुट डेटावर अवलंबून असते आणि सर्वोत्तम बाबतीत O(n×2log2n) च्या समान असेल. सर्वात वाईट केस O(n^2). एक सरासरी देखील आहे, जी O(n×log2n) आहे.

कंगवा क्रमवारी- अल्गोरिदम कसे कार्य करते याची कल्पना एक्सचेंज क्रमवारी सारखीच आहे, परंतु मुख्य फरक असा आहे की ते दोन समीप घटक नसतात ज्यांची तुलना केली जाते, परंतु पाच घटकांच्या अंतरातील घटक असतात. हे सुनिश्चित करते की लहान मूल्ये शेवटी टाकून दिली जात नाहीत, जे मोठ्या ॲरेवर क्रमवारी वाढविण्यात मदत करते. प्रथम पुनरावृत्ती सूत्र (ॲरे आकार)/(कपात घटक) द्वारे गणना केलेल्या वाढीमध्ये केली जाते, जेथे कपात घटक अंदाजे 1.247330950103979 किंवा 1.3 पर्यंत पूर्ण केला जातो. दुसरी आणि त्यानंतरची पुनरावृत्ती स्टेप (वर्तमान पायरी)/(कपात घटक) सह पुढे जातील आणि पायरी एक समान होईपर्यंत सुरू राहील. जवळजवळ कोणत्याही परिस्थितीत, अल्गोरिदमची जटिलता O(n×log2n) असते.

चाचणी पार पाडण्यासाठी, प्रत्येक अल्गोरिदमच्या 5 धावा केल्या जातील आणि सर्वोत्तम वेळ निवडला जाईल. सर्वोत्तम वेळ आणि वापरलेली मेमरी टेबलमध्ये प्रविष्ट केली जाईल. विशिष्ट अल्गोरिदम कोणत्या कार्यांसाठी आहे हे निर्धारित करण्यासाठी आम्ही 10, 50, 200 आणि 1000 घटकांच्या क्रमवारी लावण्याच्या गतीची चाचणी करू.

पूर्णपणे क्रमबद्ध न केलेला ॲरे:

अंशतः क्रमवारी लावलेले ॲरे (अर्धे घटक क्रमवारी लावलेले आहेत):

आलेखांमध्ये प्रदान केलेले परिणाम:

संशोधन आणि प्राप्त डेटाच्या परिणामी, क्रमवारी न लावलेल्या ॲरेची क्रमवारी लावण्यासाठी, ॲरेची क्रमवारी लावण्यासाठी सादर केलेल्या अल्गोरिदमपैकी सर्वात इष्टतम म्हणजे द्रुत क्रमवारी. दीर्घ अंमलबजावणी वेळ असूनही, अल्गोरिदम कमी मेमरी वापरतो, जे मोठ्या प्रकल्पांमध्ये महत्त्वपूर्ण असू शकते. तथापि, निवड, देवाणघेवाण आणि अंतर्भूत क्रमवारी यांसारखे अल्गोरिदम वैज्ञानिक हेतूंसाठी अधिक योग्य असू शकतात, जसे की शिक्षण, जेथे मोठ्या प्रमाणात डेटावर प्रक्रिया करणे आवश्यक नसते. अंशतः क्रमवारी लावलेल्या ॲरेसह, सर्व क्रमवारी अल्गोरिदम 2-3 मिलिसेकंद कमी वेळ दर्शवतात; तथापि, अंशतः क्रमवारी लावलेल्या ॲरेची क्रमवारी लावताना, क्विकसॉर्ट खूप जलद होते आणि कमी मेमरी वापरते.

कोड सुलभ करण्यासाठी आणि वाचनीयता सुधारण्यासाठी, आम्ही स्वॅप पद्धत सादर करू, जी अनुक्रमणिकेनुसार ॲरेमधील मूल्ये स्वॅप करेल.

व्हॉइड स्वॅप(टी आयटम, इंट डावे, इंट उजवे) ( जर (डावीकडे != उजवीकडे) ( टी temp = आयटम; आयटम = आयटम; आयटम = temp; ))

बबल क्रमवारी

बबल सॉर्ट हा सर्वात सोपा सॉर्टिंग अल्गोरिदम आहे. हे ॲरेमधून अनेक वेळा लूप करते, प्रत्येक पायरीवर सर्वात मोठे अनक्रमित मूल्य ॲरेच्या शेवटी हलवते.

उदाहरणार्थ, आमच्याकडे पूर्णांकांची ॲरे आहे:

पहिल्यांदा जेव्हा आपण ॲरेमधून जातो, तेव्हा आपण 3 आणि 7 मूल्यांची तुलना करतो. 7 हे 3 पेक्षा मोठे असल्याने, आपण त्यांना जसेच्या तसे सोडतो. मग आम्ही 7 आणि 4 ची तुलना करतो. 4 हे 7 पेक्षा कमी आहे, म्हणून आम्ही त्यांना अदलाबदल करतो, सात एक स्थान ॲरेच्या शेवटी हलवतो. आता हे असे दिसते:

सात ॲरेच्या जवळजवळ शेवटपर्यंत पोहोचेपर्यंत ही प्रक्रिया पुनरावृत्ती होते. शेवटी त्याची तुलना घटक 8 शी केली जाते, जे मोठे आहे, याचा अर्थ कोणतीही देवाणघेवाण होत नाही. आम्ही एकदा ॲरे पार केल्यानंतर, ते असे दिसते:

किमान एक व्हॅल्यू एक्स्चेंज केले असल्याने, आम्हाला पुन्हा ॲरेमधून जावे लागेल. या पासच्या परिणामी, आम्ही क्रमांक 6 ठिकाणी हलवतो.

आणि पुन्हा, किमान एक एक्सचेंज केले गेले, याचा अर्थ आम्ही पुन्हा ॲरेमधून जातो.

पुढील पासवर, कोणतीही देवाणघेवाण केली जात नाही, याचा अर्थ आमची ॲरे क्रमवारी लावली गेली आहे आणि अल्गोरिदमने त्याचे कार्य पूर्ण केले आहे.

सार्वजनिक शून्य क्रमवारी (टी आयटम) ( bool स्वॅप्ड; do ( swapped = false; for (int i = 1; i< items.Length; i++) { if (items.CompareTo(items[i]) >0) ( स्वॅप(आयटम, i - 1, i); स्वॅप = सत्य; ) ) ) तर (स्वॅप्ड != खोटे); )

घालण्याची क्रमवारी

इन्सर्शन सॉर्ट ॲरेद्वारे पुनरावृत्ती करून आणि इच्छित मूल्य ॲरेच्या सुरूवातीस हलवून कार्य करते. पुढील पोझिशनवर प्रक्रिया केल्यानंतर, आम्हाला माहित आहे की त्याच्या आधीच्या सर्व पोझिशन्सची क्रमवारी लावली गेली आहे, परंतु ती नंतर नाही.

एक महत्त्वाचा मुद्दा: समाविष्ट क्रमवारी क्रमाने ॲरे घटक प्रक्रिया करते. अल्गोरिदम डावीकडून उजवीकडे घटकांद्वारे पुनरावृत्ती होत असल्याने, आम्हाला माहित आहे की वर्तमान निर्देशांकाच्या डावीकडील प्रत्येक गोष्ट आधीच क्रमवारी लावलेली आहे. ही आकृती दर्शवते की ॲरेचा क्रमवारी लावलेला भाग प्रत्येक पाससह कसा वाढतो:

हळुहळू ॲरेचा क्रमबद्ध भाग वाढतो आणि अखेरीस ॲरे ऑर्डर केला जाईल.

चला एक विशिष्ट उदाहरण पाहू. येथे आमची क्रमवारी न केलेली ॲरे आहे जी आम्ही वापरणार आहोत:

अल्गोरिदम अनुक्रमणिका 0 आणि मूल्य 3 पासून सुरू होते. ही पहिली अनुक्रमणिका असल्याने, त्यापर्यंतचा ॲरे क्रमवारी केलेला मानला जातो.

या टप्प्यावर, 0..1 निर्देशांक असलेल्या घटकांची क्रमवारी लावली जाते, परंतु 2..n निर्देशांक असलेल्या घटकांबद्दल काहीही माहिती नाही.

मूल्य 4 पुढे तपासले आहे कारण ते सात पेक्षा कमी आहे, आम्ही ते ॲरेच्या क्रमवारीत योग्य स्थानावर नेले पाहिजे. प्रश्न उरतो: ते कसे परिभाषित करावे? हे FindInsertionIndex पद्धतीद्वारे केले जाते. जोपर्यंत त्याला घालण्यासाठी जागा मिळत नाही तोपर्यंत क्रमवारी केलेल्या भागातील प्रत्येक मूल्याशी ते पास केलेल्या मूल्याची (4) तुलना करते.

तर, आम्हाला इंडेक्स 1 आढळला (मूल्य 3 आणि 7 दरम्यान). इन्सर्ट पद्धत ॲरेमधून इन्सर्ट व्हॅल्यू काढून टाकून आणि इन्सर्ट इंडेक्सपासून सुरू होऊन उजवीकडे सर्व व्हॅल्यू हलवून इन्सर्ट करते. आता ॲरे असे दिसते:

आता ॲरेचा भाग, शून्य घटकापासून सुरू होणारा आणि इंडेक्स 2 सह घटकासह समाप्त होणारा, क्रमवारी लावला आहे. पुढील पास अनुक्रमणिका 3 आणि मूल्य 4 पासून सुरू होतो. अल्गोरिदम कार्य करत असताना, आम्ही असे अंतर्भूत करणे सुरू ठेवतो.

जेव्हा आणखी काही इनसर्शन उपलब्ध नसतात, तेव्हा ॲरे पूर्णपणे सॉर्ट केलेला मानला जातो आणि अल्गोरिदम पूर्ण होतो.

सार्वजनिक शून्य क्रमवारी (टी आयटम) ( int sortedRangeEndIndex = 1; तर (sortedRangeEndIndex)< items.Length) { if (items.CompareTo(items) < 0) { int insertIndex = FindInsertionIndex(items, items); Insert(items, insertIndex, sortedRangeEndIndex); } sortedRangeEndIndex++; } } private int FindInsertionIndex(T items, T valueToInsert) { for (int index = 0; index < items.Length; index++) { if (items.CompareTo(valueToInsert) >0) ( रिटर्न इंडेक्स; ) ) नवीन InvalidOperationException फेकणे("इन्सर्टेशन इंडेक्स सापडला नाही"); ) खाजगी शून्य घाला (T itemArray, int indexInsertingAt, int indexInsertingFrom) ( // itemArray = 0 1 2 4 5 6 3 7 // insertingAt = 3 // insertingFrom = 6 // // क्रिया: // 1: वर्तमान जतन करा index in temp // 2: indexInsertingAt बदला indexInsertingFrom // 3: indexInsertingAt ला indexInsertingFrom स्थानावर बदला temp = itemArray; // चरण 2. itemArray = itemArray; // चरण 3. (int current = indexInsertingFrom; current > indexInsertingAt; current--) ( itemArray = itemArray; ) // चरण 4. itemArray = temp;

निवडीनुसार क्रमवारी लावत आहे

सिलेक्शन सॉर्ट हा बबल सॉर्ट आणि इन्सर्शन सॉर्ट मधील संकर आहे. बबल सॉर्ट प्रमाणे, हा अल्गोरिदम ॲरेमधून वारंवार जातो, एक व्हॅल्यू योग्य स्थितीत हलवतो. तथापि, बबल सॉर्टच्या विपरीत, ते सर्वात मोठ्या ऐवजी सर्वात लहान क्रमवारी न केलेले मूल्य निवडते. इन्सर्शन सॉर्ट प्रमाणे, ॲरेचा क्रमबद्ध भाग सुरुवातीला असतो, तर बबल सॉर्टमध्ये तो शेवटी असतो.

आमच्या unsorted ॲरेवर सिलेक्शन सॉर्ट कसे कार्य करते ते पाहू.

पहिल्या पासवर, ॲरेमधील सर्वात लहान मूल्य शोधण्यासाठी अल्गोरिदम FindIndexOfSmallestFromIndex पद्धत वापरते आणि त्यास सुरुवातीस हलवते.

अशा लहान ॲरेसह, आम्ही लगेच सांगू शकतो की सर्वात लहान मूल्य 3 आहे आणि ते आधीच योग्य स्थितीत आहे. या टप्प्यावर आपल्याला माहित आहे की ॲरेमधील प्रथम स्थान (इंडेक्स 0) हे सर्वात लहान मूल्य आहे, म्हणून ॲरेची सुरूवात आधीच क्रमवारी लावलेली आहे. म्हणून आम्ही दुसरा पास सुरू करतो - यावेळी 1 ते n - 1 पर्यंत निर्देशांक वापरून.

दुसऱ्या पासवर, आम्ही निर्धारित करतो की सर्वात लहान मूल्य 4 आहे. आम्ही ते दुसऱ्या घटकासह स्वॅप करतो, सात, ज्यानंतर 4 त्याच्या योग्य स्थितीत ठेवला जातो.

आता ॲरेचा क्रम न केलेला भाग इंडेक्स 2 पासून सुरू होतो. तो अल्गोरिदमच्या प्रत्येक पाससह एका घटकाने वाढतो. जर कोणत्याही पासवर आम्ही एकच एक्सचेंज केले नाही, तर याचा अर्थ ॲरे क्रमवारी लावला आहे.

आणखी दोन पास झाल्यानंतर, अल्गोरिदम त्याचे कार्य पूर्ण करते:

सार्वजनिक शून्य क्रमवारी (T आयटम) ( int sortedRangeEnd = 0; तर (sortedRangeEnd)< items.Length) { int nextIndex = FindIndexOfSmallestFromIndex(items, sortedRangeEnd); Swap(items, sortedRangeEnd, nextIndex); sortedRangeEnd++; } } private int FindIndexOfSmallestFromIndex(T items, int sortedRangeEnd) { T currentSmallest = items; int currentSmallestIndex = sortedRangeEnd; for (int i = sortedRangeEnd + 1; i < items.Length; i++) { if (currentSmallest.CompareTo(items[i]) >0) (currentSmallest = आयटम[i]; currentSmallestIndex = i; ) ) रिटर्न currentSmallestIndex; )

क्रमवारी विलीन करा

फूट पाडा आणि राज्य करा

आतापर्यंत आपण रेखीय अल्गोरिदम पाहिले आहेत. ते थोडे अतिरिक्त मेमरी वापरतात परंतु चतुर्भुज जटिलता आहे. उदाहरण म्हणून विलीनीकरण क्रम वापरून, आम्ही विभाजन आणि जिंकणे अल्गोरिदम पाहू. (विभागा आणि जिंका).

या प्रकारचा अल्गोरिदम मोठ्या समस्येचे छोट्या, सोप्या पद्धतीने सोडवण्यायोग्य समस्यांमध्ये विभागणी करून कार्य करतो. आम्ही त्यांचा दररोज वापर करतो. उदाहरणार्थ, फोन बुकमध्ये शोधणे हे अशा अल्गोरिदमचे एक उदाहरण आहे.

जर तुम्हाला पेट्रोव्ह नावाची व्यक्ती शोधायची असेल, तर तुम्ही A अक्षरापासून सुरुवात करून आणि एका वेळी एक पान फिरवून शोधणार नाही. तुम्ही बहुधा पुस्तक मध्यभागी कुठेतरी उघडाल. तुम्ही T ला दाबल्यास, तुम्ही काही पृष्ठे मागे पलटवाल, कदाचित O वर खूप जास्त असतील. मग तुम्ही पुढे जाल. अशा प्रकारे, कमी आणि कमी पृष्ठांमधून पुढे आणि मागे फ्लिप केल्याने, शेवटी आपल्याला आवश्यक असलेले एक सापडेल.

हे अल्गोरिदम किती प्रभावी आहेत?

समजा फोन बुकमध्ये 1000 पाने आहेत. तुम्ही ते अर्धवट उघडल्यास, तुम्ही 500 पृष्ठे फेकून देत आहात ज्यात तुम्ही शोधत असलेली व्यक्ती नाही. तुम्ही उजव्या पृष्ठावर न पोहोचल्यास, तुम्ही उजवी किंवा डावी बाजू निवडा आणि उपलब्ध पर्यायांपैकी अर्ध्या पर्यायांसह पुन्हा सोडले जातील. आता तुमच्याकडे पाहण्यासाठी 250 पाने आहेत. अशाप्रकारे आम्ही आमची समस्या पुन्हा पुन्हा अर्ध्या भागात विभागतो आणि फोन बुकमध्ये फक्त 10 लूकमध्ये एक व्यक्ती शोधू शकतो. हे पृष्ठांच्या एकूण संख्येपैकी 1% दर्शविते जे आम्हाला रेखीय शोधात पहावे लागेल.

क्रमवारी विलीन करा

मर्ज क्रमवारीत, प्रत्येक विभाग एक घटक लांब होईपर्यंत आम्ही ॲरे अर्ध्यामध्ये विभाजित करतो. मग हे विभाग योग्य क्रमाने त्यांच्या जागी (विलीन) परत केले जातात.

चला अशा प्रकारे एक ॲरे पाहू:

चला ते अर्ध्यामध्ये विभाजित करूया:

आणि आम्ही प्रत्येक भाग अर्ध्यामध्ये विभाजित करू जोपर्यंत एक घटक शिल्लक राहत नाही:

आता आम्ही ॲरेला शक्य तितक्या लहान विभागांमध्ये विभागले आहे, आम्ही त्यांना योग्य क्रमाने विलीन करतो.

प्रथम आपल्याला दोन वर्गीकृत घटकांचे गट मिळतात, नंतर आपण त्यांना चार घटकांच्या गटांमध्ये "संकलित" करतो आणि शेवटी आम्ही सर्व काही एका क्रमबद्ध ॲरेमध्ये एकत्रित करतो.

अल्गोरिदम कार्य करण्यासाठी, आम्ही खालील ऑपरेशन्स अंमलात आणणे आवश्यक आहे:

1. ॲरेला वारंवार गटांमध्ये विभाजित करण्यासाठी ऑपरेशन (क्रमवारी पद्धत).
2. योग्य क्रमाने विलीन करणे (मर्ज पद्धत).

हे लक्षात घेण्यासारखे आहे की रेखीय क्रमवारी अल्गोरिदमच्या विपरीत, विलीनीकरण क्रमवारी विभाजित होईल आणि ॲरे मूळत: क्रमवारी लावली होती की नाही याची पर्वा न करता विलीन होईल. म्हणून, जरी सर्वात वाईट परिस्थितीत ते रेखीय पेक्षा वेगवान कार्य करेल, सर्वोत्तम बाबतीत त्याची कार्यक्षमता रेखीय पेक्षा कमी असेल. म्हणून, तुम्हाला अर्धवट ऑर्डर केलेले ॲरे सॉर्ट करण्याची आवश्यकता असताना मर्ज सॉर्ट हा सर्वोत्तम उपाय नाही.

सार्वजनिक शून्य क्रमवारी (टी आयटम) ( जर (आयटम. लांबी<= 1) { return; } int leftSize = items.Length / 2; int rightSize = items.Length - leftSize; T left = new T; T right = new T; Array.Copy(items, 0, left, 0, leftSize); Array.Copy(items, leftSize, right, 0, rightSize); Sort(left); Sort(right); Merge(items, left, right); } private void Merge(T items, T left, T right) { int leftIndex = 0; int rightIndex = 0; int targetIndex = 0; int remaining = left.Length + right.Length; while(remaining >0) ( जर (leftIndex >= डावीकडे. लांबी) ( आयटम = उजवीकडे; ) तर (उजवीकडे निर्देशांक >= उजवीकडे. लांबी) (आयटम = डावीकडे; ) नाहीतर जर (डावीकडे. तुलना करा(उजवीकडे)< 0) { items = left; } else { items = right; } targetIndex++; remaining--; } }

द्रुत क्रमवारी

Quicksort हा आणखी एक विभाजन आणि विजय अल्गोरिदम आहे. हे पुढील चरणांची पुनरावृत्ती करून कार्य करते:

1. की इंडेक्स निवडा आणि त्याचा वापर करून ॲरेचे दोन भाग करा. हे अनेक प्रकारे केले जाऊ शकते, परंतु या लेखात आम्ही यादृच्छिक संख्या वापरतो.
2. ॲरेच्या उजव्या बाजूला की पेक्षा मोठे सर्व घटक आणि की पेक्षा कमी सर्व घटक डावीकडे हलवा. मुख्य घटक आता योग्य स्थितीत आहे - तो डावीकडील कोणत्याही घटकापेक्षा मोठा आणि उजवीकडील कोणत्याही घटकापेक्षा लहान आहे.
3. ॲरे पूर्णपणे क्रमवारी होईपर्यंत आम्ही पहिल्या दोन चरणांची पुनरावृत्ती करतो.

खालील ॲरेवर अल्गोरिदम कसे कार्य करते ते पाहूया:

प्रथम आपण यादृच्छिकपणे एक मुख्य घटक निवडतो:

Int pivotIndex = _pivotRng.Next(डावीकडे, उजवीकडे);

आता आम्हाला की इंडेक्स (4) माहित असल्याने, आम्ही त्या इंडेक्स (6) वर स्थित व्हॅल्यू घेतो आणि ॲरेमध्ये व्हॅल्यू हलवतो जेणेकरून की पेक्षा मोठ्या किंवा समान सर्व संख्या उजव्या बाजूला असतील आणि सर्व की पेक्षा कमी संख्या डावीकडे आहेत. लक्षात ठेवा की मूल्ये हस्तांतरित करण्याच्या प्रक्रियेदरम्यान मुख्य घटकाची अनुक्रमणिका बदलू शकते (आम्ही हे लवकरच पाहू).

मुव्हिंग व्हॅल्यूज विभाजन पद्धती वापरून केले जाते.

या टप्प्यावर आपल्याला माहित आहे की मूल्य 6 योग्य स्थितीत आहे. आता आपण ॲरेच्या उजव्या आणि डाव्या बाजूंसाठी ही प्रक्रिया पुन्हा करू.

आमच्याकडे एक क्रमवारी न केलेले मूल्य शिल्लक आहे, आणि आम्हाला माहित आहे की इतर सर्व गोष्टी आधीच क्रमवारी लावल्या गेल्या आहेत, अल्गोरिदम संपुष्टात येतो.

यादृच्छिक _pivotRng = नवीन यादृच्छिक(); सार्वजनिक शून्य क्रमवारी (टी आयटम) ( द्रुत क्रमवारी (आयटम, 0, आयटम. लांबी - 1); ) खाजगी शून्य क्विकसॉर्ट (टी आयटम, डावीकडे पूर्ण, उजवीकडे पूर्ण) ( जर (डावीकडे)< right) { int pivotIndex = _pivotRng.Next(left, right); int newPivot = partition(items, left, right, pivotIndex); quicksort(items, left, newPivot - 1); quicksort(items, newPivot + 1, right); } } private int partition(T items, int left, int right, int pivotIndex) { T pivotValue = items; Swap(items, pivotIndex, right); int storeIndex = left; for (int i = left; i < right; i++) { if (items[i].CompareTo(pivotValue) < 0) { Swap(items, i, storeIndex); storeIndex += 1; } } Swap(items, storeIndex, right); return storeIndex; }

निष्कर्ष

हे नवशिक्यांसाठी अल्गोरिदम आणि डेटा स्ट्रक्चर्सवरील आमच्या लेखांच्या मालिकेचा शेवट करते. या वेळी, आम्ही लिंक केलेल्या याद्या, डायनॅमिक ॲरे, बायनरी शोध झाडे आणि C# मधील कोड उदाहरणांसह सेट पाहिले.

महापालिका माध्यमिक शाळा एस. कामश्की

सर्जनशील कार्य

डेटा वर्गीकरण पद्धती

OIVT ची जाणीव

केले:

आयटी-शिक्षक

I पात्रता श्रेणीसाठी

सह. अल-गै, 2006

परिचय. 3

1. "डेटा क्रमवारी लावण्याच्या पद्धती" या विषयाचा अभ्यास करण्याची गरज. 4

2. "डेटा सॉर्टिंगच्या पद्धती" या विषयासाठी पूर्वतयारी कार्य. 4

3. क्रमवारी पद्धती. ७

4. अधिक जटिल आणि अधिक कार्यक्षम वर्गीकरण पद्धती. 10

5. वर्गीकरण पद्धतींची तुलनात्मक वैशिष्ट्ये. अकरा

निष्कर्ष. 12

साहित्य.. १३

अर्ज. 14

अर्ज. १५

अर्ज. 16

अर्ज. 20

अर्ज. २१

अर्ज. २४

अर्ज. २६

अर्ज. २८

अर्ज. 29

अर्ज. ३४

अर्ज. ३७

अर्ज. 42

परिचय

या कार्यामध्ये "डेटा सॉर्टिंग पद्धती" या मोठ्या विषयाचा समावेश आहे, जो JIVT कोर्समध्ये अनिवार्य आहे.
सारणी मूल्ये आणि वर्गीकरण पद्धतींचा अभ्यास हा कोणत्याही संगणक विज्ञान अभ्यासक्रमाचा अविभाज्य भाग आहे. त्यांच्या लेखकांच्या वैचारिक आणि पद्धतशीर वृत्तीमध्ये फरक असूनही, आज सर्व पाठ्यपुस्तकांमध्ये या विषयावर व्यापक चर्चा केली जाते या वस्तुस्थितीवरून हे किमान दिसून येते.
क्रमवारी प्रक्रिया म्हणजे काही डेटा (टेबल) की द्वारे ऑर्डर करण्याची क्रिया. कळा वेगळ्या असू शकतात. उदाहरणार्थ, रूपांतरित करा
1) चढत्या क्रमाने संख्यांची सारणी,
२) आडनावांची सारणी - वर्णक्रमानुसार आणि फक्त पहिल्या अक्षराने,
3) घटक जे उतरत्या क्रमाने सारणीमध्ये फक्त सम ठिकाणी दिसतात.
हे स्पष्ट आहे की यादृच्छिकपणे व्यवस्था केलेल्या डेटापेक्षा "क्रमबद्ध" डेटासह कार्य करणे सोपे आणि जलद आहे. जेव्हा घटक "सॉर्ट केलेले" असतात, तेव्हा ते शोधणे सोपे होते, उदाहरणार्थ, 500-पानांच्या फोन बुकमध्ये मित्राचा फोन नंबर किंवा 700-पानांच्या शब्दकोशात शब्द शोधणे अधिक जलद.

"क्रमवारी" या विषयाचे महत्त्व टेबलच्या विशेष भूमिकेद्वारे देखील निर्धारित केले जाते. संगणकाचे सर्व ऍप्लिकेशन्स मोठ्या प्रमाणात माहितीवर जलद आणि अचूकपणे प्रक्रिया करण्याच्या त्यांच्या क्षमतेवर आधारित आहेत आणि हे तेव्हाच शक्य आहे जेव्हा माहिती एकसंध आणि क्रमवारीत असेल. अशा प्रकारे, सर्व वास्तविक संगणक प्रोग्राममध्ये एकसंध माहिती सादर करण्याचे मुख्य साधन म्हणून सारण्या अनिवार्यपणे वापरल्या जातात.
आधुनिक संगणकांचे आर्किटेक्चर सारणीच्या तत्त्वावर आधारित आहे: मशीनची मेमरी बाइट्सची एक मोठी ॲरे मानली जाऊ शकते, ज्याचे पत्ते चढत्या क्रमाने लावले जातात. परिणामी, सारण्यांचे माहितीचे सार आणि त्यांच्यावर प्रक्रिया करण्यासाठी मूलभूत अल्गोरिदम समजून घेतल्याशिवाय, संगणकाच्या क्षमता आणि त्यांच्या ऑपरेशनच्या तत्त्वांची संपूर्ण माहिती तयार करणे अशक्य आहे. याचा अर्थ संगणक शास्त्राच्या सामान्य शिक्षण अभ्यासक्रमात "वर्गीकरण" या विषयाची आवश्यकता आहे. सखोल कॉम्प्युटर सायन्स कोर्समध्ये हा विषय अत्यंत आवश्यक आहे. कोणतेही क्लिष्ट आणि अर्थपूर्ण प्रोग्राम तयार करण्यासाठी, आपल्याला टेबल वापरण्याच्या सामान्य तत्त्वांचे आणि त्यावर प्रक्रिया करण्यासाठी मूलभूत तंत्रांचे आत्मविश्वासपूर्ण आकलन आवश्यक आहे.
डेटा वर्गीकरणाचे घटक विविध लेखकांच्या अनेक कामांमध्ये सादर केले जातात (पहा). हे "वर्गीकरण" या विषयाची प्रासंगिकता, त्यांच्या पद्धतींचा अभ्यास, डेटा वर्गीकरणाशी संबंधित JIVT अभ्यासक्रमातील विषय शिकवण्याच्या पद्धतींचा विकास दर्शवते.
सह महापालिका शैक्षणिक संस्था माध्यमिक शाळा मध्ये. रीड्स कॉम्प्युटर सायन्स अनेक वर्षांपासून शिकवले जात आहे. वर्षानुवर्षे, आम्हाला एकापेक्षा जास्त वेळा प्रोग्राम बदलावा लागला आहे. कधीकधी सादरीकरणाची पद्धत आणि सामग्रीची सामग्री बदलणे आवश्यक होते, जे अंशतः संगणक तंत्रज्ञानाच्या विकासामुळे आणि या संबंधात दिसणार्या नवीन संधी आणि नवीन तंत्रज्ञानामुळे होते.

"वर्गीकरण" ची थीम हा कार्यक्रमाचा अविभाज्य भाग आहे. काही समस्या सोडवण्यासाठी शिक्षकाकडे मोठ्या प्रमाणात तयार केलेले अल्गोरिदम आहेत. एखाद्या विषयाचा अभ्यास करण्याच्या प्रक्रियेत, तो प्रभावी ठरतो: विद्यार्थी स्वतः तयार केलेले अल्गोरिदम आणि प्रोग्राम कार्यान्वित करतो, “संगणकाऐवजी,” विशिष्ट प्रारंभिक डेटासाठी अल्गोरिदमचा “ट्रेस” करतो, अशा डेटाची निवड करतो जे अल्गोरिदम क्रियांची सर्वात मोठी किंवा सर्वात लहान संख्या करेल. प्रत्येक विषयासाठी, असे कार्य केवळ संगणकावरच नाही तर नोटबुकसह देखील, लेखकाच्या मते, सकारात्मक परिणाम देते.
या कामाचा उद्देश इयत्ता 10-11 मध्ये "घटकांची क्रमवारी लावणे" हा विषय शिकवण्याच्या पद्धतीची रूपरेषा तयार करणे, तसेच डेटा वर्गीकरणाशी संबंधित विषय.
याशिवाय, उदाहरण म्हणून या विषयाचा वापर करून, मी इतर अनेक विषय शिकवण्यासाठी वापरल्या जाणाऱ्या अध्यापन पद्धतीचे प्रदर्शन करू इच्छितो.
झटपट वर्गीकरण पद्धती, ज्या समजण्यास अधिक कठीण आहेत, त्या वैकल्पिक वर्गांमध्ये शिकवल्या जातात.

1. "डेटा सॉर्टिंगच्या पद्धती" या विषयाचा अभ्यास करण्याची गरज

कोणत्याही विषयाचा अभ्यास विद्यार्थ्याला याची गरज भासण्यासाठी, संबंधित समस्या सोडवण्याची गरज दर्शविण्यासाठी, विद्यार्थ्यांना समजेल अशी उदाहरणे प्रदान करण्यासाठी आणि लागू केलेल्या समस्यांमध्ये वर्गीकरण घटकांचा वापर (सरावात) दाखवण्यासाठी सुरुवात केली पाहिजे. , आपल्या सभोवतालच्या जगात).
आम्ही डेटाच्या "वर्गीकरण" च्या अर्थाची अंतर्ज्ञानी संकल्पना दिली आहे, आम्ही JIVT धड्यांमध्ये त्याच्या आवश्यकतेबद्दल बोलतो, उदाहरणार्थ, काही निकषांनुसार डेटाची क्रमवारी लावणे. आम्ही वैयक्तिक नोटबुक, शब्दकोश, टेलिफोन डिरेक्टरी, गणितीय तक्ते आणि विश्वकोश आयोजित करण्याची उदाहरणे देतो. जर सूचीबद्ध केलेल्या वस्तूंची माहिती क्रमवारी लावली नसेल तर ते कसे वापरायचे याची कल्पना करणे कठीण आहे.
शब्दकोषांमध्ये, "सॉर्टिंग" शब्दाची व्याख्या, वाण, गुणवत्ता, आकार आणि तत्सम वैशिष्ट्यांनुसार वितरण म्हणून केली जाते, हा शब्द पारंपारिकपणे संकुचित अर्थाने वापरला जातो;
OIVT कोर्समध्ये, क्रमवारी लावणे सामान्यत: दिलेल्या वस्तूंच्या संचाच्या घटकांना काही विशिष्ट क्रमाने ठेवण्याची प्रक्रिया समजली जाते, सामान्यतः चढत्या किंवा उतरत्या क्रमाने (जेव्हा क्रमवारी केलेले घटक संख्या असतात) किंवा वर्णक्रमानुसार (मजकूर माहितीची क्रमवारी लावताना) .
अर्थात, यादृच्छिकपणे मांडलेल्या डेटापेक्षा क्रमवारी लावलेला डेटा वापरणे सोपे आहे. जेव्हा घटकांची क्रमवारी लावली जाते, तेव्हा ते शोधणे सोपे होते आणि त्यांच्यासह विविध ऑपरेशन्स करणे सोपे होते. क्रमवारी केलेल्या डेटासह, गहाळ आयटम आहेत की नाही हे निर्धारित करणे सोपे आहे. दोन क्रमवारी केलेल्या सारण्यांमधील सामान्य घटक शोधणे सोपे आहे.
क्रमवारी लावणे हे जवळजवळ कोणत्याही अल्गोरिदमला गती देण्याचे एक शक्तिशाली साधन आहे ज्यासाठी विशिष्ट घटकांमध्ये वारंवार प्रवेश आवश्यक असतो. प्रोग्रामिंग सिद्धांतातील एक क्लासिक म्हणून, डी. नुथ, [4] मध्ये लिहितात, “जरी क्रमवारी जवळजवळ निरुपयोगी असली तरीही, शोधात्मक क्रमवारी पद्धती हे सूचित करतात की ते स्वतःच एक ऑब्जेक्ट म्हणून मनोरंजक आहे! संशोधन." या पद्धतींचे विश्लेषण शिकवण्याच्या दृष्टिकोनातून देखील खूप उपयुक्त आहे, कारण त्यांचा उपयोग विविध परिस्थिती स्पष्टपणे स्पष्ट करण्यासाठी केला जाऊ शकतो. पास्कल भाषेचे निर्माते, एन. विर्थ यांच्या मते, "असे दिसते की तुम्ही फक्त सॉर्टिंग समस्यांमधून उदाहरणे निवडून संपूर्ण प्रोग्रामिंग कोर्स तयार करू शकता" [५].
अल्गोरिदमचा हा वर्ग देखील मनोरंजक आहे कारण तो सर्वात श्रीमंत प्रोग्रामिंग शक्यता स्पष्टपणे प्रदर्शित करतो: तुम्ही एकाच ध्येयापर्यंत किती वेगवेगळ्या मार्गांनी पोहोचू शकता - ऑर्डर केलेला ॲरे मिळवणे! वर्गीकरण अल्गोरिदमची विविधता लक्षात घेता, हे स्पष्ट होते की अल्गोरिदमचे तुलनात्मक विश्लेषण आणि त्यांच्या गुणवत्तेचे मूल्यांकन करणे आवश्यक आहे, ज्याचे निकष कार्यक्षमतेत वाढ आणि मेमरी बचत आहेत. शालेय संगणक विज्ञान अभ्यासक्रमात वर्गीकरणाशी संबंधित समस्यांना महत्त्वाचे स्थान आहे असे नाही.

2. "डेटा सॉर्टिंगच्या पद्धती" या विषयासाठी पूर्वतयारी कार्य.

शोध आणि क्रमवारी सारणी आणि इतर जटिल डेटा संरचनांशी संबंधित आहे, म्हणून या जटिल डेटा संरचनांचा अभ्यास करणे आवश्यक आहे, उदाहरणार्थ, रेखीय आणि आयताकृती ॲरे (टेबल).
प्रोग्रॅमिंगमध्ये एकसंध माहितीचे प्रतिनिधित्व करण्याच्या संरचनेला सामान्यतः ॲरे म्हणतात. (खरं तर, या संदर्भातील सारणी आणि ॲरे हे शब्द पूर्ण समानार्थी शब्द आहेत).
इयत्ता 10 मध्ये, माहिती संग्रहित करण्याचा एक नवीन मार्ग म्हणून टेबलची संकल्पना सादर केली जाते. नवीन संकल्पना विद्यार्थ्यांच्या ज्येथे त्या योगायोगाने उद्भवतात त्याच्या दृष्टीने उत्तम समजतात, परंतु कोणतीही नवीन समस्या सोडवताना आवश्यकता असते. विशेष निवडलेल्या प्रास्ताविक समस्येचे निराकरण करण्याच्या परिणामी एक नवीन संकल्पना उद्भवते. खरं तर, विद्यार्थी स्वतःच हरवलेल्या साधनांचा शोध लावतात आणि शिक्षकाने या साधनांच्या निर्मितीला योग्य दिशेने निर्देशित केले पाहिजे.

"सारणी" या विषयासाठी संभाव्य प्रास्ताविक कार्य - ज्ञात बाजूच्या लांबीसह बहुभुजाची परिमिती शोधणे हे परिशिष्ट 1 मध्ये दिलेले आहे. हे कार्य विद्यार्थ्यांना सारणीच्या प्रमाणांच्या मूलभूत गुणधर्मांकडे घेऊन जाते: सारणीमध्ये अनेक सोप्या चलांचा समावेश असतो. अनन्य नावाने नाही तर घटक क्रमांक दर्शविणाऱ्या सामान्य सारणीच्या नावाने प्रवेश केला जातो.

या परिचयानंतर, विद्यार्थ्यांना टेबल्सची गरज का आहे हे समजते, ते घटक, अनुक्रमणिका, घटक प्रवेश इत्यादी संकल्पना समजून घेण्यासाठी तयार असतात.

वास्तविक-जगातील समस्या सोडवताना उत्तर देण्यासाठी एक महत्त्वाचा प्रश्न म्हणजे साध्या व्हेरिएबल्सला टेबलमध्ये कधी एकत्र करावे आणि कधी नाही. उत्तराची गुरुकिल्ली म्हणजे सारणीला एकसंध माहिती साठवणारे संमिश्र प्रमाण समजणे.

एकजिनसीपणाचा अर्थ असा आहे की सारणीचे सर्व घटक समान आहेत: त्यांचा समान अर्थपूर्ण अर्थ आहे आणि जेव्हा प्रक्रिया केली जाते तेव्हा त्यांच्यावर समान ऑपरेशन्स केल्या जातात.

एखाद्या विद्यार्थ्याला समस्या सोडवायला शिकवण्यासाठी, त्याला केवळ मानक तंत्रांचा परिचय करून देणे आवश्यक नाही, तर हे किंवा ते तंत्र कोणत्या परिस्थितीत कार्य करते हे देखील त्याला दर्शविणे आवश्यक आहे.

चांगल्या वर्गीकरणाने यास मदत केली पाहिजे; हे करण्यासाठी, एकाच वेळी समान परिस्थिती आणि निराकरणाची तत्त्वे असलेल्या कार्यांचे गट करणे आवश्यक आहे (परिशिष्ट क्रमांक 2 पहा).

परिस्थितीची सामान्यता हे सुनिश्चित करते की विद्यार्थ्याने समस्या ओळखली आहे आणि ती एका विशिष्ट प्रकारासाठी नियुक्त केली आहे, म्हणजेच ते वर्गीकरणाच्या वास्तविक अनुप्रयोगाची शक्यता निर्माण करते.
सोल्यूशन्सची सामान्यता विद्यार्थ्याला पुढील पाऊल उचलण्यास मदत करते - समाधान पद्धत निवडण्यासाठी, म्हणजेच ते वर्गीकरणाची प्रभावीता सुनिश्चित करते.
अशा प्रकारे, वर्गीकरण एका विशिष्ट वैशिष्ट्यावर आधारित असावे जे समस्येच्या परिस्थितीतून स्पष्टपणे दृश्यमान आहे आणि त्याच्या निराकरणावर लक्षणीय परिणाम करते. असे वैशिष्ट्य म्हणून, अल्गोरिदममधील सारणीच्या माहितीच्या भूमिकेचा, म्हणजे, सारणी मूल्याचा प्रकार विचारात घेण्याचा प्रस्ताव आहे.
स्पष्टपणे, सारणी अल्गोरिदम (भरणे), एक युक्तिवाद (प्रक्रिया) आणि परिणाम युक्तिवाद (फेरफार) चे परिणाम असू शकते. जवळून तपासणी केल्यावर, हे स्पष्ट होते की प्रक्रिया (टेबल - युक्तिवाद) मध्ये वेगवेगळ्या पद्धतींनी सोडवलेल्या समस्यांचा खूप मोठा वर्ग समाविष्ट आहे. त्यापैकी, दोन मोठे गट वेगळे केले जाऊ शकतात: विश्लेषण कार्ये आणि शोध कार्ये. विश्लेषण कार्यांमध्ये, तुम्हाला संपूर्ण सारणी पहाणे आवश्यक आहे आणि त्यातील काही वैशिष्ट्ये (बेरीज, उत्पादन, दिलेल्या मालमत्तेसह घटकांची संख्या इ.) निर्धारित करणे आवश्यक आहे, शोध कार्यांमध्ये, आपल्याला सारणीमध्ये एक घटक शोधण्याची आवश्यकता आहे ज्यामध्ये इच्छित मालमत्ता, आणि यासाठी संपूर्ण टेबल पाहणे आवश्यक नाही.
दुसरीकडे, बर्याच सुधारणा कार्यांना विशेष तंत्रांच्या विकासाची आवश्यकता नसते आणि ते विश्लेषण आणि भरण्याच्या संयोजनात कमी केले जातात. हे, उदाहरणार्थ, अहवाल समायोजित करण्याचे सुप्रसिद्ध कार्य आहे (100 पेक्षा कमी घटक 100 ने बदला) आणि तत्सम. म्हणून, कार्यांचा एक वेगळा वर्ग म्हणून बदल ओळखणे योग्य नाही.
वास्तविक स्वारस्य म्हणजे क्रमपरिवर्तन समस्या ज्यामध्ये दिलेल्या सारणीच्या घटकांची काही आवश्यकतांनुसार पुनर्रचना करणे आवश्यक आहे. ही कार्ये इतरांना कमी करता येत नाहीत आणि स्वतंत्र गट म्हणून गणली जाऊ शकतात. क्रमपरिवर्तनाचे मुख्य कार्य म्हणजे ॲरे घटकांची क्रमवारी लावणे, म्हणजेच ॲरे घटकांची पुनर्रचना करणे आवश्यक आहे जेणेकरून ते व्यवस्थित केले जातील, उदाहरणार्थ, चढत्या क्रमाने. ॲरे क्रमवारी लावण्याची समस्या आकाशातून पडत नाही, परंतु सारणी मूल्यांचा समावेश असलेल्या समस्यांच्या गटांपैकी एक आहे. शेवटी आम्हाला कार्यांचे खालील गट मिळतात:
1. भरणे
2. विश्लेषण
3. शोधा
4. पुनर्रचना.
प्रत्येक गटासाठी कार्यांची मालिका परिशिष्ट 3 मध्ये दिली आहे.

खरं तर, अल्गोरिदम तयार करण्यासाठी सर्व मूलभूत तंत्रे रेखीय सारण्यांवर तयार केली जातात. आयताकृती सारण्यांवर प्रक्रिया केल्याने परिमाणात्मक, परंतु गुणात्मक नाही, जटिलता येते. एक रेखीय सारणी ही मूलभूत, प्राथमिक संकल्पना आहे आणि एक आयताकृती सारणी ही रेखीय सारणी असलेली रेखीय सारणी म्हणून तयार केली जाऊ शकते. म्हणून, सामान्य शैक्षणिक अभ्यासक्रमात, फक्त रेषीय सारण्यांचा विचार करणे पुरेसे आहे, कदाचित उल्लेख करणे, परंतु तपशीलवार परीक्षण न करणे, आयताकृती. सखोल अभ्यासक्रम लागू करताना, आयताकृती सारण्यांचा अभ्यास करणे आवश्यक आहे, परंतु या प्रकरणात देखील, आपल्याला प्रथम रेखीय सारण्यांवर प्रक्रिया करण्याच्या मूलभूत तत्त्वांचे दृढपणे आकलन करणे आवश्यक आहे.
आमच्या शालेय विषय JIVT मध्ये, खरं तर, समस्यांचा संग्रह किंवा प्रकाशित उपदेशात्मक साहित्य नाही. संगणक विज्ञान शिक्षकाला सतत कार्य परिस्थिती निवडणे आणि व्यवस्थित करणे आवश्यक आहे.

बऱ्याच वर्षांच्या अनुभवावरून असे दिसून आले आहे की अल्गोरिदम आणि प्रोग्राम्स संकलित करण्याव्यतिरिक्त, शिक्षक आणि विद्यार्थ्यांनी तयार केलेल्या अल्गोरिदमच्या अंमलबजावणीकडे लक्ष देणे योग्य आहे.
विद्यार्थ्यांना आवश्यक आहे:
1) अल्गोरिदम कार्यान्वित करा,
2) विशिष्ट डेटावर कार्यान्वित केल्यावर काय होते ते निर्धारित करा,
3) तयार अल्गोरिदम वापरून समस्येची स्थिती पुनर्संचयित करा,
4) अल्गोरिदम कार्यान्वित करताना "प्राथमिक" क्रियांच्या संख्येचे विश्लेषण करा, जे अल्गोरिदमची गती किंवा त्याची अंमलबजावणी वेळ प्रतिबिंबित करते,
5) असा डेटा निवडा ज्यासाठी "प्राथमिक" क्रियांची संख्या कमी असेल आणि असा डेटा ज्यासाठी तो जास्तीत जास्त असेल.

आपण विविध फॉर्ममध्ये तयार अल्गोरिदमसह कार्य करू शकता, उदाहरणार्थ:
1. सर्व विद्यार्थ्यांना समान अल्गोरिदम समजावून सांगताना;
2. विद्यार्थ्यासोबत वैयक्तिकरित्या काम करताना;
3. विषय चुकलेल्या विद्यार्थ्यांना वेगळा विषय समजावून सांगताना, उदाहरणार्थ, आजारपणामुळे;
4. त्या विद्यार्थ्यांसोबत विषय समजून घेताना जे नेहमी प्रथमच सामग्रीवर प्रभुत्व मिळवत नाहीत.
रेडीमेड अल्गोरिदमसह विविध फॉर्ममध्ये काम केल्याने तुम्हाला हे करण्याची अनुमती मिळते:
1. विद्यार्थ्यांची वैयक्तिक वैशिष्ट्ये विचारात घ्या;
2. मानसशास्त्र, कालांतराने त्यांच्या वेगवेगळ्या प्रतिक्रिया विचारात घ्या;
3. त्यांची तार्किक, अल्गोरिदमिक क्षमता विकसित करा;
4. संबंधित विषयावरील ज्ञान सखोल करा, कारण निकाल मिळविण्यासाठी, तो स्वतः अल्गोरिदम पार पाडण्यास बांधील आहे, एक कलाकार म्हणून, ज्याचा अर्थ सर्व संरचना एकत्रित करणे, ते कसे अंमलात आणले जातात, त्यांची वैशिष्ट्ये कोणती आहेत हे चांगल्या प्रकारे समजून घेणे आहे

"वर्गीकरण" या विषयासाठी तयारीच्या कामाचा आणखी एक घटक म्हणजे प्रोग्रामिंग भाषांमधील व्हेरिएबल आयामांच्या ॲरेचा अभ्यास. परिशिष्ट 4 विद्यार्थ्यांना सोडवण्याची ऑफर केलेली कार्ये दर्शविते.
10 व्या इयत्तेतील विद्यार्थ्यांसोबत केलेले पूर्वतयारी कार्य आम्हाला थेट वर्गीकरण पद्धतींचा अभ्यास करण्यास अनुमती देते.

म्हणून, अभ्यासाच्या पहिल्या वर्षात (10 व्या वर्गात), अभ्यास टेबलसाठी पाया घातला गेला, समस्यांच्या मालिकेद्वारे कार्य करणे आणि जास्तीत जास्त आणि किमान घटक निवडण्यासाठी अल्गोरिदम, घटकांची पुनर्रचना इ.
11 व्या वर्गात, आम्ही अभ्यास केलेल्या टेबल प्रोसेसिंग अल्गोरिदमवर अवलंबून राहून क्रमवारी पद्धतींच्या जवळ आलो आहोत.
आवश्यक घटक शोधणे, शब्दकोश, संदर्भ पुस्तके संकलित करणे, लॉटरी तक्ते काढणे आणि मासिकातील विद्यार्थ्यांची यादी या समस्यांचा विचार केला जातो.
अनेक समस्यांचे निराकरण करण्यासाठी, प्रथम एका विशिष्ट निकषानुसार डेटा आयोजित करणे सोयीचे आहे.
डेटा, जसे की ॲरे घटकांची क्रमवारी लावली जाऊ शकते:
चढत्या - प्रत्येक पुढील घटक मागील घटकापेक्षा मोठा आहे:
एक[ १ ]< a < a[n];
कमी न होणारा - प्रत्येक पुढील घटक मागील घटकापेक्षा कमी नाही:
ए<= а <=. . .<= а[n];
उतरत्या - प्रत्येक पुढील घटक मागील घटकापेक्षा कमी आहे:
a [ 1 ]> a> ... >a[n],
नॉन-असेंडिंग - प्रत्येक पुढील घटक मागील घटकापेक्षा मोठा नसतो:
a [ 1 ] >= a >= ... >=a[n].

3. वर्गीकरण पद्धती

कार्यक्षमतेच्या प्रमाणात एकमेकांपासून भिन्न असलेल्या काही भिन्न क्रमवारी पद्धती आहेत, ज्याला वर्गीकरण प्रक्रियेदरम्यान केलेल्या तुलनेची संख्या आणि एक्सचेंजची संख्या, अंमलबजावणीची वेळ आणि व्यापलेल्या जागेचे प्रमाण समजले जाते. चला यापैकी काही पद्धतींचा तपशीलवार विचार करूया. प्रथम, चार सोप्या पद्धती दिल्या आहेत. प्रस्तावित ऑर्डर समाधानकारक नसल्यास प्रत्येक शिक्षक या पद्धतींचा अभ्यास करण्याचा कोणताही क्रम निवडू शकतो.
तथापि, कोणत्याही क्रमवारी पद्धतीचा विचार करण्यापूर्वी, ही पद्धत ज्यावर अवलंबून आहे त्या वैयक्तिक आधीच अभ्यासलेल्या अल्गोरिदमची पुनरावृत्ती करणे आवश्यक आहे.
प्रथम, दोन क्रमवारी पद्धती पाहू:
निवड क्रमवारी (किंवा रेखीय) आणि एक्सचेंज क्रमवारी (किंवा बबल).
दोन्ही पद्धती फार प्रभावी नाहीत आणि सराव मध्ये अत्यंत क्वचितच वापरल्या जातात. पण मग त्यांच्यावर अजिबात कारवाई करण्याची काय गरज आहे? प्रथम, बर्याच साध्या प्रकरणांमध्ये (उदाहरणार्थ, जेव्हा आपल्याला फक्त 20-25 क्रमांकांची क्रमवारी लावायची असते) ते समाधानकारक असतात. दुसरे म्हणजे, या पद्धती आमच्यासाठी मनोरंजक आहेत कारण ते मॅन्युअल सॉर्टिंग करत असलेल्या व्यक्तीच्या नैसर्गिक वर्तनाचे मॉडेल करतात. या दोन पद्धती आहेत ज्यांचे स्पष्ट अल्गोरिदमच्या रूपात वर्णन केले जाते आणि सोप्या सॉफ्टवेअरची अंमलबजावणी होते.

चला निवड क्रमवारी पाहू.

निवड क्रमवारीत प्रथम अक्रमित अनुक्रमातून सर्वात लहान घटक निवडणे समाविष्ट असते. हा घटक पुढील प्रक्रियेतून वगळण्यात आला आहे, आणि उर्वरित घटकांचा क्रम मूळ म्हणून घेतला जातो आणि सर्व घटक निवडले जाईपर्यंत प्रक्रिया पुनरावृत्ती केली जाते. हे उघड आहे की निवडलेल्या घटकांचा क्रमबद्ध क्रम तयार होतो. मूळ क्रमामध्ये निवडलेला किमान घटक त्याच्या नियुक्त ठिकाणी अनेक प्रकारे क्रमाने ठेवला जातो:
1. i-th दृश्यानंतरचा किमान घटक i-th ठिकाणी हलविला जातो (i=1, 2, 3, दुसऱ्या ॲरेच्या, आणि जुन्या, मूळमध्ये, काही खूप मोठ्या संख्येच्या ठिकाणी ठेवला जातो. एक निवडलेला, क्रमवारी लावलेल्या एका ॲरेच्या कोणत्याही घटकापेक्षा जास्त आकाराने बदललेला ॲरे मूळ एक म्हणून घेतला जातो, आणि स्पष्टपणे, प्रक्रिया केलेल्या ॲरेचा आकार 1 कमी असतो मागील एक.
2. i-th दृश्यानंतरचा किमान घटक i-th ठिकाणी हलविला जातो (दिलेल्या ॲरेच्या i=1, 2, 3, आणि i-th ठिकाणाहून घटक निवडलेल्या ठिकाणी हलविला जातो. नंतर प्रत्येक पाहिल्यावर, क्रमबद्ध केलेले घटक (प्रथम ते अनुक्रमणिका i सह घटकापर्यंत) पुढील प्रक्रियेतून वगळले जातात, म्हणजे प्रत्येक त्यानंतरच्या प्रक्रिया केलेल्या ॲरेचा आकार आधीच्या आकारापेक्षा 1 कमी असतो.
ही क्रमवारी पद्धत सहसा डुप्लिकेट घटक नसलेल्या ॲरेसाठी वापरली जाते. हे ध्येय साध्य करण्यासाठी, आपण खालीलप्रमाणे कार्य करू शकता:
1) ॲरेचा कमाल घटक निवडा;
2) शेवटच्या घटकासह स्वॅप करा (यानंतर सर्वात मोठा घटक त्याच्या जागी राहील);
3) गुण पुन्हा करा. उर्वरित n-1 घटकांसह 1-2, म्हणजे, ॲरेचा भाग विचारात घ्या, पहिल्या घटकापासून उपांत्य घटकापर्यंत प्रारंभ करा, त्यातील कमाल घटक शोधा आणि उपांत्य घटकासह ते स्वॅप करा; (n-1) ॲरेचा वा घटक आणि असेच एक घटक त्याच्या जागी आधीपासून शिल्लक राहेपर्यंत.
एकूण, तुम्हाला क्रियांचा हा क्रम n-1 वेळा करावा लागेल. वर्गीकरण प्रक्रियेदरम्यान, ॲरेचा क्रमवारी लावलेला भाग वाढेल आणि क्रमवारी न केलेला भाग त्यानुसार कमी होईल.

तर, ही पद्धत कमाल (किमान) मूल्य आणि क्रमपरिवर्तन शोधण्यावर आधारित आहे. शिवाय, हे अल्गोरिदम आधीच तयार केले गेले आहेत आणि आम्ही फक्त त्यांच्यावर अवलंबून आहोत. म्हणून, या वर्गीकरण पद्धतीचा विचार करण्यापूर्वी, या समस्यांचे निराकरण लक्षात ठेवणे आवश्यक आहे. अल्गोरिदम संकलित करताना उद्भवणारी एकमेव अडचण ही आहे की आपण सारणी मूल्याच्या भागासह कार्य करत आहोत. उदाहरण म्हणून या अल्गोरिदमचा वापर करून, आम्ही सहाय्यक अल्गोरिदम किंवा प्रक्रियांचा वापर प्रदर्शित करू शकतो, कारण कमाल मूल्याचा शोध स्वतंत्र प्रोग्राम म्हणून ओळखला जाऊ शकतो, म्हणजे एक प्रक्रिया म्हणून.

या पद्धतीची अंमलबजावणी करणारे अल्गोरिदम परिशिष्ट 5 मध्ये चर्चा केले आहेत.
आपण विद्यार्थ्यांना ऑफर करू शकता:
1. केलेल्या A[I] प्रकारच्या तुलनांची संख्या मोजा< AF.
2. केलेल्या स्वॅप (A, B) प्रकाराच्या क्रमपरिवर्तनांची संख्या मोजा.
अल्गोरिदमच्या कार्यक्षमतेच्या दृष्टिकोनातून पहिल्या आणि दुसऱ्या पद्धतींचे विश्लेषण केल्यावर, जे कमीत कमी संख्येत बदल्या आणि तुलना केल्या जातात, विद्यार्थ्यांसह, तुम्ही निवड क्रमवारीची दुसरी, तिसरी पद्धत लिहून ठेवावी (परिशिष्ट पहा. ५).
ॲरे 30, 17, 73, 47, 22, 11, 65, 54 क्रमवारी लावण्यासाठी तिसरी पद्धत वापरून क्रमवारी लावण्याची प्रगती टेबलमध्ये दिसून येईल.

त्यानंतरच्या संगणक शास्त्राच्या धड्यांमध्ये, तुम्ही निवड वर्गीकरणाची शिकलेली पद्धत अधिक मजबूत करावी.

निवड क्रमवारी अल्गोरिदमच्या कार्यक्षमतेच्या प्रश्नाकडे परत परत आल्यावर, आम्ही स्थापित करू की मूळ ॲरेसाठी कमीत कमी क्रिया केल्या जातील, आधीच इच्छित क्रमाने क्रमवारी लावलेल्या. "विरुद्ध अर्थाने" क्रमवारी लावलेल्या मूळ ॲरेवर सर्वाधिक क्रिया केल्या जातील.

चला एक्सचेंज सॉर्टिंगचा विचार करूया ("बबल" पद्धत).

एक्सचेंज सॉर्ट ही एक पद्धत आहे ज्यामध्ये ॲरेच्या सर्व समीप घटकांची एकमेकांशी जोड्यांमध्ये तुलना केली जाते आणि मागील घटक त्यानंतरच्या घटकापेक्षा मोठा असल्यास स्वॅप केला जातो. परिणामी, कमाल घटक हळूहळू उजवीकडे हलविला जातो आणि अखेरीस ॲरेमध्ये त्याचे सर्वात उजवे स्थान घेते, त्यानंतर ते पुढील प्रक्रियेतून वगळले जाते. मग प्रक्रिया पुनरावृत्ती होते, आणि दुसरा सर्वात मोठा घटक त्याचे स्थान घेतो, ज्याला पुढील विचारातून देखील वगळण्यात आले आहे. संपूर्ण क्रम व्यवस्थित होईपर्यंत हे चालू राहते.
जर क्रमवारी केलेल्या संख्यांचा क्रम अनुलंब ठेवला असेल (पहिला घटक तळाशी असेल) आणि तुम्ही घटकांच्या हालचालींचे अनुसरण करत असाल (परिशिष्ट 6 मधील आकृती 2), तर तुम्ही पाहू शकता की पाण्यातील हवेचे फुगे, " योग्य स्थितीत फ्लोट करा. म्हणून, "सॉर्टिंग" ला "बबल" सॉर्टिंग किंवा "बबल" सॉर्टिंग असेही म्हणतात.
साधे एक्सचेंज क्रमवारी कोणत्याही ॲरेवर लागू केले जाऊ शकते.
म्हणून, एक्सचेंज क्रमवारीत, सर्व शेजारच्या घटकांची एकमेकांशी जोड्यांमध्ये तुलना केली जाते आणि जर मागील घटक नंतरच्या घटकापेक्षा मोठा असेल तर ते बदलले जातात. म्हणजेच, घटकांची पुनर्रचना करण्यासाठी आम्ही पुन्हा आधीच सिद्ध अल्गोरिदमवर अवलंबून आहोत.
या पद्धतीचे अधिक तपशीलवार वर्णन परिशिष्ट 6 मध्ये आहे.

"शेकर" - क्रमवारी लावणे.

वर केलेल्या सर्व सुधारणा असूनही, खालील (जवळजवळ ऑर्डर केलेले!) ॲरे 5, 7, 12, 28, 36, 85, 2 मध्ये बबल क्रमवारी लावण्यासाठी सात पास लागतील. हे या वस्तुस्थितीमुळे आहे की या पद्धतीचा वापर करून क्रमवारी लावताना, घटक एका पासमध्ये एकापेक्षा जास्त स्थानांवर डावीकडे जाऊ शकत नाही. म्हणून जर ॲरेचा किमान घटक उजव्या टोकाला असेल (विचाराधीन उदाहरणाप्रमाणे), तर जास्तीत जास्त पास करावे लागतील. म्हणून, "बबल" क्रमवारी पद्धतीमध्ये आणखी एक सुधारणा नैसर्गिकरित्या उद्भवते - पर्यायी दोन्ही दिशांनी ॲरेमधून जाते, आणि केवळ सुरुवातीपासून शेवटपर्यंत नाही. या प्रकरणात, क्रमवारीची वेळ किंचित कमी केली जाऊ शकते. या क्रमवारी पद्धतीला "शेकर" सॉर्टिंग म्हणतात (इंग्रजी शब्द शेक - शेक, शेक). त्याचे कार्य 8 घटकांच्या ॲरेचे वर्गीकरण करण्याच्या उदाहरणाद्वारे दर्शविले आहे (परिशिष्ट 7 मधील अंजीर 3 मध्ये). या पद्धतीचे अल्गोरिदम परिशिष्ट 7 मध्ये तपशीलवार वर्णन केले आहेत.

मोजणी क्रमवारी

या सोप्या आणि समजण्यास सोप्या पद्धतीमध्ये ॲरेच्या प्रत्येक घटकाची इतर सर्व घटकांशी तुलना करणे समाविष्ट आहे. क्रमवारी लावलेल्या ॲरेमधील प्रत्येक घटकाचे स्थान त्याच्यापेक्षा लहान घटकांच्या संख्येवर अवलंबून असते. दुसऱ्या शब्दांत, जर एखादा घटक 13 इतरांपेक्षा मोठा असेल, तर क्रमाने क्रमवारीत त्याचे स्थान 14 आहे. म्हणून, क्रमवारी लावण्यासाठी, तुम्हाला सर्व घटकांची जोड्यांमध्ये तुलना करावी लागेल आणि प्रत्येक घटकापेक्षा किती लहान आहेत हे मोजावे लागेल. यानंतर, मूळ ॲरेचे सर्व घटक त्यांच्या संबंधित ठिकाणी नवीन, खास तयार केलेल्या ॲरेमध्ये ठेवता येतात. मोजणी क्रमवारी अल्गोरिदम परिशिष्ट 8 मध्ये तपशीलवार वर्णन केले आहे.

अंतर्भूत क्रमवारी (थेट समावेश पद्धत).

इन्सर्शन सॉर्ट, साध्या सिलेक्शन सॉर्ट प्रमाणे, सामान्यत: डुप्लिकेट घटक नसलेल्या ॲरेसाठी वापरला जातो. थेट समावेशन पद्धतीनुसार क्रमवारी लावणे, वर वर्णन केलेल्या सर्वांप्रमाणे, चरणांमध्ये चालते. kth पायरीवर, असे मानले जाते की प्रथम k-1 घटक असलेल्या ॲरेचा भाग आधीच ऑर्डर केलेला आहे, म्हणजे, a< a< . . . < a. Далее необходимо взять k-й элемент и подобрать для него такое место в отсортированной части массива, чтобы после его вставки упорядоченность не нарушилась, то есть надо найти такое j (1<=j<=k-1), что a<=a[k]

या पद्धतीची परिशिष्ट 9 मध्ये अधिक तपशीलवार चर्चा केली आहे

4. अधिक जटिल आणि अधिक कार्यक्षम वर्गीकरण पद्धती.

ऑलिम्पियाडसह अधिक जटिल समस्या सोडवताना, मोठ्या डेटा सेटवर प्रक्रिया करणे आवश्यक आहे. मागील विभागात वर्णन केलेल्या समजण्यास सोप्या परंतु हळू-परफॉर्मिंग क्रमवारी पद्धती अव्यवहार्य बनल्या आहेत. विद्यार्थी वर्गीकरणाच्या इतर पद्धती शोधू लागतात. जेव्हा विद्यार्थ्यांमध्ये अधिक कार्यक्षम वर्गीकरण पद्धती नसतात तेव्हा या अधिक जटिल पद्धतींचा विचार केला जातो.
पाठपुरावा केलेले ध्येय: प्रभावी वर्गीकरण आणि शोध अल्गोरिदमची ओळख; पुनरावृत्ती प्रक्रिया आणि कार्ये अंमलबजावणी. द्रुत क्रमवारी पद्धतींचा अभ्यास क्लब आणि वैकल्पिक वर्गांमध्ये केला जातो.

विभाजनासह एक्सचेंज क्रमवारी (होरे क्रमवारी)

साधी विनिमय पद्धत ("बबल" पद्धत) वापरून क्रमवारी लावणे, सरासरी, सर्वात अकार्यक्षम आहे. हे या पद्धतीच्या अगदी कल्पनेमुळे आहे, ज्यासाठी क्रमवारी प्रक्रियेदरम्यान केवळ शेजारच्या घटकांची एकमेकांशी तुलना आणि देवाणघेवाण करणे आवश्यक आहे. एक्सचेंज-आधारित क्रमवारी पद्धत लक्षणीयरीत्या सुधारली जाऊ शकते. ही सुधारणा आज उपलब्ध असलेल्या सर्वोत्तम ॲरे सॉर्टिंग पद्धतीकडे नेत आहे, ज्याला एक्सचेंज विभाजन क्रमवारी म्हटले जाऊ शकते. हे एकमेकांपासून शक्य तितक्या मोठ्या अंतरावर असलेल्या घटकांची तुलना आणि देवाणघेवाण यावर आधारित आहे. 1962 मध्ये ही पद्धत प्रस्तावित केली. कारण या पद्धतीची कामगिरी प्रभावी आहे, लेखकाने याला "क्विक सॉर्ट" म्हटले आहे.
परिशिष्ट 10 मध्ये या पद्धतीची अधिक तपशीलवार चर्चा केली आहे.

क्रमवारी विलीन करा

ॲरे घटकांची क्रमवारी लावण्याची आणखी एक पद्धत आहे, ज्याची कार्यक्षमता तुलनेने जास्त आहे - विलीन करण्याची पद्धत.
ही क्रमवारी पद्धत शिकवण्यापूर्वी, विद्यार्थ्यांना खालील समस्या ऑफर करणे फॅशनेबल आहे, जे एकेकाळी ऑलिम्पियाड कार्य होते, परंतु आता नियमित धड्यांमध्ये सोडवले जाते:
आणि किमान संख्येच्या तुलनेत. विलीनीकरण पद्धत या समस्येच्या अल्गोरिदमवर आधारित आहे, जी विद्यार्थी स्वतः शिक्षकांकडून सूचना न देता सोडवू शकतात.
अर्थात, तुम्ही समाविष्ट करण्याची पद्धत वापरून समस्या सोडवू शकता - ॲरे B मध्ये ॲरेचा प्रत्येक घटक त्याच्या संबंधित ठिकाणी ठेवा. तथापि, या प्रकरणात तुलनांची संख्या n+m पेक्षा जास्त असेल.
समस्येचे निराकरण करण्याची पद्धत परिशिष्ट 11 मध्ये वर्णन केली आहे.

विलीनीकरण क्रमवारी पद्धतीमध्ये दिलेल्या ॲरेला अनेक भागांमध्ये विभाजित करणे समाविष्ट आहे, जे स्वतंत्रपणे क्रमवारी लावले जातात आणि नंतर एकामध्ये "विलीन" केले जातात.

अरे a ला k लांबीच्या भागांमध्ये विभागू द्या, नंतर पहिला भाग a[I], a , . . ., a [k], दुसरा - a, a,..., a आणि असेच. जर n ला k ने भाग जात नसेल तर शेवटच्या भागात k पेक्षा कमी घटक असतील.
एकदा पार्ट ॲरे ऑर्डर केल्यावर, तुम्ही त्यांना 2k पेक्षा जास्त घटक नसलेल्या ऑर्डर केलेल्या पार्ट ॲरेमध्ये एकत्र करू शकता, जे नंतर 4k पेक्षा जास्त लांबीच्या ऑर्डर केलेल्या ॲरेमध्ये एकत्र केले जातात आणि जोपर्यंत तुम्हाला एक ऑर्डर केलेला ॲरे मिळत नाही तोपर्यंत. अशा प्रकारे, या पद्धतीचा वापर करून क्रमवारी लावलेला ॲरे मिळविण्यासाठी, तुम्हाला ॲरेचे दोन ऑर्डर केलेले सेगमेंट एका ऑर्डर केलेल्या सेगमेंटमध्ये वारंवार “विलीन” करावे लागतील. तथापि, ॲरेचे इतर भाग प्रभावित होत नाहीत. या पद्धतीची पर्यायी सामग्री म्हणून परिशिष्ट 12 मध्ये अधिक तपशीलवार चर्चा केली आहे.

5. वर्गीकरण पद्धतींची तुलनात्मक वैशिष्ट्ये.

सोप्या पद्धतींपैकी एक - मोजणी पद्धत आठवूया. ही पद्धत, सुधारणा असूनही, घटकांच्या सर्व जोड्यांची तुलना करणे आवश्यक असल्याने, n घटकांच्या ॲरेचे वर्गीकरण करण्याचा कालावधी n2 च्या प्रमाणात असेल. समाविष्ट करणे, देवाणघेवाण आणि निवडीनुसार क्रमवारी लावण्याची पद्धत थोडी चांगली आहे, तथापि, त्यामध्ये, प्रक्रियेचा कालावधी देखील n2 च्या प्रमाणात आहे; त्याच वेळी, हे दर्शविले जाऊ शकते की द्रुत क्रमवारी किंवा हीप सॉर्ट सारख्या पद्धती वापरून ॲरे आयोजित करण्यात घालवलेला वेळ n log2n च्या प्रमाणात आहे, म्हणजे लक्षणीयरीत्या कमी. म्हणून, विचारात घेतलेल्या सर्व क्रमवारी पद्धती सोप्या (n2) आणि सुधारित, किंवा "लोगॅरिथमिक" (n log2n) मध्ये विभागल्या आहेत.
मुख्य वर्गीकरण पद्धतींचे तपशीलवार विश्लेषण कामांमध्ये केले गेले. ते एका विशिष्ट पद्धतीचे मूल्यांकन करण्यासाठी सूचक म्हणून वर्गीकरण करताना तुलनांची संख्या आणि घटकांच्या हालचालींची संख्या वापरतात. तथापि, ही वैशिष्ट्ये सायकल व्यवस्थापन इत्यादीसारख्या इतर ऑपरेशन्सवर घालवलेला वेळ विचारात घेत नाहीत. साहजिकच, वेगवेगळ्या पद्धतींची तुलना करण्याचा निकष म्हणजे वर्गीकरणावर घालवलेला वेळ. N. Wirth द्वारे क्रमवारी प्रक्रियेच्या अंमलबजावणीच्या वेळेचा डेटा प्राप्त झाला.
अर्थात, आधुनिक संगणक गणना केल्यावर जास्त वेगाने काम करतात, म्हणजे दिलेला डेटा जुना आहे. त्याच वेळी, विविध पद्धतींचे सापेक्ष कार्यप्रदर्शन सामान्यतः बदललेले नाही. परिशिष्ट 12 N. Wirth द्वारे दिलेल्या निकालांच्या आधारे प्राप्त केलेल्या क्रमवारी पद्धतींच्या नऊ प्रकारांची सापेक्ष वैशिष्ट्ये सादर करते.
सादर केलेला डेटा या पद्धतींमध्ये स्पष्ट फरक दाखवतो: n2 आणि n log2n. तक्ता 1 वरून हे पाहिले जाऊ शकते की सोप्या पद्धतींपैकी सर्वोत्तम म्हणजे समाविष्ट करणे क्रमवारी, आणि प्रगत पद्धतींमध्ये - द्रुत क्रमवारी.
एन. विर्थ खालील गोष्टी देखील नोंदवतात:
- "बबल" क्रमवारी सर्व तुलनात्मक पद्धतींमध्ये सर्वात वाईट आहे. त्याची सुधारित आवृत्ती - "शेकर" क्रमवारी - साध्या अंतर्भूत क्रमवारी आणि निवड क्रमवारीपेक्षा अजूनही वाईट आहे;
- क्विकसॉर्टचे वैशिष्ठ्य हे आहे की ते एका ॲरेची क्रमवारी उलट क्रमाने मांडलेल्या घटकांसह करते जसे की पुढे क्रमाने क्रमवारी लावली जाते.
हे जोडले पाहिजे की दिलेले परिणाम संख्यात्मक ॲरे वर्गीकरण करून प्राप्त झाले. जर ॲरे घटकांचे मूल्य "रेकॉर्ड" प्रकाराचा डेटा असेल, ज्यामध्ये सोबतचे फील्ड (घटक) संख्यात्मक फील्डपेक्षा 7 पट जास्त मेमरी व्यापतात ज्याद्वारे क्रमवारी लावली जाते, तर चित्र बदलेल.
तक्ता 2 "रेकॉर्ड" प्रकारातील डेटा ॲरे क्रमवारी लावण्यासाठी पद्धतींची तुलनात्मक वैशिष्ट्ये प्रदान करते.
हे स्पष्ट आहे
1) निवड क्रमवारी लक्षणीय फायदा देते आणि सोप्या पद्धतींपैकी सर्वोत्तम असल्याचे बाहेर वळते;
2) बबल क्रमवारी अजूनही सर्वात वाईट पद्धत आहे;
3) क्विकसॉर्टने सर्वात वेगवान पद्धत म्हणून त्याचे स्थान मजबूत केले आणि ते खरोखर सर्वोत्तम क्रमवारी अल्गोरिदम ठरले.

बाह्य क्रमवारीची वस्तू फाइल आहे. फाईलचा आकार मूलभूतपणे अमर्यादित आहे, म्हणजेच तो RAM मध्ये बसू शकत नाही. या प्रकारच्या क्रमवारीसाठी, बाह्य मेमरीचे अतिरिक्त खर्च कठोरपणे प्रमाणित केले जात नाहीत, म्हणून सहाय्यक फायली सक्रियपणे वापरल्या जातात. फाइल प्रवेश काटेकोरपणे अनुक्रमिक आहे. ही आवश्यकता दोन परिस्थितींमुळे आहे. प्रथम, चुंबकीय टेप सारख्या अनुक्रमिक ऍक्सेस उपकरणांवर फायली संचयित करताना बाह्य क्रमवारी पद्धती कार्यक्षम असणे आवश्यक आहे. दुसरे म्हणजे, थेट प्रवेश वापरताना, मुख्य वेळेचा खर्च फाईल पोझिशनिंगशी संबंधित असतो, जो दूर करणे इष्ट आहे.

बाह्य क्रमवारी पद्धती विलीन करण्याच्या प्रक्रियेवर आधारित आहेत, ज्यामध्ये दोन किंवा अधिक क्रमवारी लावलेले अनुक्रम एकत्र करणे समाविष्ट आहे. A आणि B हे दोन अनुक्रम C मध्ये विलीन करण्याच्या उदाहरणाचा वापर करून या प्रक्रियेचा विचार करू या. A आणि B घटकांना चढत्या क्रमाने क्रमवारी लावू द्या, म्हणजे 1 £ a 2 £ …£ a m आणि b 1 £ b 2 £ … £ b n . C हा क्रम चढत्या क्रमाने लावला जाणे आवश्यक आहे, म्हणजे c 1 £ c 2 £ …£ c m + n समाधानी आहे.

प्रथम, अनुक्रमांचे पहिले घटक वर्तमान म्हणून निवडले जातात. लहान एक C वर लिहिला जातो आणि त्याच क्रमाचा पुढील घटक त्याऐवजी चालू होतो. एक क्रम संपेपर्यंत या ऑपरेशनची पुनरावृत्ती केली जाते, त्यानंतर उर्वरित इतर अनुक्रम C मध्ये जोडला जातो.

आपण पाहू शकता की घटक A, B आणि C मध्ये प्रवेश काटेकोरपणे क्रमाने केला गेला होता. बाह्य क्रमवारी पद्धतींमध्ये, फायलींचे वर्गीकरण केलेले विभाग A, B आणि C या क्रमाने दिसतात.

बाह्य क्रमवारीची मूळ पद्धत ही सोपी मर्ज पद्धत आहे. खालील उदाहरणाचा वापर करून ते पाहू. 27, 16, 13, 11, 18, 25, 7 या घटकांचा समावेश असलेली फाइल A असू द्या. या फाइल्सवर पर्यायीपणे घटक लिहून ही फाइल B आणि C या दोन फाइल्समध्ये विभागली गेली आहे. हे आकृतीसह दाखवू

ब: 27, 13, 18, 7

A: 27, 16, 13, 11, 18, 25, 7

फायली B आणि C नंतर A आणि B मधील घटक C मध्ये वैकल्पिकरित्या समाविष्ट करून, प्रत्येक जोडीतील लहान घटक प्रथम ठेवून पुन्हा जोडल्या जातात. तुम्हाला पुढील परिणाम मिळेल

ब: 27, 13, 18, 7

जोड्या अपोस्ट्रॉफ्सद्वारे एकमेकांपासून विभक्त आहेत. पुढच्या टप्प्यावर, फाइल ए पुन्हा बी आणि सी मध्ये विभागली गेली आहे, परंतु वैयक्तिक घटक नाहीत, परंतु निवडलेल्या जोड्या प्रत्येक फाईलमध्ये बदलल्या जातात. आम्हाला मिळते

ब: 16, 27, '18, 25

A: 16, 27, '11, 13,' 18, 25, '7

ब: 16, 27, '18, 25

A: 11, 13, 16, 27, 7, 18, 25

फाइल A नंतर घटकांच्या चतुर्थांशांमध्ये वितरीत केली जाते आणि पुन्हा जोडल्यावर, क्रमबद्ध आठ घटकांचा समावेश असेल. आमच्या उदाहरणामध्ये, या टप्प्यावर क्रमवारी समाप्त होईल. सर्वसाधारणपणे, क्रमवारी लावलेल्या मालिकेची लांबी 2 च्या शक्तींमध्ये वाढेल जोपर्यंत मालिका आकार फाइलमधील घटकांच्या संख्येपेक्षा जास्त होत नाही.

हे उदाहरण वापरून, आम्ही बाह्य क्रमवारीच्या मूलभूत अटी परिभाषित करू. या पद्धतीमध्ये 3 फायलींचा समावेश होता, म्हणूनच त्याला थ्री-टेप म्हणतात. वर्गीकरण पूर्ण करण्यासाठी 3 पास लागले. एकाच पासमध्ये स्प्लिट आणि मर्ज रूटीन असतात, प्रत्येक घटकावर प्रक्रिया करतो. अशा प्रक्रियांना टप्पे म्हणतात. म्हणून, साधी संलयन पद्धत दोन-चरण आणि तीन-बँड आहे.

पद्धतीमध्ये स्पष्ट सुधारणा आहे. विलीनीकरणाचा परिणाम ताबडतोब दोन टेपमध्ये वितरीत केला जातो, म्हणजेच 4 टेप आधीपासूनच प्रक्रियेत गुंतलेले आहेत. अतिरिक्त मेमरीमुळे, पुनर्लेखन ऑपरेशन्सची संख्या निम्मी झाली आहे. ही एकल-फेज चार-बँड पद्धत आहे, ज्याला संतुलित संलयन देखील म्हणतात.

वरील डेटावरून पाहिल्याप्रमाणे, पद्धत सर्वात वेगवान अंतर्गत क्रमवारी पद्धतींशी स्पर्धा करू शकते, परंतु ती वापरली जात नाही, कारण त्यासाठी महत्त्वपूर्ण मेमरी खर्च आवश्यक आहे. पासच्या संख्येचा अंदाज लॉग 2 n द्वारे केला जातो आणि एकूण हस्तांतरणांची संख्या M n लॉग 2 n च्या प्रमाणात असते.

फाइल A पूर्ण किंवा अंशतः क्रमवारी लावलेल्या प्रकरणांमध्ये साधी विलीनीकरण पद्धत कोणताही फायदा देत नाही. नैसर्गिक संलयन पद्धतीमध्ये हा गैरसोय उपस्थित नाही.

a i, a i +1, …, a j, संबंधांचे समाधान करणाऱ्या a i -1 > a i £ a i +1 £ …£ a j > a j +1 या घटकांच्या क्रमाला आपण मालिका म्हणू या. विशेष प्रकरणांमध्ये, मालिका क्रमाच्या सुरूवातीस किंवा शेवटी असू शकते.

स्त्रोत फाइल A मालिकेत विभागली आहे. B आणि C चे वितरण मालिकेद्वारे केले जाते. कनेक्ट केल्यावर, मालिकांच्या जोड्या विलीन होतात. पुन्हा, पद्धतीची तीन-टेप आणि चार-टेप आवृत्ती दोन्ही शक्य आहे. खाली 4 टेपसह नैसर्गिक मर्ज क्रमवारीचे उदाहरण आहे.

ब: १७, २५, ४१, ‘६

A: 17, 25, 41, '9, 11, '6, '3, 5, 8, 44

C: 9, 11, '3, 5, 8, 44

A: 9, 11, 17, 25, 41 B: 3, 5, 6, 8, 9, 11, 17, 25, 41, 44

D: 3, 5, 6, 8, 44 C:

शेवटच्या स्प्लिटवर, C टेप रिकामा आहे आणि क्रमवारी लावलेली फाइल B टेपवर राहते.

नैसर्गिक विलीनीकरण पद्धत सामान्यतः वेगवान असते, परंतु अधिक तुलना करणे आवश्यक असते कारण त्यासाठी प्रत्येक रनचा शेवट निश्चित करणे आवश्यक असते. टू-फेज थ्री-टेप नॅचरल मर्ज पद्धतीचा वापर करून फाईलची क्रमवारी लावण्यासाठी खाली एक प्रोग्राम आहे.

प्रोग्राम सॉर्टस्लियन;

(3-बँड, 2-फेज नैसर्गिक विलीनीकरण क्रमवारी)

(की पूर्णांक आणि धनात्मक आहेत)

elem=record टाइप करा

(इतर फील्ड)

टेप = एलिमची फाइल;

नाव: स्ट्रिंग; (स्रोत फाइल नाव)

प्रक्रिया Vvod(var F: टेप);

तर के<>-1 करू

लिहा("पुढील की एंटर करा (शेवट -1):");

जर के<>-1 नंतर लिहा(F, S)

प्रक्रिया Pech(var F: टेप);

eof(F) करत नसताना

लिहा(एस. की," ")

प्रक्रिया CopyElem(var X, Y: टेप;

var बुफ: elem; var E: बुलियन);

(एक घटक कॉपी करणे आणि पुढील वाचणे

(Buf मध्ये मालिका चेकच्या शेवटी (E=True))

Eof(X) नसल्यास वाचा(X, Buf)

बाकी बफ.की:=-1; (अडथळा: फाईलचा शेवट गाठला)

ई:=(बुफ.की

प्रक्रिया CopySer(var X, Y: टेप; var Buf: elem);

(X ते Y पर्यंत मालिका कॉपी करणे)

(Buf च्या सुरुवातीला X वरील वर्तमान मालिकेतील पहिला घटक आहे)

(एंड बुफ - पुढचा पहिला घटक किंवा -1 (शेवट X))

जर Buf.Key>0 तर (फाइल X वाचली नाही)

CopyElem(X, Y, Buf, E)

ई पर्यंत (ई = मालिकेच्या शेवटी खरे)

प्रक्रिया वितरण;

(वितरण A --> B आणि C)

वाचा(A, S); (A चा पहिला घटक)

पुन्हा लिहा(बी); पुन्हा लिहा(C);

CopySer(A, B, S); (S पुढील मालिकेतील पहिला घटक आहे)

S.Key>0 असल्यास (फाइल A पूर्णपणे कॉपी केलेली नाही)

CopySer(A, C, S)

S.Key पर्यंत<0

प्रक्रिया स्लियन;

(B आणि C चे विलीनीकरण--->A)

E1, E2: बुलियन;

प्रक्रिया SlianSer;

(B आणि C ---> A पासून मालिका एकत्र करा)

(S आणि T हे मालिकेतील पहिले घटक आहेत)

(एस. की<0-весь файл B считан, T.Key<0-файл C считан }

E1:=असत्य; E2:=असत्य;

जर (S.Key>0) आणि ((S.Key

(फाइल बी वाचली गेली नाही आणि बी चा वर्तमान घटक सी पेक्षा लहान आहे किंवा फाइल सी पूर्णपणे वाचली गेली आहे)

CopyElem(B, A, S, E1);

जर E1 असेल तर (B वरील मालिकेचा शेवट झाला)

CopySer(C, A, T)

CopyElem(C, A, T, E2);

जर E2 असेल तर (सी वरील मालिकेचा शेवट झाला)

CopySer(B, A, S)

सुरुवात (स्लियनची सुरुवात)

नसल्यास (Eof(B) किंवा Eof(C)) नंतर

सुरू करा (दोन्ही फायली रिकाम्या नाहीत)

L:=0; (एपिसोड काउंटर)

(S.Key>0) किंवा (T.Key>0) करत असताना

सुरुवात (मुख्य कार्यक्रमाची सुरुवात)

लिहा("आयटम लिहिण्यासाठी फाईलचे नाव एंटर करा:");

नियुक्त करा (ए, नाव);

नियुक्त करा (B, "Rab1");

नियुक्त करा(C, "Rab2");

L:=0; (एल - विलीन झाल्यानंतर मालिकेची संख्या - पॅरामीटर)

WriteLn("फाइल A:"); पेच(ए);

रास्प्रेड; (वितरण टप्पा)

WriteLn("फाइल बी:"); पेच(बी);

WriteLn("फाइल C:"); पेच (सी);

ReadLn; (विराम द्या)

स्लियन (फ्यूजन फेज)

एल पर्यंत<=1; { L=0, если исходный файл отсортирован }

WriteLn("फाइल A शेवटी: ");

बंद (बी); पुसून टाका(बी); (कार्यरत फाइल्स हटवत आहे)

बंद (C); पुसून टाका (सी);

एक घटक टेप ते टेप कॉपीइलेम कॉपी करण्याच्या प्रक्रियेकडे लक्ष देणे योग्य आहे. प्रत्यक्षात, मागील प्रतमधून उरलेल्या RAM मधील घटक फाइलवर लिहिला जातो आणि या फाइलचा पुढील घटक मेमरीमध्ये वाचला जातो. हे मालिकेचा शेवट सतत तपासण्याची गरज असल्यामुळे आहे. जेव्हा मालिकेचा शेवट फाईलच्या समाप्तीशी जुळतो तेव्हा आम्हाला विशेषतः प्रकरण लक्षात घ्यावे लागेल. विलीन करताना, परिणामी मालिकांची संख्या मोजली जाते. फक्त एक मालिका शिल्लक असताना क्रमवारी समाप्त होते.

मल्टी-पाथ विलीनीकरण वापरून क्रमवारी कार्यक्षमता सुधारली जाऊ शकते, ज्यामध्ये k टेप्सवर वितरण केले जाते. प्रत्येक पासवरील मालिकेची संख्या k च्या घटकाने कमी होत असल्याने, M ची संख्या n log k n च्या प्रमाणात असते. जर टेप्सची एकूण संख्या सम असेल तर, एकल-फेज विलीनीकरण पद्धत वापरली जाऊ शकते, टेपच्या एका अर्ध्यापासून दुसर्यापर्यंत मालिका वितरीत करणे. मल्टीपाथ विलीनीकरणाची कार्यक्षमता वाढवण्याची किंमत, नेहमीप्रमाणे, अंमलबजावणीची जटिलता आणि अतिरिक्त बाह्य मेमरी खर्चात वाढ आहे.

विभाजनानंतर भागांची संख्या किती वेगळी असू शकते? पहिल्या दृष्टीक्षेपात असे दिसते की एकापेक्षा जास्त नाही, परंतु असे नाही. उदाहरणार्थ, 17, 25, 41, '9, 60, '50, 52, '7 मालिका वितरित करताना, पहिली आणि तिसरी मालिका एका सामान्य मालिकेत विलीन होते, जी दुसऱ्या आणि चौथ्या मालिकेसोबत होत नाही. परिणामी, त्यानंतरच्या विलीनीकरणादरम्यान, एका टेपवरील मालिका लवकर संपुष्टात येऊ शकते आणि कार्यक्षमता गमावून तुम्हाला उर्वरित टेप वाया घालवावा लागेल. अशा परिस्थिती मल्टीफेस सॉर्टिंग पद्धतीमध्ये विचारात घेतल्या जातात. उदाहरण म्हणून तीन टेप्स वापरून पाहू.

समजा B आणि C टेप A ला जोडताना B वरील मालिका आधी संपेल. नंतर टेप बी आउटपुट घोषित केले जाते, आणि टेप A इनपुट बनते. जेव्हा इनपुट टेपपैकी एकावरील मालिका संपते तेव्हा परिस्थितीची पुनरावृत्ती होईपर्यंत प्रक्रिया चालू राहते. मल्टीपॅथ विलीनीकरणासह मल्टीफेज क्रमवारी देखील शक्य आहे. उदाहरणार्थ, तुम्ही k टेप्स एका क्रमाने वापरत असल्यास, तुमच्याकडे नेहमी एक आउटपुट टेप असू शकतो. जेव्हा k-1 इनपुट टेपपैकी एकावरील रन्स संपतात, तेव्हा ती टेप मागील आउटपुट टेपऐवजी आउटपुट टेप बनते.

अंतर्गत आणि बाह्य क्रमवारी पद्धती एकत्रितपणे वापरल्या जाऊ शकतात. मोठ्या फाईलची क्रमवारी लावू द्या. RAM मध्ये जास्तीत जास्त संभाव्य आकाराचा बफर वाटप केला जातो. फाइल बफर आकाराशी संबंधित ब्लॉकमध्ये विभागली गेली आहे. ब्लॉक्स बफरमध्ये वाचले जातात, अंतर्गत वर्गीकरण पद्धतींपैकी एक वापरून क्रमवारी लावली जाते आणि दुसर्या फाईलमध्ये पुन्हा लिहिली जाते. आता नवीन फाईलचा प्रत्येक ब्लॉक बफरच्या आकारानुसार निश्चित मोठ्या लांबीची मालिका आहे. मालिका डेटा वापरून बाह्य क्रमवारी पद्धतींपैकी एक लागू करणे बाकी आहे.