പ്രോഗ്രാമിംഗിൽ ഡാറ്റ അടുക്കുന്നതിനുള്ള രീതികൾ. അറേകൾ അടുക്കുന്നതിനുള്ള രീതികൾ. സോർട്ടിംഗ് രീതികളുടെ താരതമ്യ സവിശേഷതകൾ

അടുക്കൽ രീതികൾ

വികസന സമയത്ത് സോഫ്റ്റ്വെയർമൂല്യങ്ങൾ അടുക്കുക എന്നതാണ് വളരെ സാധാരണമായ ഒരു പ്രവർത്തനം, അതായത്. ചില ക്രമത്തിൽ മൂലകങ്ങളുടെ ഒരു ലിസ്റ്റ് ക്രമീകരിക്കുന്നു (ഉദാഹരണത്തിന്, അക്ഷരമാലാക്രമത്തിലുള്ള പദങ്ങൾ അല്ലെങ്കിൽ ആരോഹണ അല്ലെങ്കിൽ അവരോഹണ ക്രമത്തിലുള്ള സംഖ്യകൾ).

ഘടകങ്ങൾ അടുക്കുന്നതിന് നിരവധി അൽഗോരിതങ്ങൾ ഉണ്ട്. അവയിൽ ഏറ്റവും ലളിതമായത് "ബബിൾ" രീതിയാണ്. രണ്ട് നെസ്റ്റഡ് ലൂപ്പുകളുടെ രൂപത്തിലാണ് അൽഗോരിതം നടപ്പിലാക്കുന്നത്. അകത്തെ ലൂപ്പിൽ, അറേയുടെ എല്ലാ ഘടകങ്ങളും ക്രമത്തിൽ നോക്കുന്നു, അടുത്തുള്ള മൂലകങ്ങളെ ജോഡികളായി താരതമ്യം ചെയ്യുന്നു, രണ്ടാമത്തേത് ആദ്യത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ (അവരോഹണ ക്രമത്തിൽ അടുക്കുമ്പോൾ), ഘടകങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നു. അകത്തെ ലൂപ്പിന്റെ പരാമീറ്റർ അറേ മൂലകത്തിന്റെ സൂചിക (നമ്പർ) ആണ്. ഒരു സമ്പൂർണ്ണ ക്രമത്തിന്, അത്തരം ഒരു ക്രമമാറ്റം n-1 തവണ നടത്തണം, ഇവിടെ n എന്നത് അറേയിലെ മൂലകങ്ങളുടെ എണ്ണമാണ്. ഇത് ചെയ്യുന്നതിന്, ഒരു ബാഹ്യ ലൂപ്പ് സംഘടിപ്പിക്കുന്നു, അതിന്റെ പാരാമീറ്റർ സോർട്ടിംഗ് ഘട്ടമാണ്.

ഉദാഹരണം. പൂർണ്ണസംഖ്യകളുടെ ഏകമാന ശ്രേണിയുടെ മൂലകങ്ങളെ ആരോഹണ ക്രമത്തിൽ അടുക്കുക.

മൂലകങ്ങളുടെ പുനഃക്രമീകരണത്തിന്റെ ക്രമം ചിത്രം 1 കാണിക്കുന്നു.

ചിത്രം 1. ബബിൾ സോർട്ടിംഗ്

നിർദിഷ്ട ഉദാഹരണത്തിൽ സോർട്ടിംഗ് നാല് ഘട്ടങ്ങളിലായാണ് പൂർത്തിയാക്കിയതെങ്കിലും, ഘടകങ്ങൾ പരിശോധിക്കുന്നത് രണ്ട് ആവർത്തനങ്ങൾ കൂടി തുടരും, കാരണം ആവർത്തനങ്ങളുടെ ആകെ എണ്ണം അറേ വലുപ്പത്തേക്കാൾ ഒന്ന് കുറവാണ്.

പരിഗണിക്കപ്പെടുന്ന അൽഗോരിതത്തിന്റെ ഒരു ബ്ലോക്ക് ഡയഗ്രം ചിത്രം 2 കാണിക്കുന്നു.

ചിത്രം 2. ബബിൾ സോർട്ട് അൽഗോരിതം ഫ്ലോചാർട്ട്

രണ്ട് വേരിയബിളുകൾക്കിടയിൽ മൂല്യങ്ങളുടെ കൈമാറ്റം അനുവദിക്കുന്നതിനാണ് m എന്ന വേരിയബിൾ അവതരിപ്പിച്ചത്, സോർട്ടിംഗ് ഘട്ടങ്ങൾക്ക് k ഉത്തരവാദിയാണ്.

ഈ അൽഗോരിതം ഉപയോഗിക്കുന്ന ഒരു C++ പ്രോഗ്രാം ഇതുപോലെ കാണപ്പെടും.

ചിത്രം 3. "ബബിൾ" രീതി ഉപയോഗിച്ച് അറേ ഘടകങ്ങൾ അടുക്കുന്നതിനുള്ള പ്രോഗ്രാം

ബബിൾ സോർട്ടിംഗ് കാരണം കാര്യക്ഷമമല്ലാത്ത രീതിയാണ് വലിയ സംഖ്യതാരതമ്യങ്ങൾ.

നേരിട്ടുള്ള തിരഞ്ഞെടുക്കൽ രീതി കൂടുതൽ ഫലപ്രദമാണ്

ആദ്യ ഘട്ടത്തിൽ മൂല്യങ്ങളുടെ മുഴുവൻ ലിസ്റ്റും തുടർച്ചയായി കാണുന്നതും അതിൽ നിന്ന് ഏറ്റവും കുറഞ്ഞതോ കൂടിയതോ ആയത് (സോർട്ടിംഗ് ഓർഡറിനെ ആശ്രയിച്ച്) തിരഞ്ഞെടുത്ത്, മുമ്പ് ഉണ്ടായിരുന്ന ഘടകവുമായി കൈമാറ്റം ചെയ്തുകൊണ്ട് അതിനെ ഒന്നാം സ്ഥാനത്ത് വയ്ക്കുന്നത് ഉൾപ്പെടുന്നു.

ഈ നടപടിക്രമം ആവർത്തിക്കുന്നു, എന്നാൽ ഏറ്റവും കുറഞ്ഞ (പരമാവധി) മൂല്യത്തിനായുള്ള തിരയൽ രണ്ടാം സ്ഥാനത്ത് നിന്ന് സംഭവിക്കുന്നു. ഈ അൽഗോരിതത്തിന്റെ ഡയഗ്രം ചിത്രം 4 ൽ അവതരിപ്പിച്ചിരിക്കുന്നു.

മൂല്യ സോഫ്റ്റ്‌വെയർ അടുക്കുന്നു

ചിത്രം 4. ഡയറക്ട് സെലക്ഷൻ സോർട്ടിംഗ്

നേരിട്ടുള്ള തിരഞ്ഞെടുക്കൽ രീതി ഉപയോഗിച്ച് സോർട്ടിംഗ് നടപ്പിലാക്കുന്ന പ്രോഗ്രാമിന്റെ ഒരു ഭാഗം ചുവടെ നൽകിയിരിക്കുന്നു.

// അറേ ഘടകങ്ങൾ ആരോഹണ ക്രമത്തിൽ അടുക്കുക

മൂല്യങ്ങൾ കൈമാറ്റം ചെയ്യുമ്പോൾ താൽക്കാലിക സംഭരണത്തിനായി int temp;// വേരിയബിൾ

int i;//ലൂപ്പ് കൺട്രോൾ വേരിയബിൾ (അറേ എലമെന്റ് നമ്പർ)

int k;//ലൂപ്പ് കൺട്രോൾ വേരിയബിൾ (ഘട്ട നമ്പർ അടുക്കുന്നു)

int nmin;//കുറഞ്ഞ മൂല്യ സംഖ്യ

വേണ്ടി (k=0; i< к 1; i++)

// മൂല്യങ്ങളുടെ പട്ടികയിലെ ഏറ്റവും കുറഞ്ഞ മൂലകത്തിന്റെ എണ്ണം നോക്കുക [ i ... n -1]

(i = k+1; i< n; i++)

എങ്കിൽ (ലിസ്റ്റ്[i]< list[ nmin ]) nmin = i;

//സ്വാപ്പ് ലിസ്റ്റ്[ nmin ] കൂടാതെ ലിസ്റ്റ്[ k ]

temp = ലിസ്റ്റ്[ nmin ];

ലിസ്റ്റ്[ nmin ]= ലിസ്റ്റ്[ k ];

ലിസ്റ്റ്[k] = temp;

ആന്തരിക ലൂപ്പിലെ ഏറ്റവും കുറഞ്ഞ മൂല്യത്തിനായുള്ള തിരയൽ പട്ടികയുടെ ബാക്കി ഭാഗങ്ങളിൽ സംഭവിക്കുന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

അവരോഹണ ക്രമത്തിൽ അടുക്കാൻ, ഏറ്റവും കുറഞ്ഞ മൂല്യത്തിന് പകരം ഓരോ ഘട്ടത്തിലും പരമാവധി മൂല്യം കണ്ടെത്തേണ്ടതുണ്ട്.

കഴിഞ്ഞ ദിവസം, VKontakte-ലെ അഭിപ്രായങ്ങളിൽ, പ്രോജക്റ്റിലെ മറ്റ് വിദ്യാർത്ഥികളിൽ ഒരാളുമായി എനിക്ക് വഴക്കുണ്ടായി. തർക്കത്തിന്റെ സാരാംശം "ആരാണ് വിജയിക്കുന്നത്" - java.util.Arays ക്ലാസിൽ നിന്നുള്ള സോർട്ട്() രീതി അല്ലെങ്കിൽ ലളിതമായ അൽഗോരിതങ്ങൾ സ്വയം എഴുതിയ നടപ്പാക്കലുകൾ: കുമിള(കുമിള), ഉൾപ്പെടുത്തൽ(ഉൾപ്പെടുത്തലുകൾ), തിരഞ്ഞെടുപ്പ്(തിരഞ്ഞെടുക്കൽ പ്രകാരം), ഷെൽ(ഷെൽ അൽഗോരിതം). ചിലർക്ക് ഉത്തരം ഈ ചോദ്യംവ്യക്തമാകാം, പക്ഷേ തർക്കം ഉടലെടുത്തതിനാൽ, ഓരോ കക്ഷികൾക്കും അവരുടെ കാഴ്ചപ്പാടിന് അനുകൂലമായ "ബഹുമാനമുള്ള സ്രോതസ്സുകൾ" ഉണ്ടായിരുന്നിട്ടും, ഒരു പഠനം നടത്താൻ തീരുമാനിച്ചു, പ്രക്രിയയിൽ ചാരനിറം നീട്ടി, വിവിധ അൽഗോരിതങ്ങൾ നടപ്പിലാക്കുന്നു . TL;DR: java.util.Arrays.sort() 100,000 മൂലകങ്ങളുടെ നിരകളിൽ നിരുപാധികമായി നയിക്കുന്നു ചെറിയ വലിപ്പംഷെല്ലിന്റെ രീതി ചിലപ്പോൾ അതിനോട് മത്സരിച്ചേക്കാം. പരിഗണിക്കപ്പെടുന്ന ബാക്കി അൽഗോരിതങ്ങൾ പൂർണ്ണമായും ശൂന്യമാണ്, ചില വിദേശ സാഹചര്യങ്ങളിൽ മാത്രമേ ഇത് ഉപയോഗപ്രദമാകൂ.ഇനി നമ്മുടെ സിലിക്കൺ uber-ഉപകരണങ്ങളിൽ അറേകൾ എങ്ങനെയാണ് അടുക്കുന്നത് എന്ന് നോക്കാം.

തിരഞ്ഞെടുക്കൽ തരം. തിരഞ്ഞെടുക്കൽ പ്രകാരം അടുക്കുന്നു

നമുക്ക് ഏറ്റവും ലളിതമായതിൽ നിന്ന് ആരംഭിക്കാം വ്യക്തമായ വഴി. അതിന്റെ സാരാംശം റോബർട്ട് സെഡ്‌ഗ്‌വിക്ക് കോഴ്‌സ്‌റയെക്കുറിച്ചുള്ള തന്റെ വീഡിയോ പ്രഭാഷണത്തിൽ നമുക്ക് നന്നായി പ്രദർശിപ്പിച്ചിരിക്കുന്നു (അവിടെ നിന്നുള്ള ആനിമേഷൻ ഞാൻ ഉദ്ധരിക്കാം, അത് ഞാൻ ഒരു gif-ലേക്ക് മോശമായി കംപ്രസ്സുചെയ്‌തു): ആദ്യ ഘടകത്തിൽ നിന്ന് അറേയിലൂടെ ഓടുമ്പോൾ, ഞങ്ങൾ തിരയുന്നു ഓരോ ഘട്ടത്തിലും വലതുവശം ഏറ്റവും കുറഞ്ഞ ഘടകം, അതുപയോഗിച്ച് ഞങ്ങൾ നിലവിലുള്ളത് സ്വാപ്പ് ചെയ്യുന്നു. തൽഫലമായി, അടുക്കിയ രൂപത്തിൽ ഞങ്ങളുടെ അറേയുടെ അന്തിമ പതിപ്പ് ഞങ്ങൾ റിസർവ് ചെയ്യുന്നു. ജാവയിൽ ഈ അൽഗോരിതം നടപ്പിലാക്കുന്ന കോഡ് ഇതാ: പബ്ലിക് വോയിഡ് സോർട്ട് (int അറേ) (int n = അറേ. നീളം; (int i = 0 ; i< n; i ++ ) { int minIndex = min (array, i, n - 1 ) ; swap (array, i, minIndex) ; } } public static void swap (int array, int i, int j) { int temp = array[ i] ; array[ i] = array[ j] ; array[ j] = temp; } public static int min (int array, int begin, int end) { int minVal = array[ begin] ; int minIndex = begin; for (int i = begin + 1 ; i <= end; i++ ) { if (array[ i] < minVal) { minVal = array[ i] ; minIndex = i; } } return minIndex; } Анализ алгоритма показывает, что необходимо на каждом проходе прошерстить весть остаток массива, то есть нам понадобится ровно N + (N-1) + (N-2) + … + 1 = N^2/2 сравнений. Таким образом, сложность алгоритма составляет O(N^2). Что же это означает? А означает это, что, увеличив количество элементов в массиве (N) в 2 раза, мы увеличим время работы алгоритма не в 2, а в 2^2 = 4 раза. Увеличив N в 10 раз, время работы увеличим в 100 раз и так далее. На моем ноутбуке 2012 года с процессором Core i3 под Ubuntu 14.4 я получил следующее время работы:

ഉൾപ്പെടുത്തൽ അടുക്കുക. ഉൾപ്പെടുത്തൽ അടുക്കുക

ഇവിടെ ആശയം അല്പം വ്യത്യസ്തമാണ്. വീണ്ടും, നമുക്ക് ഡോക്ടർ സെഡ്ഗ്വിക്കിൽ നിന്നുള്ള ആനിമേഷനിലേക്ക് തിരിയാം: മുന്നിലുള്ളത് ഇതുവരെ നമ്മൾ കണ്ടിട്ടില്ല, നമ്മൾ ഉപേക്ഷിക്കുന്നതെല്ലാം എല്ലായ്പ്പോഴും ക്രമത്തിൽ തുടരും. യഥാർത്ഥ അറേയുടെ ഓരോ പുതിയ ഘടകവും ഒരു ചെറിയ ഘടകത്തിൽ "വിശ്രമിക്കുന്നത്" വരെ ഞങ്ങൾ തുടക്കത്തിലേക്ക് "മടങ്ങുന്നു" എന്നതാണ് കാര്യം. അങ്ങനെ, നമുക്ക് വീണ്ടും N പാസുകൾ ഉണ്ട് (ഒറിജിനൽ അറേയുടെ ഓരോ ഘടകത്തിനും), എന്നാൽ ഓരോ പാസിലും, മിക്ക കേസുകളിലും, ഞങ്ങൾ ബാക്കിയുള്ളത് മുഴുവൻ നോക്കുന്നില്ല, മറിച്ച് ഒരു ഭാഗം മാത്രം. അതായത്, നമുക്ക് ഓപ്‌ഷൻ 1 + (N-1) + (N-2) + ... + N = N^2/2 ലഭിക്കും ഇൻപുട്ടിന്റെ "റിവേഴ്സ്" അറേ (നിർഭാഗ്യം, നിർഭാഗ്യം). ഇതിനകം അടുക്കിയ അറേയുടെ കാര്യത്തിൽ (ഇവിടെ ഭാഗ്യം) ഒരു പൂർണ്ണമായ സൗജന്യം ഉണ്ടാകും - ഓരോ പാസിലും ഒരു താരതമ്യവും മൂലകത്തെ സ്ഥാനത്ത് വിടുന്നതും, അതായത്, അൽഗോരിതം N ന് ആനുപാതികമായ സമയത്തിൽ പ്രവർത്തിക്കും. സങ്കീർണ്ണത അൽഗോരിതം നിർണ്ണയിക്കുന്നത് ഏറ്റവും മോശം സൈദ്ധാന്തിക സാഹചര്യം, അതായത് O(N^2). ശരാശരി, പ്രവർത്തന സമയം N^2/4 ന് ആനുപാതികമായിരിക്കും, അതായത് മുമ്പത്തെ അൽഗോരിതത്തിന്റെ ഇരട്ടി വേഗത. എന്റെ നടപ്പാക്കലിൽ, ക്രമപ്പെടുത്തലിന്റെ ഒപ്റ്റിമൽ ഉപയോഗം കാരണം, റണ്ണിംഗ് സമയം സെലക്ഷനേക്കാൾ കൂടുതലായിരുന്നു. പോസ്റ്റ് ഉടൻ തിരുത്താനും അപ്ഡേറ്റ് ചെയ്യാനും ഞാൻ ആഗ്രഹിക്കുന്നു. അതേ മെഷീനിൽ ഇത് പ്രവർത്തിപ്പിക്കുന്നതിന്റെ കോഡും ഫലവും ഇതാ: പബ്ലിക് ശൂന്യമായ സോർട്ട് (int array) ( int length = array. length; for (int i = 1 ; i< length; i++ ) { for (int j = i; j >= 1 ; j-- ) ( എങ്കിൽ (അറേ[ j]< array[ j - 1 ] ) swap (array, j, j - 1 ) ; else break ; } } }

ഷെൽ അടുക്കുക. ഷെൽ അടുക്കുക

ഒരു മിടുക്കനായ ഡൊണാൾഡ് ഷെൽ, 1959-ൽ വീണ്ടും ശ്രദ്ധിച്ചു, ഉൾപ്പെടുത്തലുകൾക്കുള്ള അൽഗോരിതത്തിലെ ഏറ്റവും ചെലവേറിയ കേസുകൾ, ഘടകം അറേയുടെ തുടക്കത്തിലേക്ക് വളരെ അകലെ തിരിച്ചെത്തുമ്പോഴാണ്: ചില പാസുകളിൽ ഞങ്ങൾ മൂലകത്തെ രണ്ട് സ്ഥാനങ്ങളിൽ നിന്ന് തുടക്കത്തിലേക്ക് തിരികെ കൊണ്ടുവരുന്നു. , മറ്റൊരു പാസിൽ ഏതാണ്ട് മുഴുവൻ അറേയിലൂടെയും തുടക്കത്തിലേക്കുള്ള ദൂരം വളരെ ദൂരെയാണ്. നിരവധി ഘടകങ്ങളിലൂടെ ചാടി ഇത് ഒരേസമയം ചെയ്യാൻ കഴിയുമോ? അവൻ അത്തരമൊരു വഴി കണ്ടെത്തി. പ്രത്യേക ഭാഗിക തരങ്ങളുടെ തുടർച്ചയായ നിർവ്വഹണത്തിൽ ഇത് അടങ്ങിയിരിക്കുന്നു പൊതുവായ കാഴ്ച d-sort അല്ലെങ്കിൽ, Sedgwick പ്രകാരം, h-sort (ഞാൻ h എന്നാൽ ഹോപ്പ് എന്ന് സംശയിക്കുന്നു). 3-സോർട്ട്, ഉദാഹരണത്തിന്, സംശയാസ്‌പദമായ ഘടകത്തെ മുമ്പത്തേതുമായി താരതമ്യം ചെയ്യും, എന്നാൽ രണ്ടെണ്ണം ഒഴിവാക്കി ഒരു 3 സ്ഥാനവുമായി താരതമ്യം ചെയ്യും. മാറ്റിയാൽ, അത് വീണ്ടും എലമെന്റ് 3 പൊസിഷനുകളുമായി താരതമ്യം ചെയ്യും. തത്ഫലമായുണ്ടാകുന്ന അറേ "3-സോർട്ടഡ്" ആയിരിക്കും, അതായത്, മൂലകങ്ങളുടെ തെറ്റായ സ്ഥാനം 3 സ്ഥാനങ്ങളിൽ കുറവായിരിക്കും എന്നതാണ് പ്രധാന കാര്യം. ഈ ഉൾപ്പെടുത്തൽ അൽഗോരിതം ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് എളുപ്പവും മനോഹരവുമായിരിക്കും. വഴിയിൽ, “1-സോർട്ട്” എന്നത് ഒരു ഇൻസേർഷൻ അൽഗോരിതം എന്നതിലുപരി മറ്റൊന്നുമല്ല =) h മൂല്യങ്ങൾ കുറയുന്ന ശ്രേണിയിലേക്ക് തുടർച്ചയായി h-sort പ്രയോഗിക്കുന്നതിലൂടെ, നമുക്ക് ഒരു വലിയ അറേ വേഗത്തിൽ അടുക്കാൻ കഴിയും. ഇത് എങ്ങനെ കാണപ്പെടുന്നുവെന്നത് ഇതാ: എങ്ങനെ തിരഞ്ഞെടുക്കാം എന്നതാണ് ഇവിടെ ബുദ്ധിമുട്ട് ശരിയായ ക്രമംഭാഗിക തരം. ആത്യന്തികമായി, അൽഗോരിതത്തിന്റെ പ്രകടനം ഇതിനെ ആശ്രയിച്ചിരിക്കുന്നു. ഏറ്റവും സാധാരണമായത് ഡൊണാൾഡ് നൂത്ത് നിർദ്ദേശിച്ച ക്രമമാണ്: h = h*3 + 1, അതായത്, 1, 4, 13, 40, ... അങ്ങനെ അറേ വലുപ്പത്തിന്റെ 1/3 വരെ. ഈ സീക്വൻസ് മാന്യമായ പ്രകടനം നൽകുന്നു കൂടാതെ നടപ്പിലാക്കാൻ എളുപ്പവുമാണ്. അൽഗോരിതത്തിന്റെ വിശകലനത്തിന് ടൺ കണക്കിന് ഭാഷ ആവശ്യമാണ്, അത് എന്റെ കഴിവിന് അപ്പുറമാണ്. വിശകലനത്തിന്റെ വീതിയും നിർണ്ണയിക്കുന്നത് h സീക്വൻസുകളുടെ പല വകഭേദങ്ങളും ആണ്. അനുഭവപരമായി, അൽഗോരിതത്തിന്റെ വേഗത വളരെ മികച്ചതാണെന്ന് നമുക്ക് പറയാൻ കഴിയും - സ്വയം കാണുക: ഒരു സെക്കന്റിൽ താഴെയുള്ള ഒരു ദശലക്ഷം ഘടകങ്ങൾ! നട്ട് സീക്വൻസുള്ള ജാവ കോഡ് ഇതാ. പൊതു ശൂന്യമായ സോർട്ട് (int array) (int h = 1 ; while (h* 3< array. length) h = h * 3 + 1 ; while (h >= 1 ) (hSort (array, h) ; h = h/ 3< length; i++ ) { for (int j = i; j >= h; j = j - h) ( എങ്കിൽ (അറേ[ j]< array[ j - h] ) swap (array, j, j - h) ; else break ; } } }

ബബിൾ അടുക്കുക. ബബിൾ രീതി

ഇതൊരു ക്ലാസിക് ആണ്! മിക്കവാറും എല്ലാ പുതിയ പ്രോഗ്രാമർമാരും ഈ അൽഗോരിതം നടപ്പിലാക്കുന്നു. ഡോ. സെഡ്‌വിക്കിന് അതിനുള്ള ഒരു ആനിമേഷൻ പോലും ഇല്ലാത്തതിനാൽ ഇത് ഒരു ക്ലാസിക് ആണ്, അതിനാൽ ഞാൻ തന്നെ ആ ജോലി ചെയ്യേണ്ടിവന്നു. ഇവിടെ, ഓരോ പാസിലും, ഞങ്ങൾ ആദ്യം മുതൽ അവസാനം വരെ അറേയിലൂടെ സഞ്ചരിക്കുന്നു, ക്രമരഹിതമായ അയൽ ഘടകങ്ങൾ മാറ്റി. തൽഫലമായി, ഏറ്റവും വലിയ ഘടകങ്ങൾ അറേയുടെ അവസാനം വരെ "ഫ്ലോട്ട്" (അതിനാൽ പേര്). അറേ ഇതിനകം അടുക്കിക്കഴിഞ്ഞു (ക്രമീകരിച്ചത് = ശരി) എന്ന പ്രതീക്ഷയിൽ ഞങ്ങൾ ഓരോ പുതിയ പാസും ശുഭാപ്തിവിശ്വാസത്തോടെ ആരംഭിക്കുന്നു. ഖണ്ഡികയുടെ അവസാനം, നമുക്ക് തെറ്റ് പറ്റിയതായി കണ്ടാൽ, ഞങ്ങൾ ഒരു പുതിയ ഭാഗം ആരംഭിക്കുന്നു. ഇവിടെയുള്ള ബുദ്ധിമുട്ട്, വീണ്ടും, ഓരോ ചുരത്തിലും ഞങ്ങൾ മുഴുവൻ അറേയും (ഏതാണ്ട്) സഞ്ചരിക്കുന്നു എന്നതാണ്. താരതമ്യം ഓരോ ഘട്ടത്തിലും സംഭവിക്കുന്നു, കൈമാറ്റം മിക്കവാറും എല്ലാ ഘട്ടങ്ങളിലും സംഭവിക്കുന്നു ഈ അൽഗോരിതംഏറ്റവും മന്ദഗതിയിലുള്ള ഒന്ന് (യുക്തിസഹമായി നടപ്പിലാക്കിയവയെ ഞങ്ങൾ പരിഗണിക്കുകയാണെങ്കിൽ, "കുലുക്കി തരം" അല്ലാത്തതും അതുപോലെയുള്ളവയും). ഔപചാരികമായി ഇവിടെ സങ്കീർണ്ണതയും O (N^2) ന് തുല്യമായിരിക്കും എന്നത് രസകരമാണ്, എന്നാൽ ഉൾപ്പെടുത്തലുകളേക്കാളും തിരഞ്ഞെടുക്കലുകളേക്കാളും ഗുണകം വളരെ കൂടുതലാണ്. അൽഗോരിതം കോഡ്: പൊതു ശൂന്യമായ അടുക്കൽ (ഇന്റ് അറേ) (ബൂലിയൻ സോർട്ടഡ്; int nMinusOne = അറേ. നീളം - 1 ; (int i = 0 ; i< nMinusOne; i++ ) { isSorted = true ; for (int j = 0 ; j < nMinusOne - i; j++ ) { if (array[ j] >അറേ[ j + 1 ] ) ( സ്വാപ്പ് (അറേ, ജെ, ജെ + 1 ); isSorted = തെറ്റ് ; )) എങ്കിൽ (ഇസ്സോർട്ടഡ്) മടങ്ങുക ; ) ) പ്രവർത്തന സമയം: വ്യത്യാസം അനുഭവിക്കുക: ഒരു ദശലക്ഷം മൂലകങ്ങളിൽ അരമണിക്കൂറിലധികം! ഉപസംഹാരം: ഈ അൽഗോരിതം ഒരിക്കലും ഉപയോഗിക്കരുത്!!!

ആദ്യ ഭാഗത്തിന്റെ സംഗ്രഹം

തൽഫലമായി, ഈ അൽഗോരിതങ്ങൾക്കായി പൊതുവായ പട്ടിക നോക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. നിങ്ങൾക്ക് അന്തർനിർമ്മിത java.util.Arrays.sort() രീതിയുടെ ഫലങ്ങളുമായി താരതമ്യം ചെയ്യാം. ഇത് ഒരുതരം മാന്ത്രികവിദ്യ പോലെ തോന്നുന്നു - ഷെല്ലിനെക്കാൾ വേഗതയുള്ളത് എന്താണ്? ഇതിനെക്കുറിച്ച് അടുത്ത ഭാഗത്തിൽ എഴുതാം. അവിടെ ഞങ്ങൾ വ്യാപകമായി ഉപയോഗിക്കുന്ന ദ്രുത അടുക്കൽ അൽഗോരിതങ്ങൾ നോക്കും, അതുപോലെ ലയിപ്പിക്കൽ അടുക്കുക, പ്രാകൃതങ്ങളുടെയും റഫറൻസ് തരങ്ങളുടെയും ശ്രേണികൾ അടുക്കുന്നതിനുള്ള രീതികളിലെ വ്യത്യാസത്തെക്കുറിച്ച് മനസിലാക്കുക, കൂടാതെ താരതമ്യപ്പെടുത്താവുന്ന ഇന്റർഫേസുമായി പരിചയപ്പെടുകയും ചെയ്യും, ഇത് ഈ വിഷയത്തിൽ വളരെ പ്രധാനമാണ്;) പട്ടിക ഡാറ്റ പ്രകാരം ഒരു ലോഗരിഥമിക് സ്കെയിലിൽ നിർമ്മിച്ച ഒരു ഗ്രാഫ് നിങ്ങൾക്ക് ചുവടെ പഠിക്കാം. ലൈൻ പരന്നാൽ, മികച്ച അൽഗോരിതം =) മുഴുവൻ പ്രോജക്റ്റും ഡൗൺലോഡ് ചെയ്യാനും സ്വന്തമായി ടെസ്റ്റുകൾ നടത്താനും ആഗ്രഹിക്കുന്നവർക്ക്, ലിങ്ക് സൂക്ഷിക്കുക: ജാവ അടുത്ത ഭാഗത്തിൽ കാണാം! =) പ്രാഥമിക വർഗ്ഗീകരണ രീതികൾഅൽഗോരിതങ്ങൾ അടുക്കുന്നതിനുള്ള ഞങ്ങളുടെ ആദ്യ ഉല്ലാസയാത്ര എന്ന നിലയിൽ, ചെറിയ ഫയലുകൾക്കോ പ്രത്യേക ഘടനകളുള്ള ഫയലുകൾക്കോ നന്നായി പ്രവർത്തിക്കുന്ന ചില "എലിമെന്ററി" രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഇവ പഠിക്കാൻ പല കാരണങ്ങളുണ്ട് ലളിതമായ രീതികൾ. ഒന്നാമതായി, സോർട്ടിംഗ് അൽഗോരിതങ്ങളുടെ ടെർമിനോളജിയും അടിസ്ഥാന പ്രവർത്തനങ്ങളും പഠിക്കാൻ താരതമ്യേന വേദനയില്ലാത്ത ഒരു മാർഗം അവർ നൽകുന്നു, ഇത് കൂടുതൽ സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ പഠിക്കുന്നതിന് ആവശ്യമായ അടിത്തറ നൽകുന്നു. രണ്ടാമതായി, പല സോർട്ടിംഗ് പ്രശ്നങ്ങൾക്കും കൂടുതൽ സങ്കീർണ്ണമായവയെക്കാൾ ലളിതമായ രീതികൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്. സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ. അവസാനമായി, ചില ലളിതമായ രീതികൾ കൂടുതൽ വിപുലീകരിക്കാൻ കഴിയും നല്ല രീതികൾഅല്ലെങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായവ മെച്ചപ്പെടുത്താൻ അവ ഉപയോഗിക്കുക.ചില സോർട്ടിംഗ് പ്രോഗ്രാമുകളിൽ, ലളിതമായ അൽഗോരിതങ്ങൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്. സോർട്ടിംഗ് പ്രോഗ്രാമുകൾ പലപ്പോഴും ഒരു തവണ മാത്രമേ ഉപയോഗിക്കൂ (അല്ലെങ്കിൽ നിരവധി തവണ). അടുക്കേണ്ട മൂലകങ്ങളുടെ എണ്ണം വലുതല്ലെങ്കിൽ (പറയുക, 500 മൂലകങ്ങളിൽ കുറവ്), സങ്കീർണ്ണമായ ഒരു അൽഗോരിതം വികസിപ്പിക്കുകയും ഡീബഗ്ഗുചെയ്യുകയും ചെയ്യുന്നതിനേക്കാൾ ലളിതമായ അൽഗോരിതം ഉപയോഗിക്കുന്നത് കൂടുതൽ കാര്യക്ഷമമായിരിക്കും. എലിമെന്ററി രീതികൾ എല്ലായ്പ്പോഴും ചെറിയ ഫയലുകൾക്ക് അനുയോജ്യമാണ് (പറയുക, 50 ഘടകങ്ങളിൽ ചെറുത്); ക്രമപ്പെടുത്തേണ്ട ആവശ്യമില്ലെങ്കിൽ, അത്തരം ഫയലുകൾക്കായി സങ്കീർണ്ണമായ ഒരു അൽഗോരിതം ഉപയോഗിക്കുന്നത് ബുദ്ധിപരമാകാൻ സാധ്യതയില്ല. ഒരു വലിയ സംഖ്യഅത്തരം ഫയലുകൾ. ചട്ടം പോലെ, പ്രാഥമിക രീതികൾ, ഞങ്ങൾ ചർച്ച ചെയ്യും, അടുക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങളെക്കുറിച്ച് നടത്തുക എൻക്രമരഹിതമായി തിരഞ്ഞെടുത്ത ഘടകങ്ങൾ. എങ്കിൽ എൻവേണ്ടത്ര ചെറുതാണ്, ഇത് ഒരു പ്രശ്നമായിരിക്കില്ല, കൂടാതെ ഘടകങ്ങൾ ക്രമരഹിതമായി വിതരണം ചെയ്യപ്പെടുന്നില്ലെങ്കിൽ, ഈ അൽഗോരിതങ്ങൾക്ക് സങ്കീർണ്ണമായതിനേക്കാൾ വേഗത്തിൽ പ്രവർത്തിക്കാൻ കഴിയും. എന്നിരുന്നാലും, ഓർക്കേണ്ട കാര്യം, വലിയതും ക്രമരഹിതമായി ഓർഡർ ചെയ്തതുമായ ഫയലുകൾക്കായി ഈ അൽഗോരിതങ്ങൾ ഉപയോഗിക്കരുത്, ഒരു അപവാദം ഷെൽ സോർട്ട് അൽഗോരിതം ആണ്, ഇത് പലപ്പോഴും പല പ്രോഗ്രാമുകളിലും ഉപയോഗിക്കുന്നു. കളിയുടെ നിയമങ്ങൾ

ഏതെങ്കിലും പ്രത്യേക അൽഗോരിതം നോക്കുന്നതിന് മുമ്പ്, പദാവലിയും അൽഗോരിതങ്ങൾ അടുക്കുന്നതിനെക്കുറിച്ചുള്ള ചില അടിസ്ഥാന കൺവെൻഷനുകളും പഠിക്കുന്നത് ഉപയോഗപ്രദമാകും. അടുക്കുന്നതിനുള്ള അൽഗോരിതങ്ങൾ ഞങ്ങൾ പഠിക്കും റെക്കോർഡിംഗ് ഫയലുകൾഅടങ്ങുന്ന കീകൾ. ഒരു റെക്കോർഡിന്റെ ഭാഗം മാത്രമായ കീകൾ (പലപ്പോഴും അതിന്റെ വളരെ ചെറിയ ഭാഗം) സോർട്ടിംഗ് പ്രക്രിയ നിയന്ത്രിക്കാൻ ഉപയോഗിക്കുന്നു. ഒരു സോർട്ടിംഗ് അൽഗോരിതത്തിന്റെ ഉദ്ദേശ്യം, ഒരു ഫയലിലെ റെക്കോർഡുകൾ പുനഃസംഘടിപ്പിക്കുക എന്നതാണ്, അതിലൂടെ അവ കർശനമായി നിർവചിക്കപ്പെട്ട ക്രമത്തിൽ (സാധാരണയായി അക്ഷരമാലാക്രമത്തിലോ സംഖ്യയിലോ) ദൃശ്യമാകും.

അടുക്കേണ്ട ഫയൽ പൂർണ്ണമായി മെമ്മറിയിലേക്ക് യോജിച്ചാൽ (അല്ലെങ്കിൽ ഒരു അറേയിൽ പൂർണ്ണമായി യോജിക്കുന്നു), അതിന് ഞങ്ങൾ ഉപയോഗിക്കുന്നു ആന്തരികംസോർട്ടിംഗ് രീതികൾ. ഒരു ടേപ്പിൽ നിന്നോ ഡിസ്കിൽ നിന്നോ ഡാറ്റ അടുക്കുന്നതിനെ വിളിക്കുന്നു ബാഹ്യമായഅടുക്കുന്നു. അവ തമ്മിലുള്ള പ്രധാന വ്യത്യാസം, ആന്തരിക സോർട്ടിംഗ് ഉപയോഗിച്ച്, ഏത് റെക്കോർഡും എളുപ്പത്തിൽ ആക്സസ് ചെയ്യാൻ കഴിയും എന്നതാണ്, അതേസമയം ബാഹ്യ സോർട്ടിംഗിനൊപ്പം, നമുക്ക് റെക്കോർഡുകൾ തുടർച്ചയായി അല്ലെങ്കിൽ വലിയ ബ്ലോക്കുകളിൽ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. നമ്മൾ നോക്കുന്ന സോർട്ടിംഗ് അൽഗോരിതങ്ങളിൽ ഭൂരിഭാഗവും ആന്തരികമാണ്.

സാധാരണയായി, ഒരു അൽഗോരിതത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള പ്രധാന കാര്യം അതിന്റെ പ്രവർത്തന സമയമാണ്. N മൂലകങ്ങൾ അടുക്കുന്നതിനായി ഞങ്ങൾ നോക്കുന്ന ആദ്യത്തെ നാല് അൽഗോരിതങ്ങൾക്ക് ആനുപാതികമായ പ്രവർത്തന സമയമുണ്ട്, അതേസമയം കൂടുതൽ സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ ആനുപാതികമായ പ്രവർത്തന സമയം ഉപയോഗിക്കുന്നു. (കീകൾ തമ്മിലുള്ള താരതമ്യത്തേക്കാൾ കുറച്ച് സോർട്ടിംഗ് അൽഗോരിതം ഉപയോഗിക്കാനാവില്ലെന്ന് കാണിക്കാം.) ലളിതമായ രീതികൾ പര്യവേക്ഷണം ചെയ്ത ശേഷം, റണ്ണിംഗ് സമയം ആനുപാതികമായ കൂടുതൽ സങ്കീർണ്ണമായ രീതികളും മൊത്തം പ്രവർത്തന സമയം കുറയ്ക്കുന്നതിന് കീകളുടെ ബൈനറി ഗുണങ്ങൾ ഉപയോഗിക്കുന്ന രീതികളും ഞങ്ങൾ പരിശോധിക്കും. എൻ.

ഉപയോഗിച്ച അളവ് അധിക മെമ്മറിസോർട്ടിംഗ് അൽഗോരിതം മറ്റൊന്നാണ് പ്രധാന ഘടകം, ഞങ്ങൾ കണക്കിലെടുക്കും. പൊതുവായി പറഞ്ഞാൽ, സോർട്ടിംഗ് രീതികൾ മൂന്ന് തരങ്ങളായി തിരിച്ചിരിക്കുന്നു:

ഒരു ചെറിയ സ്റ്റാക്ക് കൂടാതെ/അല്ലെങ്കിൽ അറേ ഒഴികെ, അധിക മെമ്മറി ഉപയോഗിക്കാതെ അടുക്കുന്ന സോർട്ടിംഗ് രീതികൾ;

തരംതിരിക്കാൻ ഉപയോഗിക്കുന്ന രീതികൾ ബന്ധപ്പെട്ട ലിസ്റ്റുകൾഅതിനാൽ ഉപയോഗിക്കുക എൻമെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്ന അധിക പോയിന്ററുകൾ;

ക്രമീകരിച്ച ഫയലിന്റെ ഒരു പകർപ്പ് സംഭരിക്കുന്നതിന് അധിക മെമ്മറി ആവശ്യമുള്ള രീതികളും.

സ്ഥിരത- സോർട്ടിംഗ് രീതികളുടെ മറ്റൊരു പ്രധാന സ്വഭാവം. സോർട്ടിംഗ് രീതി എന്ന് വിളിക്കുന്നു സ്ഥിരതയുള്ള,ഒരേ കീകൾ ഉപയോഗിച്ച് റെക്കോർഡുകളുടെ ആപേക്ഷിക ക്രമം അത് സംരക്ഷിക്കുകയാണെങ്കിൽ. ഉദാഹരണത്തിന്, എങ്കിൽ അക്ഷരമാലാക്രമ പട്ടികഗ്രൂപ്പുകളെ ഗ്രേഡുകളാൽ അടുക്കുന്നു, സ്ഥിരതയുള്ള രീതി ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു, അതിൽ ഒരേ ഗ്രേഡുകളുള്ള വിദ്യാർത്ഥികളുടെ പേരുകൾ അക്ഷരമാലാക്രമത്തിൽ ക്രമപ്പെടുത്തും, അസ്ഥിരമായ രീതി യഥാർത്ഥ ക്രമം ലംഘിക്കപ്പെടാനിടയുള്ള ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കും. ഏറ്റവും ലളിതമായ രീതികൾ സ്ഥിരതയുള്ളവയാണ്, ഏറ്റവും അറിയപ്പെടുന്നവയാണ് സങ്കീർണ്ണമായ രീതികൾ- ഇല്ല. സ്ഥിരത ആവശ്യമാണെങ്കിൽ, അടുക്കുന്നതിന് മുമ്പ് കീയിൽ ഒരു ചെറിയ സൂചിക ചേർത്തോ അല്ലെങ്കിൽ ഏതെങ്കിലും വിധത്തിൽ കീ നീട്ടിക്കൊണ്ടോ ഇത് നേടാനാകും. സ്ഥിരത സാധാരണമായി എളുപ്പത്തിൽ അംഗീകരിക്കപ്പെടുന്നു; ആളുകൾ അസ്ഥിരതയെ അവിശ്വാസത്തോടെയാണ് കൈകാര്യം ചെയ്യുന്നത്. വാസ്തവത്തിൽ, അധിക സമയമോ സ്ഥലമോ ഉപയോഗിക്കാതെ കുറച്ച് രീതികൾ സ്ഥിരത കൈവരിക്കുന്നു.

ഇനിപ്പറയുന്ന പ്രോഗ്രാം, മൂന്ന് റെക്കോർഡുകൾ അടുക്കുന്നതിന്, ഞങ്ങൾ ഉപയോഗിക്കുന്ന അടിസ്ഥാന കൺവെൻഷനുകൾ ചിത്രീകരിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്. പ്രത്യേകിച്ച്, പ്രധാന പ്രോഗ്രാംഇത് N=3 ന് മാത്രമേ പ്രവർത്തിക്കൂ എന്നതിൽ കൗതുകം; ഏത് സോർട്ടിംഗ് പ്രോഗ്രാമും ഒരു നടപടിക്രമത്തിലേക്ക് ചുരുക്കാം എന്നതാണ് അടുക്കുക3ഈ പ്രോഗ്രാം.

മൂന്ന് അസൈൻമെന്റ് പ്രസ്താവനകൾ, ഓരോന്നിനും ഒരു ഓപ്പറേറ്റർ എങ്കിൽ,വാസ്തവത്തിൽ, അവർ "എക്സ്ചേഞ്ച്" പ്രവർത്തനം നടപ്പിലാക്കുന്നു. ഞങ്ങൾ അത് നേരിട്ട് ഒട്ടിക്കുന്നു പ്രോഗ്രാം കോഡ്ഒരു പ്രൊസീജിയർ കോൾ ഉപയോഗിക്കുന്നതിനുപകരം, അവ പല അൽഗോരിതങ്ങളുടെയും അടിസ്ഥാനമായതിനാൽ പലപ്പോഴും ഒരു ലൂപ്പിനുള്ളിൽ വീഴുന്നു.

അൽഗോരിതമിക് പ്രശ്‌നങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ, സംഖ്യാ ക്രമത്തിൽ പൂർണ്ണസംഖ്യകളുടെ നിരകളെ ക്രമപ്പെടുത്തുന്ന അൽഗരിതങ്ങളുമായി ഞങ്ങൾ പ്രവർത്തിക്കും. പൊതുവേ, അത്തരം അൽഗോരിതങ്ങൾ പൊരുത്തപ്പെടുത്തുന്നത് വളരെ എളുപ്പമാണ് പ്രായോഗിക ഉപയോഗം, വലിയ കീകൾ അല്ലെങ്കിൽ റെക്കോർഡുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഉൾപ്പെടുന്നു. അടിസ്ഥാനപരമായി, സോർട്ടിംഗ് പ്രോഗ്രാമുകൾ രണ്ട് തരത്തിൽ റെക്കോർഡുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു: ഒന്നുകിൽ അവ കീകൾ മാത്രം താരതമ്യം ചെയ്യുകയും അടുക്കുകയും ചെയ്യുക, അല്ലെങ്കിൽ അവ മുഴുവൻ റെക്കോർഡുകളും നീക്കുക. ഞങ്ങൾ പഠിക്കുന്ന മിക്ക അൽഗോരിതങ്ങളും ഈ രണ്ട് പ്രവർത്തനങ്ങളുടെ അടിസ്ഥാനത്തിൽ പരിഷ്കരിച്ചുകൊണ്ട് പ്രയോഗിക്കാൻ കഴിയും. ഏകപക്ഷീയമായ രേഖകൾ. അടുക്കിയിരിക്കുന്ന രേഖകൾ വളരെ വലുതാണെങ്കിൽ, അവയെ ഒരു "പരോക്ഷ തരം" വഴി നീക്കുന്നത് ഒഴിവാക്കാൻ ശ്രമിക്കുന്നത് സാധാരണമാണ്: ഇത് റെക്കോർഡുകൾ സ്വയം പുനഃക്രമീകരിക്കുന്നില്ല, പകരം പോയിന്ററുകളുടെ (ഇൻഡക്സുകൾ) അറേ പുനഃക്രമീകരിക്കുന്നു, അങ്ങനെ ആദ്യ പോയിന്റർ ചൂണ്ടിക്കാണിക്കുന്നു ഏറ്റവും ചെറിയ മൂലകം മുതലായവ. കീകൾ റെക്കോർഡുകൾ (അവ വലുതാണെങ്കിൽ) അല്ലെങ്കിൽ പോയിന്ററുകൾ (അവ ചെറുതാണെങ്കിൽ) ഒന്നുകിൽ സൂക്ഷിക്കാം. ആവശ്യമെങ്കിൽ, ക്രമീകരിച്ചതിന് ശേഷം നിങ്ങൾക്ക് റെക്കോർഡുകൾ പുനഃക്രമീകരിക്കാം. ഇത് താഴെ വിവരിക്കുന്നു.

പ്രോഗ്രാം അടുക്കുക3അതിലും കൂടുതൽ ഉപയോഗിക്കുന്നു പരിമിതമായ പ്രവേശനംഒരു ഫയലിലേക്ക്: "രണ്ട് റെക്കോർഡുകൾ താരതമ്യം ചെയ്യുക, ആവശ്യമെങ്കിൽ അവ കൈമാറ്റം ചെയ്യുക, ചെറിയ കീ ഉപയോഗിച്ച് റെക്കോർഡ് ആദ്യം സ്ഥാപിക്കുക" എന്ന ഫോമിന്റെ മൂന്ന് പ്രവർത്തനങ്ങളാണ് ഇവ. അത്തരം പ്രവർത്തനങ്ങളിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്ന പ്രോഗ്രാമുകൾ രസകരമാണ്, കാരണം അവ നടപ്പിലാക്കാൻ അനുയോജ്യമാണ് ഹാർഡ്‌വെയർ ലെവൽ. ഞങ്ങൾ അവ പിന്നീട് കൂടുതൽ വിശദമായി പഠിക്കും.

എല്ലാ സാമ്പിൾ പ്രോഗ്രാമുകളും അടുക്കുന്നതിന് ഉപയോഗിക്കുന്നു ആഗോള ശ്രേണി. ഒരു പാരാമീറ്ററായി ഒരു അറേ കടന്നുപോകുന്നതിനേക്കാൾ ഈ സമീപനം മികച്ചതോ മോശമോ ആണെന്ന് ഇതിനർത്ഥമില്ല. ഇതെല്ലാം കാഴ്ചപ്പാടിനെയും നിർദ്ദിഷ്ട അൽഗോരിതത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. ഉദാഹരണങ്ങൾ ചെറുതും വ്യക്തവും ആയതിനാൽ മാത്രമാണ് അറേ ആഗോളമാക്കുന്നത്.

തിരഞ്ഞെടുക്കൽ പ്രകാരം അടുക്കുന്നുഏറ്റവും ലളിതമായ സോർട്ടിംഗ് രീതികളിലൊന്ന് ഇതുപോലെയാണ് പ്രവർത്തിക്കുന്നത്: അറേയിലെ ഏറ്റവും ചെറിയ ഘടകം കണ്ടെത്തി ആദ്യം മൂലകവുമായി അത് സ്വാപ്പ് ചെയ്യുക. ഫയലിലെ രണ്ടാമത്തെ സ്ഥാനത്ത് നിന്ന് ഞങ്ങൾ പ്രക്രിയ ആവർത്തിക്കുകയും കണ്ടെത്തിയ ഘടകം രണ്ടാമത്തെ ഘടകവുമായി കൈമാറ്റം ചെയ്യുകയും അങ്ങനെ മുഴുവൻ അറേയും അടുക്കുന്നത് വരെ. ഈ രീതിയെ വിളിക്കുന്നു തിരഞ്ഞെടുക്കൽ തരം,കാരണം, ചിത്രം 1-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ശേഷിക്കുന്ന ഏറ്റവും ചെറിയ മൂലകത്തെ ചാക്രികമായി തിരഞ്ഞെടുത്ത് ഇത് പ്രവർത്തിക്കുന്നു. ആദ്യ പാസിൽ, സ്‌പെയ്‌സ് പ്രതീകം ആദ്യം പോകുന്നു, `P' എന്ന അക്ഷരം ഉപയോഗിച്ച് കൈമാറ്റം ചെയ്യുന്നു. രണ്ടാമത്തെ പാസിൽ, `B' എന്ന ഘടകം കൈമാറ്റം ചെയ്യപ്പെടുന്നു. മൂലകം `P', തുടങ്ങിയവ .ഇനിപ്പറയുന്ന പ്രോഗ്രാം ഈ പ്രക്രിയയുടെ പൂർണ്ണമായ നിർവ്വഹണം നൽകുന്നു. ഓരോന്നിനും ഐ 1 മുതൽ എൻ- 1 , ഇത് ഒരു [ യുടെ ഏറ്റവും ചെറിയ മൂലകത്തെ കൈമാറ്റം ചെയ്യുന്നു ഐ..N] കൂടെ [ ഐ]:പോയിന്റർ നീങ്ങുമ്പോൾ ഐഫയലിലൂടെ ഇടത്തുനിന്ന് വലത്തോട്ട്, പോയിന്ററിന്റെ ഇടതുവശത്തുള്ള ഘടകങ്ങൾ ഇതിനകം തന്നെ അവയുടെ അന്തിമ സ്ഥാനത്താണ് (വീണ്ടും സ്പർശിക്കില്ല), അതിനാൽ പോയിന്റർ വലത് അരികിൽ എത്തുമ്പോഴേക്കും അറേ പൂർണ്ണമായി അടുക്കുന്നു. ഈ രീതി ഏറ്റവും ലളിതമായ ഒന്നാണ്, ചെറിയ ഫയലുകൾക്ക് ഇത് വളരെ നന്നായി പ്രവർത്തിക്കുന്നു. അതിന്റെ "ഇന്നർ ലൂപ്പ്" ഒരു താരതമ്യം ഉൾക്കൊള്ളുന്നു[ ഐ]മിനിറ്റ്] (കൂടാതെ വർദ്ധിപ്പിക്കാൻ ആവശ്യമായ കോഡ് ജെഅത് കവിഞ്ഞിട്ടില്ലെന്ന് പരിശോധിക്കുന്നു എൻ), ഇത് കൂടുതൽ ലളിതമാക്കാൻ കഴിയില്ല. കൂടാതെ, സെലക്ഷൻ സോർട്ട് ഒരു ബ്രൂട്ട് ഫോഴ്‌സ് രീതിയാണെങ്കിലും, ഇതിന് വളരെ പ്രധാനപ്പെട്ട ഒരു പ്രയോഗമുണ്ട്: ഓരോ ഘടകവും ഒരു തവണ നീക്കിയതിനാൽ, ചെറിയ കീകളുള്ള വലിയ റെക്കോർഡുകൾക്ക് ഇത് വളരെ നല്ലതാണ്. ഉൾപ്പെടുത്തൽ അടുക്കുകരീതി അടുക്കുന്നു തിരുകുക,തിരഞ്ഞെടുക്കൽ ക്രമം പോലെ ലളിതമാണ്, എന്നാൽ കൂടുതൽ വഴക്കമുള്ളത്. കാർഡുകൾ അടുക്കുമ്പോൾ ഈ രീതി പലപ്പോഴും ഉപയോഗിക്കുന്നു: ഞങ്ങൾ ഇതിനകം പ്രോസസ്സ് ചെയ്തവയിൽ നിന്ന് ഒരു ഘടകം എടുത്ത് ശരിയായ സ്ഥലത്ത് തിരുകുന്നു (അതുവഴി അവ അടുക്കി വയ്ക്കുന്നു). വലിയ ഘടകത്തെ ഒരു സ്ഥാനത്തേക്ക് നീക്കിക്കൊണ്ട് ചോദ്യത്തിലെ ഘടകം സ്ഥാനത്തേക്ക് ചേർക്കുന്നു ചിത്രം 2-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, വലത്തേയ്‌ക്ക് ശേഷം ചെറിയ ഘടകം ഒഴിഞ്ഞ സ്ഥാനത്തേക്ക് വയ്ക്കുന്നു. അതിനാൽ മൂന്നാം ഘട്ടത്തിലെ `I" മറ്റെല്ലാ അടുക്കിയ ഘടകങ്ങളേക്കാളും ചെറുതാണ്, അതിനാൽ ഞങ്ങൾ അതിനെ അറേയുടെ തുടക്കത്തിലേക്ക് "മുങ്ങുന്നു". `M "ഞാൻ" എന്നതിനേക്കാൾ വലുതാണ്, എന്നാൽ എല്ലാറ്റിനേക്കാളും കുറവാണ്, അതിനാൽ നമ്മൾ അത് `I' നും `P' നും ഇടയിൽ സ്ഥാപിക്കുന്നു. ഈ പ്രക്രിയ ഇനിപ്പറയുന്ന പ്രോഗ്രാമിൽ നടപ്പിലാക്കുന്നു. ഓരോന്നിനും ഐ 2 മുതൽ എൻ, സബറേ a യെ അടുക്കുന്നത് ഒരു ഐ] ഇതിനകം അടുക്കിയ മൂലകങ്ങൾക്കിടയിൽ അനുയോജ്യമായ സ്ഥാനത്തേക്ക്: തിരഞ്ഞെടുക്കൽ ക്രമം പോലെ, പോയിന്ററിന്റെ ഇടതുവശത്തേക്ക് ഘടകങ്ങൾ അടുക്കുമ്പോൾ ഐഅവ ഇതിനകം അടുക്കിയ ക്രമത്തിലാണ്, പക്ഷേ അവ അവസാന സ്ഥാനത്തായിരിക്കണമെന്നില്ല, കാരണം പിന്നീട് അഭിമുഖീകരിക്കുന്ന ചെറിയ ഘടകങ്ങൾ ചേർക്കുന്നതിന് അവ വലത്തേക്ക് നീക്കാൻ കഴിയും. പോയിന്റർ വലത് അറ്റത്ത് എത്തുമ്പോൾ അറേ പൂർണ്ണമായി അടുക്കുന്നു. എന്നിരുന്നാലും, ഒരു പ്രധാന വിശദാംശം കൂടിയുണ്ട്: പ്രോഗ്രാം ഉൾപ്പെടുത്തൽഎപ്പോഴും പ്രവർത്തിക്കില്ല കാരണം സമയത്ത്എപ്പോൾ അറേയുടെ ഇടത് അറ്റത്ത് ചാടിയേക്കാം വി- അറേയിലെ ഏറ്റവും ചെറിയ ഘടകം. സാഹചര്യം പരിഹരിക്കുന്നതിന്, ഞങ്ങൾ a-യിൽ ഒരു "ഗാർഡ്" കീ സ്ഥാപിക്കുന്നു, ഇത് അറേയിലെ ഏറ്റവും ചെറിയ കീയേക്കാൾ വലുതായിരിക്കില്ല. അധിക പരിശോധന തടയാൻ വാച്ച്ഡോഗുകൾ സാധാരണയായി ഇത്തരം സാഹചര്യങ്ങളിൽ ഉപയോഗിക്കുന്നു (ഇൻ ഈ സാഹചര്യത്തിൽ ജെ>0), ഇത് മിക്കവാറും എല്ലായ്‌പ്പോഴും ആന്തരിക ലൂപ്പുകളിൽ സഹായിക്കുന്നു. ബബിൾ അടുക്കുകപലപ്പോഴും നൽകപ്പെടുന്ന ഒരു അടിസ്ഥാന സോർട്ടിംഗ് രീതി ആമുഖ ക്ലാസുകൾ- ഈ ബബിൾ അടുക്കുക: അടുക്കാത്ത ജോഡികൾ കണ്ടുമുട്ടുന്നിടത്തോളം, തൊട്ടടുത്തുള്ള അറേ ഘടകങ്ങൾ സ്വാപ്പ് ചെയ്യപ്പെടും. ഈ രീതിയുടെ നടപ്പാക്കൽ ചുവടെ നൽകിയിരിക്കുന്നു. ഇത് യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്നുവെന്ന് വിശ്വസിക്കാൻ കുറച്ച് സമയമെടുത്തേക്കാം. ഇത് ചെയ്യുന്നതിന്, ആദ്യ പാസിനുള്ളിൽ ഒരു മാക്സിമൽ എലമെന്റിനെ നേരിടുമ്പോൾ, അത് വലത് വശത്തെ സ്ഥാനത്താകുന്നത് വരെ വലതുവശത്തുള്ള എല്ലാ ഘടകങ്ങളുമായും ഞങ്ങൾ അത് കൈമാറ്റം ചെയ്യുന്നു. രണ്ടാമത്തെ പാസിൽ, ഞങ്ങൾ രണ്ടാമത്തെ പരമാവധി ഘടകം അവസാന സ്ഥാനത്ത് സ്ഥാപിക്കുന്നു, അങ്ങനെ അങ്ങനെ. ബബിൾ സോർട്ടും സെലക്ഷൻ സോർട്ടിന്റെ അതേ രീതിയിൽ തന്നെ പ്രവർത്തിക്കുന്നു, എന്നിരുന്നാലും ഇത് കൂടുതൽ കാര്യങ്ങൾ ചെയ്യുന്നു കൂടുതൽ ജോലിമൂലകത്തെ അതിന്റെ അവസാന സ്ഥാനത്തേക്ക് നീക്കാൻ. ഏറ്റവും ലളിതമായ ഇനങ്ങളുടെ സവിശേഷതകൾസ്വത്ത് 1 തിരഞ്ഞെടുക്കൽ അടുക്കൽ ഉപയോഗിക്കുന്നു താരതമ്യങ്ങളും N എക്സ്ചേഞ്ചുകളും.പ്രോപ്പർട്ടി 2തിരുകൽ അടുക്കൽ ഏകദേശം ഉപയോഗിക്കുന്നു താരതമ്യങ്ങളും ശരാശരി കൈമാറ്റങ്ങൾ, ഏറ്റവും മോശമായ സാഹചര്യത്തിൽ ഇരട്ടി.സ്വത്ത് 3 ബബിൾ അടുക്കൽ ഏകദേശം ഉപയോഗിക്കുന്നു. താരതമ്യങ്ങളും ശരാശരി, മോശം സന്ദർഭങ്ങളിൽ കൈമാറ്റം.സ്വത്ത് 4 "ഏതാണ്ട് അടുക്കിയ" ഫയലുകൾക്കായി തിരുകൽ അടുക്കൽ രേഖീയമാണ്.സ്വത്ത് 5 വലിയ റെക്കോർഡുകളും ചെറിയ കീകളുമുള്ള ഫയലുകൾക്കായി തിരഞ്ഞെടുക്കൽ ക്രമം രേഖീയമാണ്.വലിയ റെക്കോർഡുകളുള്ള ഫയലുകൾ അടുക്കുന്നുമിക്കപ്പോഴും, N ഘടകങ്ങൾ അടങ്ങിയ ഒരു ഫയൽ അടുക്കുമ്പോൾ, ഏതെങ്കിലും രീതി ഉപയോഗിച്ച്, N എക്സ്ചേഞ്ച് പ്രവർത്തനങ്ങൾ മാത്രമേ നടത്തൂ എന്ന് ഉറപ്പാക്കാൻ സാധ്യമാണ് (അഭികാമ്യവും). മുഴുവൻ റെക്കോർഡ്അറേയുടെ ഘടകങ്ങളെ പരോക്ഷമായി അഭിസംബോധന ചെയ്തുകൊണ്ട് (സൂചികകളുടെയോ പോയിന്ററുകളുടെയോ ഒരു നിര ഉപയോഗിച്ച്), തുടർന്ന് പുനഃസംഘടന തന്നെ നടത്തുക.കൂടുതൽ വ്യക്തമായി: അറേ aയിൽ വലിയ എൻട്രികൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അറിയാൻ ഞങ്ങൾ പോയിന്റർ അറേ p ഉപയോഗിക്കാൻ താൽപ്പര്യപ്പെടുന്നു. അറേയുടെ അടുത്ത ഘടകം എവിടെയാണ് സ്ഥിതിചെയ്യുന്നത്, കൂടാതെ ഒരു വ്യാജ കൈമാറ്റം നടത്താനും. പോയിന്ററുകളുടെ ഒരു നിര ഉപയോഗിച്ചുള്ള ഒരു ഇൻസെർഷൻ സോർട്ട് പ്രോഗ്രാം ചുവടെയുണ്ട്: ലൂപ്പിലെ അനാവശ്യ നിയന്ത്രണം തടയാൻ, പ്രോഗ്രാം വീണ്ടും "വാച്ച്" ഘടകങ്ങൾ ഉപയോഗിക്കുന്നു. തുടക്കത്തിൽ, സൂചികകൾ ക്രമത്തിലാണ്. അപ്പോൾ സൂചികകളുടെ ക്രമം മാറാൻ തുടങ്ങുന്നു, അങ്ങനെ സൂചികകൾ വായിക്കുന്ന ക്രമത്തിൽ വായിക്കുന്ന ശ്രേണി a, ഓർഡർ ചെയ്യപ്പെടും.

ഇതിനായി നമുക്ക് ഉപയോഗിക്കാം ഇനിപ്പറയുന്ന നടപടിക്രമം, N ക്രമപ്പെടുത്തലുകൾ ഉപയോഗിച്ച് ഫയലിന്റെ രേഖകൾ ഭൗതികമായി ക്രമീകരിക്കുന്നു:

ഷെൽ അടുക്കുകചേർക്കൽ ക്രമം മന്ദഗതിയിലാണ്, കാരണം അത് അടുത്തുള്ള ഘടകങ്ങൾ മാത്രം കൈമാറ്റം ചെയ്യുന്നു. ഷെൽ സോർട്ട് എന്നത് ഇൻസെർഷൻ സോർട്ടിന്റെ ഏറ്റവും ലളിതമായ വിപുലീകരണമാണ്, ഇത് പരസ്പരം അകലെയുള്ള ഘടകങ്ങൾ കൈമാറ്റം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു എന്ന വസ്തുത കാരണം അൽഗോരിതം വേഗത വർദ്ധിപ്പിക്കുന്നു. എല്ലാ ഗ്രൂപ്പുകളും അടുക്കുക എന്നതാണ് അൽഗോരിതത്തിന്റെ പ്രധാന ആശയം. പരസ്പരം h ദൂരത്തിൽ ഉള്ള ഫയൽ ഘടകങ്ങൾ അടങ്ങുന്ന ഫയൽ. അത്തരം ഫയലുകളെ h-sorted എന്ന് വിളിക്കുന്നു. നമ്മൾ ഒരു ഫയലിനെ കുറച്ച് വലിയ h ഉപയോഗിച്ച് എച്ച്-സോർട്ട് ചെയ്യുമ്പോൾ, ഞങ്ങൾ അതിന്റെ ഘടകങ്ങൾ വലിയ ദൂരത്തേക്ക് നീക്കുന്നു. ഇത് h ന്റെ ചെറിയ മൂല്യങ്ങൾക്ക് അടുക്കൽ ജോലി എളുപ്പമാക്കുന്നു. h 1 ആയി കുറയുമ്പോൾ പ്രക്രിയ അവസാനിക്കുന്നു.

മുകളിലെ പ്രോഗ്രാം സീക്വൻസ് ഉപയോഗിക്കുന്നു... 1093, 364, 121, 40, 13, 4, 1. മറ്റ് സീക്വൻസുകൾ ഉണ്ടാകാം - ചിലത് മികച്ചത്, മറ്റുള്ളവ മോശം.

സ്വത്ത് 6ഷെൽ സോർട്ട് ഒരിക്കലും N എന്നതിനേക്കാൾ കൂടുതൽ ചെയ്യില്ല1.5 മേൽപ്പറഞ്ഞ ക്രമത്തിനായുള്ള താരതമ്യങ്ങൾ h.

വിതരണ എണ്ണുന്നുമിക്ക കേസുകളിലും, ഒരു ഫയലിലെ പ്രധാന മൂല്യങ്ങൾ ചില പരിധിക്കുള്ളിലാണെന്ന് നമുക്കറിയാം. ഈ സാഹചര്യങ്ങളിൽ, ഡിസ്ട്രിബ്യൂഷൻ കൗണ്ടിംഗ് എന്ന ഒരു അൽഗോരിതം ബാധകമാണ്. ഈ ലളിതമായ അൽഗോരിതത്തിനായുള്ള പ്രോഗ്രാം ഇതാ.

8 ഉൾപ്പെടുത്തൽ അടുക്കുക

9 A N ആരോഹണ ക്രമത്തിൽ A-യെ അടുക്കേണ്ടത് ആവശ്യമായിരിക്കട്ടെ, അതിൽ N മൂലകങ്ങൾ ചേർക്കൽ രീതി ഉപയോഗിച്ച് ചേർക്കുന്നു, സഹായ വേരിയബിളുകൾ j j എന്നത് ശേഷിക്കുന്ന ആദ്യ മൂലകത്തിന്റെ സംഖ്യയാണ്. i i - നീക്കുന്ന മൂലകത്തിന്റെ എണ്ണം. f f=1 f – ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുന്നതിനുള്ള വ്യവസ്ഥ (f=1 ആണെങ്കിൽ എക്സിറ്റ്) Val Val – അറേയുടെ മൂലകങ്ങൾ നീക്കാൻ ഉപയോഗിക്കുന്ന ഇന്റർമീഡിയറ്റ് മൂല്യം പ്രശ്ന പ്രസ്താവന

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം." title="10 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A [i] എങ്കിൽ Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം." class="link_thumb"> 10 !} 10 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം."> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലെങ്കിൽ f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:= i- 1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം."> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം." title="10 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A [i] എങ്കിൽ Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം."> title="10 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം."> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്താണ് "title="11 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്താണ് അർത്ഥമാക്കുന്നത്?" class="link_thumb"> 11 !} 11 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്താണ് ഇതിനർത്ഥം ഈ അവസ്ഥ? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. "> A[i] എന്നാൽ എന്താണ് അർത്ഥമാക്കുന്നത് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i- 1 , ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഈ അവസ്ഥ എന്താണ് അർത്ഥമാക്കുന്നത്?"> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്താണ് "title="11 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്താണ് അർത്ഥമാക്കുന്നത്?"> title="11 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്താണ് ഇതിനർത്ഥം"> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" title="12 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" class="link_thumb"> 12 !} 12 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് ആരംഭ മൂല്യം j =2? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു"> A[i] പിന്നെ Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1 , ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭ മൂല്യം j =2 ? "> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" title="12 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു"> title="12 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തിന് തുടങ്ങുന്നു"> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" title="13 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" class="link_thumb"> 13 !} 13 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് ആരംഭ മൂല്യം i =2? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു"> A[i] പിന്നെ Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1 , ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭ മൂല്യം i =2 ? "> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു" title="13 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A> A[i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j :=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ട് ആരംഭിക്കുന്നു"> title="13 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. എന്തിന് തുടങ്ങുന്നു"> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് എല്ലായ്പ്പോഴും ശരിയാണോ" title="(! LANG:14 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് എല്ലായ്പ്പോഴും ശരിയാണോ" class="link_thumb"> 14 !} 14 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇൻപുട്ട് j ഘടകം എപ്പോഴും അടുക്കിയ ഘടകവുമായി കൈമാറ്റം ചെയ്യുമോ? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. അത് എല്ലായ്പ്പോഴും "> A[i] ആണോ അപ്പോൾ Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i- 1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇൻപുട്ട് j ഘടകം എല്ലായ്പ്പോഴും അടുക്കിയ ഘടകവുമായി കൈമാറ്റം ചെയ്യുമോ?"> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് എല്ലായ്പ്പോഴും ശരിയാണോ" title="(! LANG:14 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് എല്ലായ്പ്പോഴും ശരിയാണോ"> title="14 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. അത് എപ്പോഴും സാധ്യമാണോ"> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് സാധ്യമാണോ" title="(! LANG:15 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് സാധ്യമാണോ" class="link_thumb"> 15 !} 15 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. I>=2, A>A[i] എന്നീ വ്യവസ്ഥകൾ ഉപയോഗിച്ച് BYE, IF ലൂപ്പ് എന്നിവ മാറ്റി ഒരു BYE ലൂപ്പ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ കഴിയുമോ? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. "> A[i] എന്നതിനു ശേഷം Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i - 1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനിക്കുന്നു. i>=2, A>A[i] ?> A എന്ന അവസ്ഥയിൽ ഒരു BYE ലൂപ്പ് ഉപയോഗിച്ച് BYE, IF ലൂപ്പ് എന്നിവ മാറ്റിസ്ഥാപിക്കാൻ കഴിയുമോ? [i] പിന്നെ വാൽ:= എ; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് സാധ്യമാണോ" title="(! LANG:15 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് സാധ്യമാണോ"> title="15 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. അത് സാധ്യമാണോ"> !}

A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് എന്തിനുവേണ്ടിയാണ്" title="(! LANG:16 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് എന്തിനുവേണ്ടിയാണ്?" class="link_thumb"> 16 !} 16 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2, f=0 എന്നിവ നിർവഹിക്കുമ്പോൾ: ഘട്ടം A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഈ ഓപ്പറേറ്റർ എന്തിനുവേണ്ടിയാണ്? A[i] പിന്നെ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് എന്തിനുവേണ്ടിയാണ്"> A[i] പിന്നെ Val:=A; A:=A[i]; A[i]:=Val, അല്ലെങ്കിൽ f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i - 1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഈ ഓപ്പറേറ്റർ എന്തിനുവേണ്ടിയാണ്? "> A[i] തുടർന്ന് Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. ഇത് എന്തിനുവേണ്ടിയാണ്" title="(! LANG:16 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j=2, f=0 എന്നിവ ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 എങ്കിൽ A>A [i] തുടർന്ന് Val:=A; A:=A[i]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതത്തിന്റെ അവസാനം. ഇത് എന്തിനുവേണ്ടിയാണ്?"> title="16 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=2, ഘട്ടം 2 ഘട്ടം 2 j=2 ഉം f=0 ഉം ചെയ്യുമ്പോൾ: ഘട്ടം 2.2.1 ഘട്ടം 2.2.1 A>A[i] ആണെങ്കിൽ Val:=A; എ:=എ[ഐ]; A[i]:=Val, അല്ലാത്തപക്ഷം f:=1, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i:=i-1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j+1. അൽഗോരിതം അവസാനം. അത് എന്തിനുവേണ്ടിയാണ് വേണ്ടത്"> !}

18 തരംതിരിക്കലിന്റെ സാരാംശം: ഉള്ള മൂലകം ഏറ്റവും കുറഞ്ഞ മൂല്യംഅറേയുടെ ആദ്യ ഘടകവുമായി ഇത് കൈമാറ്റം ചെയ്യപ്പെടുന്നു. തുടർന്ന് ശേഷിക്കുന്ന n-1 മൂലകങ്ങളിൽ നിന്ന് ഏറ്റവും ചെറിയ മൂല്യമുള്ള മൂലകം കണ്ടെത്തുകയും അത് രണ്ടാമത്തെ മൂലകവുമായി കൈമാറ്റം ചെയ്യുകയും ചെയ്യുന്നു. അവസാന രണ്ട് ഘടകങ്ങൾ കൈമാറുന്നതിന് മുമ്പ്.

തിരഞ്ഞെടുക്കൽ അടുക്കിയ ഭാഗം അടുക്കിയ ഭാഗം ആരോഹണ ക്രമത്തിൽ അടുക്കിയ ഭാഗം

20 പ്രശ്നത്തിന്റെ പ്രസ്താവന A N നിങ്ങൾ അറേ A ആരോഹണ ക്രമത്തിൽ അടുക്കാൻ അനുവദിക്കുക, അതിൽ തിരഞ്ഞെടുക്കൽ പ്രകാരം N ഘടകങ്ങൾ ഉണ്ട്. സഹായ വേരിയബിളുകൾ j j - ശേഷിക്കുന്ന ആദ്യ മൂലകത്തിന്റെ സംഖ്യ. i i - നീക്കുന്ന മൂലകത്തിന്റെ എണ്ണം. മിനിറ്റ് മിനിറ്റ് - അറേയിലെ ഏറ്റവും കുറഞ്ഞ സംഖ്യ. ഇമിൻ ഇമിൻ - അറേയിലെ ഏറ്റവും കുറഞ്ഞ സംഖ്യയുടെ സംഖ്യ

25 സോർട്ടിംഗിന്റെ സാരം: അറേ തുടർച്ചയായി സ്കാൻ ചെയ്യുകയും ഓരോ ജോഡി ഘടകങ്ങളും പരസ്പരം താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, മൂലകങ്ങളുടെ "തെറ്റായ" ക്രമീകരണം അവയെ പുനഃക്രമീകരിക്കുന്നതിലൂടെ ഇല്ലാതാക്കുന്നു. മുഴുവൻ ശ്രേണിയും കാണുന്നതുവരെ ഘടകങ്ങൾ കാണുകയും താരതമ്യം ചെയ്യുകയും ചെയ്യുന്ന പ്രക്രിയ ആവർത്തിക്കുന്നു.

26 എക്സ്ചേഞ്ച് വഴി അടുക്കുന്നു

27 A N ആരോഹണ ക്രമത്തിൽ A യെ അടുക്കേണ്ടത് ആവശ്യമായിരിക്കട്ടെ, ഇതിൽ N മൂലകങ്ങൾ എക്സ്ചേഞ്ച് രീതി ഉപയോഗിച്ച് കൈമാറ്റം ചെയ്യപ്പെടുന്നു സഹായ വേരിയബിളുകൾ j j - ശേഷിക്കുന്ന ആദ്യ മൂലകത്തിന്റെ എണ്ണം. i i - നീക്കുന്ന മൂലകത്തിന്റെ എണ്ണം. അറേ ഘടകങ്ങൾ നീക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഇന്റർമീഡിയറ്റ് മൂല്യമാണ് Val Val. പ്രശ്ന പ്രസ്താവന

2 നിർവഹിക്കുക: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. അയൽക്കാരുടെ താരതമ്യം" title="28 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നിർവഹിക്കുന്നു: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA അപ്പോൾ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതത്തിന്റെ അവസാനം. അയൽക്കാരുടെ താരതമ്യം" class="link_thumb"> 28 !} 28 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, Step Step i=i+1, Step 2.3 Step 2.3 j:=j-1. അൽഗോരിതം അവസാനം. താരതമ്യം അയൽ ഘടകങ്ങൾഇടത്തേത് വലത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ അയൽ ഘടകങ്ങൾ മാറ്റുക. അടുക്കിയ ഒരു ഭാഗം രൂപം കൊള്ളുന്നു =2 പ്രകടനം: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. അയൽക്കാരെ താരതമ്യം ചെയ്യുക "> =2 പ്രകടനം: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA അതേസമയം Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതത്തിന്റെ അവസാനം അയൽ മൂലകങ്ങളുടെ താരതമ്യം ഇടത് വലത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ അയൽ ഘടകങ്ങൾ സ്വാപ്പ് ചെയ്യുക. അടുക്കിയ ഭാഗം രൂപപ്പെടുന്നു "> =2 നിർവ്വഹിക്കുന്നു: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. അയൽക്കാരുടെ താരതമ്യം" title="28 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നിർവഹിക്കുന്നു: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA അപ്പോൾ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതത്തിന്റെ അവസാനം. അയൽക്കാരുടെ താരതമ്യം"> title="28 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. അയൽവാസികളുടെ താരതമ്യം"> !}

2 നിർവഹിക്കുക: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് വ്യവസ്ഥ "title="29 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നടത്തുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1 അൽഗോരിതത്തിന്റെ അവസാനം എന്തുകൊണ്ട് അവസ്ഥ സമാനമാണ്?" class="link_thumb"> 29 !} 29 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, Step Step i=i+1, Step 2.3 Step 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് ഈ അവസ്ഥ? =2 പ്രകടനം: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് ടാ"> =2 എന്ന വ്യവസ്ഥ പൂർത്തീകരിച്ചത്: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, Step 2.2. 2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതത്തിന്റെ അവസാനം. എന്തുകൊണ്ടാണ് അവസ്ഥ ഇങ്ങനെ?"> =2 ചെയ്യുക: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1 ;, ഘട്ടം 2.2 ഘട്ടം 2.2 ഇപ്പോൾ iA പിന്നെ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് വ്യവസ്ഥ "title="29 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നടത്തുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1 അൽഗോരിതത്തിന്റെ അവസാനം എന്തുകൊണ്ട് അവസ്ഥ സമാനമാണ്?"> title="29 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് അവസ്ഥ സമാനമാകുന്നത്?"> !}

2 നിർവഹിക്കുക: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് മൂല്യം j" title="30 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നടത്തുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA അപ്പോൾ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j- 1. അൽഗോരിതത്തിന്റെ അവസാനം എന്തുകൊണ്ട് j യുടെ മൂല്യം" class="link_thumb"> 30 !} 30 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, Step Step i=i+1, Step 2.3 Step 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് j യുടെ മൂല്യം കുറയുന്നത്? അത് വർദ്ധിപ്പിക്കാൻ കഴിയുമോ? എന്താണ് മാറ്റേണ്ടത്? =2 പ്രകടനം: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് മൂല്യം j"> =2 നിർവ്വഹിക്കുന്നു: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2. 2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതത്തിന്റെ അവസാനം. j യുടെ മൂല്യം കുറയുന്നത് എന്തുകൊണ്ട്? അത് വർദ്ധിപ്പിക്കാൻ കഴിയുമോ? എന്താണ് മാറ്റേണ്ടത്?"> =2 ചെയ്യുക: ഘട്ടം 2.1 ഘട്ടം 2.1 i: =1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA തുടർന്ന് Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ട് മൂല്യം j" title="30 അൽഗോരിതത്തിന്റെ ആരംഭം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 അതേസമയം j>=2 നടത്തുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 അതേസമയം iA അപ്പോൾ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j- 1. അൽഗോരിതത്തിന്റെ അവസാനം എന്തുകൊണ്ട് j യുടെ മൂല്യം"> title="30 അൽഗോരിതത്തിന്റെ തുടക്കം. ഘട്ടം 1 ഘട്ടം 1 j:=N, ഘട്ടം 2 ഘട്ടം 2 j>=2 ചെയ്യുമ്പോൾ: ഘട്ടം 2.1 ഘട്ടം 2.1 i:=1;, ഘട്ടം 2.2 ഘട്ടം 2.2 iA എന്നാൽ Val:=A[i]; A[i]:=A; A:=Val, ഘട്ടം 2.2.2 ഘട്ടം 2.2.2 i=i+1, ഘട്ടം 2.3 ഘട്ടം 2.3 j:=j-1. അൽഗോരിതം അവസാനം. എന്തുകൊണ്ടാണ് j മൂല്യം"> !}

35 12 ഷെൽ സോർട്ടിംഗ് ഘട്ടം. 2 ഘടകങ്ങളുടെ 4 ഗ്രൂപ്പുകൾ ഘട്ടം. 4 ഘടകങ്ങളുടെ 2 ഗ്രൂപ്പുകൾ

36 ഷെൽ സോർട്ടിംഗ് ഘട്ടം. ആരോഹണ ക്രമത്തിൽ അടുക്കിയിരിക്കുന്ന 8 ഘടകങ്ങളുടെ 1 ഗ്രൂപ്പ്

37 A N ഷെൽ രീതി ഉപയോഗിച്ച് N മൂലകങ്ങൾ ഉള്ള അറേ A യെ ആരോഹണ ക്രമത്തിൽ അടുക്കേണ്ടത് ആവശ്യമായിരിക്കട്ടെ, സഹായ വേരിയബിളുകൾ j j എന്നത് ശേഷിക്കുന്ന ആദ്യ മൂലകത്തിന്റെ സംഖ്യയാണ്. i i - നീക്കുന്ന മൂലകത്തിന്റെ എണ്ണം. എം എം- ഒപ്റ്റിമൽ സ്റ്റെപ്പ് പി പി - അറേ ഘടകങ്ങൾ നീക്കാൻ ഉപയോഗിക്കുന്ന ഇന്റർമീഡിയറ്റ് മൂല്യം പ്രശ്ന പ്രസ്താവന

45 സോർട്ടിംഗിന്റെ സാരം: ഒരു നിശ്ചിത മൂല്യം (x) തിരഞ്ഞെടുത്തു - ഒരു തടസ്സ ഘടകം, അടുക്കിയ മൂലകങ്ങളുടെ എണ്ണം 2 കൊണ്ട് ഒരു പൂർണ്ണ ഡിവിഷനിലേക്ക് റൗണ്ട് ചെയ്യുന്നതിലൂടെ നിർണ്ണയിക്കപ്പെടുന്നു; x-നേക്കാൾ വലിയ ഒരു മൂലകം കണ്ടെത്തുന്നത് വരെ ഞങ്ങൾ അറേയിലൂടെ ഇടത്തുനിന്ന് വലത്തോട്ട് നീങ്ങുന്നു, തുടർന്ന് x-നേക്കാൾ കുറവുള്ള ഒരു ഘടകം കണ്ടെത്തുന്നത് വരെ ഞങ്ങൾ അത് വലത്തുനിന്ന് ഇടത്തോട്ട് സഞ്ചരിക്കുന്നു.

46 തരംതിരിക്കലിന്റെ സാരാംശം: കണ്ടെത്തിയ ഘടകങ്ങൾ മാറ്റുക. ഏറ്റവും വലുതോ ചെറുതോ ആയ മൂലകം കണ്ടെത്തിയില്ലെങ്കിൽ, കണ്ടെത്തിയ ഏറ്റവും വലുതോ ചെറുതോ ആയ മൂലകം ഉപയോഗിച്ച് മധ്യ മൂലകം മാറ്റപ്പെടും; മധ്യത്തിൽ എത്തിയ നമുക്ക് അറേയുടെ 2 ഭാഗങ്ങളുണ്ട്; അറേ അടുക്കുന്നത് വരെ ഓരോ ഭാഗത്തിനും വേണ്ടിയുള്ള പ്രക്രിയ തുടരുന്നു

7 ലേക്ക് മാറ്റുന്നു വലത് വശം, 16>7 കൈമാറ്റം ചെയ്യപ്പെടാത്തതിനാൽ, 47 വലതുവശത്തേക്ക് മാറ്റാവുന്നതാണ്, കാരണം 16>7, 8>7,11>7, 19>7 കൈമാറ്റം ചെയ്യാനാകില്ല, 7=7 കവി" title="(!LANG :47 ക്വിക്ക് സോർട്ട് 812371911416 ബാരിയർ എലമെന്റ് 4378123 4 ബാരിയർ എലമെന്റ് 8121119 ബാരിയർ എലമെന്റ് 1219 1619 8>7 വലത് വശത്തേക്ക് നീക്കി, കാരണം 16>7 കൈമാറ്റം ചെയ്യപ്പെടാത്തതിനാൽ 47 വലതുവശത്തേക്ക് മാറ്റി, കാരണം 16>7,11> >7, 19>7 അസഹനീയം, 7=7 കവി" class="link_thumb"> 47 !} 47 ദ്രുത സോർട്ടിംഗ് ബാരിയർ എലമെന്റ് ബാരിയർ എലമെന്റ് ബാരിയർ എലമെന്റ് >7 വലതുവശത്തേക്ക് നീക്കി, കാരണം 16>7 കൈമാറ്റം ചെയ്യപ്പെടാത്തതിനാൽ 47 വലതുവശത്തേക്ക് നീക്കി, കാരണം 16>7, 8>7,11>7, 19> 7 കൈമാറ്റം ചെയ്യാനാകുന്നില്ല, 7=7 അതിനാൽ ഞങ്ങൾ 7 സ്വാപ്പ് ചെയ്യുകയും 12 4>3 അടുക്കിയ ഭാഗം 12>11 വലതുവശത്തേക്ക് മാറ്റുകയും ചെയ്യുന്നു, കാരണം >11 കൈമാറാൻ കഴിയില്ല, 811 വലതുവശത്തേക്ക് മാറ്റുന്നു, 16>11, 12 മുതൽ >11,കൈമാറാവുന്നതല്ല, 11 11=11 അങ്ങനെ ഞങ്ങൾ 11 ഉം 19 ഉം സ്വാപ്പ് ചെയ്യുന്നു, അടുക്കിയ ഭാഗം 19>12 വലതുവശത്തേക്ക് മാറ്റുന്നു, കാരണം 16>12,കൈമാറ്റം ചെയ്യാനാകാത്തത്, 12 12=12 അതിനാൽ ഞങ്ങൾ 12, 19 19> 16 എന്നിവ സ്വാപ്പ് ചെയ്യുന്നു. അറേ ആരോഹണ ക്രമത്തിൽ അടുക്കിയിരിക്കുന്നത് 7 ന് തുല്യമായ 7 വലുതാണ് ഞങ്ങൾ 7 നെ വലതുവശത്തേക്ക് നീക്കുന്നു, കാരണം 16>7 കൈമാറ്റം ചെയ്യാനാകില്ല, 47 വലത് വശത്തേക്ക് മാറ്റുന്നു, കാരണം 16>7, 8>7,11>7, 19>7 കൈമാറ്റം ചെയ്യാനാകില്ല, 7=7 കവി"> ഞങ്ങൾ 7 നെ വലത് വശത്തേക്ക് നീക്കുന്നു, കാരണം 16> 7 കൈമാറ്റം ചെയ്യാനാകില്ല, 47 വലത് വശത്തേക്ക് മാറ്റുന്നു, കാരണം 16> 7, 8> 7,11>7, 19> 7 കൈമാറാൻ കഴിയില്ല, 7=7, അതിനാൽ ഞങ്ങൾ സ്വാപ്പ് സ്ഥലങ്ങൾ 7, 12 4>3 അടുക്കിയ ഭാഗം 12>11 വലത് വശത്തേക്ക് മാറ്റുന്നു, കാരണം 8 12 16>11 കൈമാറ്റം ചെയ്യാനാകില്ല, 811 വലതുവശത്തേക്ക് മാറ്റുന്നു, കാരണം 16>11, 12>11 കൈമാറാൻ കഴിയില്ല. . ആരോഹണ ക്രമം Less equals 7 Greater than 7"> 7 എന്നത് വലത് വശത്തേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു, കാരണം 16>7, 16>7, 8>7,11>7, 19>7 മുതൽ 47 എന്നത് വലത് വശത്തേക്ക് മാറ്റുന്നു. കൈമാറ്റം ചെയ്യാനാകുന്നില്ല, 7=7 കവി" title="47 ദ്രുത ക്രമം 812371911416 ബാരിയർ ഘടകം 4378123 4 ബാരിയർ ഘടകം 8121119 ബാരിയർ ഘടകം 1219 1619 8>7 വലത് വശത്തേക്ക് നീക്കി, കാരണം 16>47 കൈമാറ്റം ചെയ്യാനാകില്ല, വലതുവശത്തേക്ക് മാറ്റി, കാരണം 16>7, 8>7,11>7, 19>7 സഹിക്കാൻ പറ്റില്ല, 7=7 കവി"> title="47 ക്വിക്ക് സോർട്ട് 812371911416 ബാരിയർ എലമെന്റ് 4378123 4 ബാരിയർ എലമെന്റ് 8121119 ബാരിയർ എലമെന്റ് 1219 1619 8>7 വലത് വശത്തേക്ക് നീക്കി, കാരണം 16>7 കൈമാറ്റം ചെയ്യാനാകില്ല, 47 വലത് വശത്തേക്ക് നീക്കി, കാരണം 16>7, 11>7, 19>7 അസഹനീയം, 7=7 കവി"> !}

48 A n, n മൂലകങ്ങളുള്ള, ആരോഹണ ക്രമത്തിൽ A യെ അടുക്കാൻ നിങ്ങളെ അനുവദിക്കുക. ദ്രുത രീതിസഹായ വേരിയബിളുകൾ: t - t - അന്തിമ ഘടകം array m - m എന്നത് അറേയുടെ പ്രാരംഭ ഘടകമാണ് x – x എന്നത് മറ്റെല്ലാ ഘടകങ്ങളുമായി ബന്ധപ്പെട്ട ഘടകമാണ്. w - w - അറേ ഘടകങ്ങൾ നീക്കാൻ ഉപയോഗിക്കുന്ന ഇന്റർമീഡിയറ്റ് മൂല്യം പ്രശ്ന പ്രസ്താവന

58 സ്ഥിരത - ഒരു അടുക്കിയ അറേ മൂലകങ്ങളുടെ ക്രമം മാറ്റില്ല ഒരേ മൂല്യങ്ങൾ. കീ 1 ഉം ഒപ്പം തുല്യ മൂലകങ്ങളുടെ ആപേക്ഷിക സ്ഥാനം അധിക ഫീൽഡുകൾ"a", "b", "c" അൽഗോരിതം മൂല്യനിർണ്ണയ പാരാമീറ്ററുകൾ

59 സ്വഭാവത്തിന്റെ സ്വാഭാവികത - ഇതിനകം അടുക്കിയ അല്ലെങ്കിൽ ഭാഗികമായി അടുക്കിയ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുമ്പോൾ രീതിയുടെ ഫലപ്രാപ്തി. ഇൻപുട്ട് സീക്വൻസിന്റെയും പ്രവർത്തനങ്ങളുടെയും ഈ സ്വഭാവം കണക്കിലെടുക്കുമ്പോൾ അൽഗോരിതം സ്വാഭാവികമായി പ്രവർത്തിക്കുന്നു. മെച്ചപ്പെട്ട പാരാമീറ്ററുകൾഅൽഗോരിതം വിലയിരുത്തലുകൾ

60 സെലക്ഷൻ സോർട്ട് അൽഗോരിതത്തിന്റെ വിലയിരുത്തൽ താരതമ്യങ്ങളുടെ ആകെ എണ്ണം C =N-l + N = (N 2 -N)/2 മൊത്തം പ്രവർത്തനങ്ങളുടെ എണ്ണം n + (n-1) + (n-2) + (n-3) = 1 /2 * (n 2 +n) = തീറ്റ(n 2) എക്സ്ചേഞ്ചുകളുടെ എണ്ണം

63 ഒരു ഇൻസെർഷൻ സോർട്ട് അൽഗോരിതം വിലയിരുത്തുന്നു ഒരു അറേയ്ക്ക് N-1 താരതമ്യങ്ങൾ ആവശ്യമാണ്. ഒരു അറേയ്ക്ക് (N 2 -N)/2 താരതമ്യം ആവശ്യമാണ്. തീറ്റ പ്രവർത്തനങ്ങളുടെ ആകെ എണ്ണം (n 2)

66 അല്ല ഫലപ്രദമായ രീതി, ഒരു മൂലകത്തിന്റെ ഉൾപ്പെടുത്തൽ മുമ്പത്തെ എല്ലാ ഘടകങ്ങളെയും ഒരു സ്ഥാനത്തേക്ക് മാറ്റുന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നതിനാൽ, ഈ പ്രവർത്തനം ലാഭകരമല്ലാത്തതാണ്, അൽഗോരിതത്തിന്റെ സ്ഥിരതയും സ്വാഭാവിക സ്വഭാവവും ഒരുമിച്ച് എടുത്താൽ, രീതി ഉണ്ടാക്കുന്നു നല്ല തിരഞ്ഞെടുപ്പ്ഉചിതമായ സാഹചര്യങ്ങളിൽ

70 ലളിതമായ സോർട്ടിംഗ് രീതികളുടെ താരതമ്യം N N - മൂലകങ്ങളുടെ എണ്ണം, M M - കൈമാറ്റങ്ങളുടെ എണ്ണം, C - താരതമ്യങ്ങളുടെ എണ്ണം കുറഞ്ഞത് പരമാവധി ലളിതമായ ഉൾപ്പെടുത്തലുകൾ M=2(n-1) C = n-1 M=2(n-1) C=( n 2 -n)/2 М=(n+3n-4)/2 М=(n 2 +3n-4)/2 ലളിതമായ വിനിമയം C=(n 2 -n)/2M=3(n-1) С =(n 2 -n)/2 М=n/4+3(n-1) М=n 2 /4+3(n-1) ലളിതമായ ചോയ്സ് C=(n 2 -n)/2 M = 0 С =(n 2 -n)/2 М=(n-n)*1.5 М=(n 2 -n)*1.5? കൈമാറ്റങ്ങളുടെ എണ്ണം എത്രയായിരിക്കും?

72 ഷെൽ അൽഗോരിതം n 1.2 മൂല്യനിർണ്ണയം ഓരോ പാസും ഉപയോഗിക്കുന്നതിനാൽ നിർവ്വഹണ സമയം n 1.2 ന് ആനുപാതികമാണ് ചെറിയ സംഖ്യഘടകങ്ങൾ അല്ലെങ്കിൽ അറേ ഘടകങ്ങൾ ഇതിനകം ആപേക്ഷിക ക്രമത്തിലാണ്, കൂടാതെ ഡാറ്റയുടെ ഓരോ പുതിയ കാഴ്ചയിലും ക്രമപ്പെടുത്തൽ വർദ്ധിക്കുന്നു

73 ക്വിക്ക്‌സോർട്ട് അൽഗോരിതം വിലയിരുത്തുന്നു N=2g X N N/2N/2 അറേയുടെ വലുപ്പം രണ്ട് സംഖ്യകളുടെ (N=2g) പവർ ആണെങ്കിൽ, ഓരോ വിഭജനവും അറേയുടെ മധ്യത്തിൽ കൃത്യമായി എലമെന്റ് X സ്ഥാപിക്കുന്നു, തുടർന്ന് ആദ്യം നോക്കുമ്പോൾ , N താരതമ്യങ്ങൾ നടത്തുകയും അറേ N/2 അളക്കുന്ന രണ്ട് ഭാഗങ്ങളായി വിഭജിക്കുകയും ചെയ്യുന്നു. ഈ ഭാഗങ്ങളിൽ ഓരോന്നിനും N/2 താരതമ്യങ്ങൾ ഉണ്ട്. അതിനാൽ C=N+2*(N/2)+4*(N/4)+...+N*(N/N). N N എന്നത് രണ്ടിന്റെ ശക്തിയല്ലെങ്കിൽ, എസ്റ്റിമേറ്റ് അതേ ക്രമത്തിലായിരിക്കും

74 തീറ്റ(n). തീറ്റ(എൻ) പ്രവർത്തനങ്ങളുടെ ആകെ എണ്ണം. log n O(n log n) അറേയെ കൂടുതലോ കുറവോ തുല്യ ഭാഗങ്ങളായി വിഭജിച്ചാൽ ഡിവിഷൻ ഘട്ടങ്ങളുടെ എണ്ണം (ആവർത്തന ഡെപ്ത്) ഏകദേശം log n ആണ്. അതിനാൽ, മൊത്തത്തിലുള്ള പ്രകടനം ഇതാണ്: O(n log n) O(n 2) ഓരോ തവണയും ഇൻപുട്ട് സീക്വൻസിൻറെ പരമാവധി അല്ലെങ്കിൽ കുറഞ്ഞത് കേന്ദ്ര ഘടകമായി തിരഞ്ഞെടുത്താൽ, പ്രകടനം O(n 2) ആണ്.

77 ചോദ്യങ്ങൾ നിയന്ത്രിക്കുക? എന്താണ് "ക്രമീകരിക്കൽ"? ? എന്താണ് തിരഞ്ഞെടുക്കൽ രീതി? ? ഉൾപ്പെടുത്തൽ അടുക്കൽ രീതി എന്താണ്? ? ബബിൾ അടുക്കൽ രീതി എന്താണ്? ? എന്താണ് പെട്ടെന്നുള്ള അടുക്കൽ രീതി? ? എന്താണ് ഷെല്ലിന്റെ സോർട്ടിംഗ് രീതി?

78 ടെസ്റ്റ് ചോദ്യങ്ങൾ? ഏത് സോർട്ടിംഗ് അൽഗോരിതം ഏറ്റവും ലളിതമായി കണക്കാക്കപ്പെടുന്നു? ? ഏത് സോർട്ടിംഗ് അൽഗോരിതം ആണ് ഏറ്റവും കാര്യക്ഷമമായി കണക്കാക്കുന്നത്? ? സോർട്ടിംഗ് അൽഗോരിതങ്ങളുടെ എത്ര ഗ്രൂപ്പുകൾ ഉണ്ട്? ? ഏത് മാനദണ്ഡമനുസരിച്ചാണ് സോർട്ടിംഗ് അൽഗോരിതങ്ങളുടെ സവിശേഷത? ? ഒരു സോർട്ടിംഗ് അൽഗോരിതം തിരഞ്ഞെടുക്കുമ്പോൾ നിങ്ങൾ എന്താണ് പരിഗണിക്കേണ്ടത്?

ഇത് ഏറ്റവും വേഗതയേറിയ രീതിയായി കണക്കാക്കുന്നില്ല എന്ന് മാത്രമല്ല, മന്ദഗതിയിലുള്ള ഓർഡറിംഗ് രീതികളുടെ പട്ടിക അടയ്ക്കുകയും ചെയ്യുന്നു. എന്നിരുന്നാലും, ഇതിന് അതിന്റെ ഗുണങ്ങളുണ്ട്. അതിനാൽ, നിങ്ങൾക്ക് ഒരു നിശ്ചിത ക്രമത്തിൽ ഘടകങ്ങൾ ക്രമീകരിക്കണമെങ്കിൽ പ്രശ്നത്തിനുള്ള ഏറ്റവും യുക്തിസഹവും സ്വാഭാവികവുമായ പരിഹാരമാണ് ബബിൾ സോർട്ടിംഗ്. ഒരു സാധാരണക്കാരൻസ്വമേധയാ, ഉദാഹരണത്തിന്, അത് കൃത്യമായി ഉപയോഗിക്കും - അവബോധത്താൽ.

അത്തരമൊരു അസാധാരണ പേര് എവിടെ നിന്ന് വന്നു?

വെള്ളത്തിലെ വായു കുമിളകളുമായുള്ള സാമ്യം ഉപയോഗിച്ചാണ് ഈ രീതിയുടെ പേര് കണ്ടുപിടിച്ചത്. ഇതൊരു രൂപകമാണ്. ചെറിയ വായു കുമിളകൾ മുകളിലേക്ക് ഉയരുന്നതുപോലെ - എല്ലാത്തിനുമുപരി, അവയുടെ സാന്ദ്രത ഏതൊരു ദ്രാവകത്തേക്കാളും കൂടുതലാണ് (ഈ സാഹചര്യത്തിൽ, വെള്ളം), അതിനാൽ അറേയുടെ ഓരോ മൂലകവും ചെറുതാണ്, അതിന്റെ മൂല്യം ചെറുതാണ്, അത് ക്രമേണ അതിന്റെ രൂപപ്പെടുത്തുന്നു. സംഖ്യകളുടെ പട്ടികയുടെ തുടക്കത്തിലേക്കുള്ള വഴി.

അൽഗോരിതം വിവരണം

ബബിൾ സോർട്ട് ഇതുപോലെ പ്രവർത്തിക്കുന്നു:

ആദ്യ പാസ്: സംഖ്യകളുടെ അറേയുടെ ഘടകങ്ങൾ ഒരു സമയം രണ്ട് എടുക്കുകയും ജോഡികളായി താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു. ചില ജോടി ഘടകങ്ങളിൽ ആദ്യ മൂല്യം രണ്ടാമത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ, പ്രോഗ്രാം അവയെ സ്വാപ്പ് ചെയ്യുന്നു;
അതിനാൽ അറേയുടെ അവസാനത്തിൽ അവസാനിക്കുന്നു. മറ്റെല്ലാ ഘടകങ്ങളും അതേപടി നിലനിൽക്കുമ്പോൾ, താറുമാറായ ക്രമത്തിൽ, കൂടുതൽ അടുക്കൽ ആവശ്യമാണ്;
അതുകൊണ്ടാണ് രണ്ടാമത്തെ പാസ് ആവശ്യമായി വരുന്നത്: മുമ്പത്തേതുമായി (ഇതിനകം വിവരിച്ചത്) സാമ്യം ഉപയോഗിച്ചാണ് ഇത് നടപ്പിലാക്കുന്നത്, കൂടാതെ താരതമ്യങ്ങളുടെ എണ്ണം ഉണ്ട് - മൈനസ് ഒന്ന്;
പാസേജ് നമ്പർ ത്രീ രണ്ടാമത്തേതിനേക്കാൾ ഒരു താരതമ്യവും ആദ്യത്തേതിനേക്കാൾ രണ്ടെണ്ണവും കുറവാണ്. ഇത്യാദി;
ഓരോ പാസിനും എന്താണ് ഉള്ളതെന്ന് നമുക്ക് സംഗ്രഹിക്കാം (അറേയിലെ മൊത്തം മൂല്യങ്ങൾ, നിർദ്ദിഷ്ട നമ്പർ) മൈനസ് (പാസ് നമ്പർ) താരതമ്യങ്ങൾ.

അതിലും ചെറിയ അൽഗോരിതം ഭാവി പരിപാടിഇങ്ങനെ എഴുതാം:

ഏതെങ്കിലും രണ്ട് സംഖ്യകൾ കണ്ടെത്തുന്നതുവരെ സംഖ്യകളുടെ നിര പരിശോധിക്കും, അവയിൽ രണ്ടാമത്തേത് ആദ്യത്തേതിനേക്കാൾ വലുതായിരിക്കണം;
പരസ്പരം ബന്ധപ്പെട്ട് തെറ്റായി സ്ഥാനം പിടിച്ചിരിക്കുന്ന അറേ ഘടകങ്ങളെ പ്രോഗ്രാം സ്വാപ്പ് ചെയ്യുന്നു.

വിവരിച്ച അൽഗോരിതം അടിസ്ഥാനമാക്കിയുള്ള സ്യൂഡോകോഡ്

ഏറ്റവും ലളിതമായ നടപ്പാക്കൽഇതുപോലെ ചെയ്തു:

നടപടിക്രമം Sortirovka_Puzirkom;

ആരംഭിക്കുക

വേണ്ടി ലൂപ്പ് ജെനിന്ന് പ്രാരംഭ_സൂചികമുമ്പ് konechii_index;

വേണ്ടി ലൂപ്പ് ഐനിന്ന് പ്രാരംഭ_സൂചികമുമ്പ് konechii_index-1;

എങ്കിൽ മാസ്സിവ്[i]>മാസിവ്

(മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്യുക);

അവസാനിക്കുന്നു

തീർച്ചയായും, ഇവിടെ ലാളിത്യം സാഹചര്യത്തെ കൂടുതൽ വഷളാക്കുകയേയുള്ളൂ: അതിലും ലളിതമായ അൽഗോരിതം, പ്രത്യേകിച്ച് എല്ലാ കുറവുകളും അതിൽ പ്രത്യക്ഷപ്പെടുന്നതിനാൽ. ഒരു ചെറിയ അറേയ്‌ക്ക് പോലും സമയ ഉപഭോഗം വളരെ വലുതാണ് (ആപേക്ഷികത ഇവിടെ പ്രവർത്തിക്കുന്നു: ശരാശരി വ്യക്തിക്ക്, സമയത്തിന്റെ അളവ് ചെറുതായി തോന്നിയേക്കാം, എന്നാൽ ഒരു പ്രോഗ്രാമറുടെ ബിസിനസ്സിൽ, ഓരോ സെക്കൻഡും അല്ലെങ്കിൽ മില്ലിസെക്കൻഡും കണക്കാക്കുന്നു).

മെച്ചപ്പെട്ട നടപ്പാക്കൽ ആവശ്യമായിരുന്നു. ഉദാഹരണത്തിന്, ഒരു അറേയിലെ മൂല്യങ്ങളുടെ സ്വാപ്പിംഗ് കണക്കിലെടുക്കുമ്പോൾ:

നടപടിക്രമം Sortirovka_Puzirkom;

ആരംഭിക്കുക

sortirovka = സത്യം;

ഇതുവരെ സൈക്കിൾ sortirovka = സത്യം;

sortirovka = തെറ്റ്;

വേണ്ടി ലൂപ്പ് ഐനിന്ന് പ്രാരംഭ_സൂചികമുമ്പ് konechii_index-1;

എങ്കിൽ മാസ്സിവ്[i]>മാസിവ്(ആദ്യ ഘടകം രണ്ടാമത്തേതിനേക്കാൾ വലുതാണ്), തുടർന്ന്:

(സ്വാപ്പ് ഘടകങ്ങൾ);

sortirovka = സത്യം; (വിനിമയം നടത്തിയതായി സൂചിപ്പിച്ചു).

അവസാനിക്കുന്നു.

രീതിയുടെ പോരായ്മകൾ

പ്രധാന പോരായ്മ പ്രക്രിയയുടെ ദൈർഘ്യമാണ്. ഒരു കുമിള ഉണ്ടാക്കാൻ എത്ര സമയമെടുക്കും?

അറേയിലെ സംഖ്യകളുടെ ചതുരത്തിൽ നിന്നാണ് നിർവ്വഹണ സമയം കണക്കാക്കുന്നത് - അന്തിമ ഫലം അതിന് ആനുപാതികമാണ്.

ഏറ്റവും മോശം സാഹചര്യത്തിൽ, അറേയിൽ ഒരു മൂല്യം മൈനസ് ചെയ്യുന്ന മൂലകങ്ങൾ ഉള്ള അതേ എണ്ണം പ്രാവശ്യം കടന്നുപോകും. ഇത് സംഭവിക്കുന്നത്, ഒടുവിൽ താരതമ്യം ചെയ്യാൻ ഒന്നുമില്ലാതെ ഒരു ഘടകം മാത്രമേ അവശേഷിക്കുന്നുള്ളൂ, അറേയിലൂടെയുള്ള അവസാനത്തെ കടന്നുകയറ്റം ഉപയോഗശൂന്യമായ പ്രവർത്തനമായി മാറുന്നു.

കൂടാതെ, സോർട്ടിംഗ് രീതി ഫലപ്രദമാണ് ലളിതമായ കൈമാറ്റങ്ങൾ, എന്നും വിളിക്കപ്പെടുന്നതുപോലെ, അറേകൾക്ക് മാത്രമുള്ളതാണ് ചെറിയ വലിപ്പം. അതിന്റെ സഹായത്തോടെ വലിയ അളവിലുള്ള ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ല: ഫലം ഒന്നുകിൽ പിശകുകളോ പ്രോഗ്രാം പരാജയമോ ആയിരിക്കും.

പ്രയോജനങ്ങൾ

ബബിൾ സോർട്ട് മനസ്സിലാക്കാൻ വളരെ ലളിതമാണ്. IN വിദ്യാഭ്യാസ പരിപാടികൾഅറേ മൂലകങ്ങളുടെ ക്രമം പഠിക്കുമ്പോൾ സാങ്കേതിക സർവ്വകലാശാലകൾ അത് ആദ്യം എടുക്കുന്നു. ഈ രീതി ഭാഷയിലും എളുപ്പത്തിൽ നടപ്പിലാക്കുന്നു ഡെൽഫി പ്രോഗ്രാമിംഗ്(D (ഡെൽഫി), C/C++ (C/C പ്ലസ് പ്ലസ്), ശരിയായ ക്രമത്തിൽ മൂല്യങ്ങൾ ക്രമീകരിക്കുന്നതിനുള്ള അവിശ്വസനീയമാംവിധം ലളിതമായ അൽഗോരിതം, തുടക്കക്കാർക്ക് ബബിൾ സോർട്ട് അനുയോജ്യമാണ്.

അതിന്റെ പോരായ്മകൾ കാരണം, അൽഗോരിതം പാഠ്യേതര ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നില്ല.