ඇල්ගොරිතමයක කාල සංකීර්ණත්වය සොයා ගන්නේ කෙසේද

ප්රශ්නය

ඇල්ගොරිතමයක කාල සංකීර්ණත්වය සොයා ගන්නේ කෙසේද?

SO හි ප්‍රශ්නයක් පළ කිරීමට පෙර මා කුමක් කර ඇත්ද?

මම හරහා ගොස් ඇති මෙම , මෙම බොහෝ සබැඳි සහ

නමුත් කාල සංකීර්ණත්වය ගණනය කරන්නේ කෙසේද යන්න පිළිබඳ පැහැදිලි හා forward ජු ඉදිරි පැහැදිලි කිරීමක් සොයා ගැනීමට මට නොහැකි විය.

මා දන්නේ කුමක්ද?

පහත කේතය තරම් සරල කේතයක් සඳහා කියන්න:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

පහත දැක්වෙන ආකාරයට ලූපයක් සඳහා කියන්න:

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; මෙය ක්‍රියාත්මක වන්නේ එක් වරක් පමණි . කාලය සැබවින්ම ගණනය කරනු i=0ලබන්නේ ප්‍රකාශයට නොවේ.

i <එන්; මෙය N + 1 වතාවක් ක්‍රියාත්මක වේ

i ++; මෙය N වතාවක් ක්‍රියාත්මක වේ

එබැවින් මෙම ලූපයට අවශ්‍ය මෙහෙයුම් ගණන වේ

{1+ (N + 1) + N} = 2N + 2

සටහන: කාලය තවමත් ගණනය කිරීම පිළිබඳ මගේ අවබෝධය ගැන මට විශ්වාසයක් නොමැති බැවින් මෙය තවමත් වැරදිය

මට දැන ගැනීමට අවශ්‍ය කුමක්ද?

හරි, ඉතින් මේ කුඩා මූලික ගණනය කිරීම් මම දන්නවා යැයි මම සිතමි, නමුත් බොහෝ අවස්ථාවලදී කාලය සංකීර්ණ බව මම දැක ඇත්තෙමි

සාමාන්ය (N), සාමාන්ය (N2), සාමාන්ය (n-සටහන), සාමාන්ය (n!) .... බොහෝ වෙනත් ,

ඇල්ගොරිතමයක කාල සංකීර්ණත්වය ගණනය කරන්නේ කෙසේදැයි තේරුම් ගැනීමට කිසිවෙකුට මට උදව් කළ හැකිද? මෙය දැන ගැනීමට මා වැනි නවක වදය ඕනෑ තරම් ඇති බව මට විශ්වාසයි.

ඇල්ගොරිතමයක කාල සංකීර්ණත්වය සොයා ගන්නේ කෙසේද

එහි ආදානයේ විශාලත්වයේ ශ්‍රිතයක් ලෙස එය ක්‍රියාත්මක කරන යන්ත්‍ර උපදෙස් කීයක් ඔබ එකතු කරනවාද, පසුව ප්‍රකාශනය විශාලතම (N ඉතා විශාල වූ විට) යෙදුමට සරල කරන අතර ඕනෑම සරල නියත සාධකයක් ඇතුළත් කළ හැකිය.

උදාහරණයක් ලෙස, 2N + 2මෙය සාධාරණ ලෙස විස්තර කිරීම සඳහා අපි යන්ත්‍ර උපදෙස් සරල කරන්නේ කෙසේදැයි බලමු O(N).

ඇයි අපි 2s දෙක ඉවත් කරන්නේ ?

N විශාල වන විට ඇල්ගොරිතමයේ ක්‍රියාකාරිත්වය ගැන අපි උනන්දු වෙමු.

2N සහ 2 යන පද දෙක සලකා බලන්න.

N විශාල වන විට මෙම පද දෙකේ සාපේක්ෂ බලපෑම කුමක්ද? N මිලියනයක් යැයි සිතමු.

පළමු වාරය මිලියන 2 ක් වන අතර දෙවන වාරය 2 ක් පමණි.

මේ හේතුව නිසා, අපි විශාල එන් සඳහා විශාලතම යෙදුම් හැර අනෙක් සියල්ල අතහැර දමමු.

ඒ නිසා, දැන් අපි ගිහින් ඇති 2N + 2කිරීමට 2N.

සාම්ප්‍රදායිකව, අප උනන්දු වන්නේ නිරන්තර සාධක දක්වා කාර්ය සාධනය කෙරෙහි පමණි .

මෙයින් අදහස් කරන්නේ N විශාල වන විට කාර්ය සාධනයේ නියත බහුවිධ වෙනසක් තිබේ නම් අප සැබවින්ම ගණන් නොගන්නා බවයි. 2N හි ඒකකය කෙසේ වෙතත් මුලින් ම මනාව අර්ථ දක්වා නැත. එබැවින් සරලම ප්‍රකාශනය ලබා ගැනීම සඳහා නියත සාධකයක් මගින් අපට ගුණ කිරීම හෝ බෙදීම කළ හැකිය.

එබැවින් 2Nසාධාරණ බවට පත්වේ N.

මෙය විශිෂ්ට ලිපියකි: http://www.daniweb.com/software-development/computer-science/threads/13488/time-complexity-of-algorithm

පහත පිළිතුර ඉහළින් පිටපත් කර ඇත (විශිෂ්ට සබැඳිය කඩාවැටුණහොත්)

කාල සංකීර්ණතාව ගණනය කිරීම සඳහා වඩාත් පොදු මෙට්‍රික් එක වන්නේ බිග් ඕ අංකනයයි. N අනන්තය කරා ළඟා වන විට N ට සාපේක්ෂව ධාවන කාලය තක්සේරු කළ හැකි වන පරිදි මෙය සියලු නියත සාධක ඉවත් කරයි. පොදුවේ ඔබට මේ ගැන සිතිය හැකිය:

statement;

නියතයි. එන් සම්බන්ධව ප්‍රකාශයේ ධාවන කාලය වෙනස් නොවේ.

for ( i = 0; i < N; i++ )
     statement;

රේඛීය වේ. ලූපයේ ධාවන කාලය N ට සමානුපාතික වේ. N දෙගුණ වන විට ධාවන කාලය ද එසේමය.

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

චතුරස්රාකාර වේ. ලූප දෙකේ ධාවන කාලය N වර්ගයට සමානුපාතික වේ. N දෙගුණ වන විට, ධාවන කාලය N * N මගින් වැඩි වේ.

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

ල ar ු ගණකය වේ. ඇල්ගොරිතමයේ ධාවන කාලය N 2 න් බෙදිය හැකි වාර ගණනට සමානුපාතික වේ. මෙයට හේතුව ඇල්ගොරිතම එක් එක් නැවතීමේ ක්‍රියාවලිය සමඟ වැඩ කරන ප්‍රදේශය අඩකින් බෙදීමයි.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

N * ලොග් (N) වේ. ධාවන කාලය ල ar ු ගණක N ලූප (පුනරාවර්තන හෝ පුනරාවර්තන) වලින් සමන්විත වේ, එබැවින් ඇල්ගොරිතම යනු රේඛීය හා ල ar ු ගණකයේ එකතුවකි.

පොදුවේ ගත් කල, සෑම අයිතමයක් සමඟම එක් මානයකින් යමක් කිරීම රේඛීය වන අතර, සෑම අයිතමයක් සමඟම මානයන් දෙකකින් යමක් කිරීම චතුරස්රාකාර වන අතර, වැඩ කරන ප්‍රදේශය අඩකින් බෙදීම ල ar ු ගණකය වේ. Big න, on ාතීය සහ වර්ග මූල වැනි වෙනත් විශාල O මිනුම් ඇත, නමුත් ඒවා එතරම් පොදු නොවේ. බිග් ඕ අංකනය විස්තර කරන්නේ මිනුම O ( <type> )කොහේද <type>යන්නයි. ක්වික්සෝර්ට් ඇල්ගොරිතම ලෙස විස්තර කෙරේ O ( N * log ( N ) ).

මේ කිසිවක් හොඳම, සාමාන්‍ය හා නරකම පියවර සැලකිල්ලට ගෙන නැති බව සලකන්න. සෑම කෙනෙකුටම තමන්ගේම බිග් ඕ අංකනයක් ඇත. මෙය ඉතා සරල පැහැදිලි කිරීමක් බව සලකන්න. බිග් ඕ වඩාත් සුලභ ය, නමුත් එය මා පෙන්වා ඇති වඩා සංකීර්ණ ය. ලොකු ඔමේගා, කුඩා ඕ, සහ ලොකු තේටා වැනි වෙනත් අංකනයන් ද ඇත. ඇල්ගොරිතම විශ්ලේෂණ පා .මාලාවෙන් පරිබාහිරව ඔබට ඒවා හමු නොවනු ඇත. ;)

මෙතැන් සිට ගත් විට - ඇල්ගොරිතමයක කාල සංකීර්ණත්වය පිළිබඳ හැඳින්වීම

1. හැඳින්වීම

පරිගණක විද්‍යාවේදී, ඇල්ගොරිතමයක කාල සංකීර්ණත්වය, ආදානය නිරූපණය කරන නූලෙහි දිගෙහි ශ්‍රිතයක් ලෙස ක්‍රියාත්මක වීමට ඇල්ගොරිතමයක් විසින් ගත කරන කාලය ගණනය කරයි.

2. විශාල ඕ අංකනය

ඇල්ගොරිතමයක කාල සංකීර්ණතාව සාමාන්‍යයෙන් ප්‍රකාශ වන්නේ විශාල O අංකනයෙනි, එය සංගුණක සහ පහළ පෙළ නියමයන් බැහැර කරයි. මේ ආකාරයෙන් ප්‍රකාශ කරන විට, කාල සංකීර්ණතාව අසමමිතික ලෙස විස්තර කෙරේ, එනම් ආදාන ප්‍රමාණය අනන්තය දක්වා ගමන් කරයි.

උදාහරණයක් ලෙස, n ප්‍රමාණයේ සියලු යෙදවුම් සඳහා ඇල්ගොරිතමයකට අවශ්‍ය කාලය උපරිම 5n ³ + 3n නම්, අසමමිතික කාල සංකීර්ණතාව O (n ³ ) වේ. ඒ ගැන වැඩි විස්තර පසුව.

තවත් උදාහරණ කිහිපයක්:

• 1 = ඕ (එන්)
• n = O (n ² )
• log (n) = O (n)
• 2 n + 1 = O (n)

3. ඕ (1) නියත කාලය:

ආදාන ප්‍රමාණය නොසලකා ඇල්ගොරිතමයට නියත වේලාවක ක්‍රියාත්මක වන බව කියනු ලැබේ.

උදාහරණ:

• අරාව: ඕනෑම මූලද්‍රව්‍යයකට ප්‍රවේශ වීම
• ස්ථාවර ප්‍රමාණයේ තොගය: තල්ලු සහ පොප් ක්‍රම
• ස්ථාවර ප්‍රමාණයේ පෝලිම්: එන්කියු සහ ඩියුක් ක්‍රම

4. ඕ (එන්) රේඛීය වේලාව

ඇල්ගොරිතමයක් රේඛීය වේලාවක ක්‍රියාත්මක වන බව කියනු ලැබේ, එහි කාලය ක්‍රියාත්මක කිරීම ආදාන ප්‍රමාණයට කෙලින්ම සමානුපාතික වේ, එනම් ආදාන ප්‍රමාණය වැඩි වන විට කාලය රේඛීයව වර්ධනය වේ.

පහත දැක්වෙන උදාහරණ සලකා බලන්න, පහත මම මූලද්‍රව්‍යයක් රේඛීයව සොයමි, මෙය O (n) හි කාල සංකීර්ණතාවයක් ඇත.

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

තවත් උදාහරණ:

• අරාව: රේඛීය සෙවීම, ගමන් කිරීම, අවම සොයා ගැනීම යනාදිය
• ArrayList: ක්‍රමය අඩංගු වේ
• පෝලිම්: ක්රමය අඩංගු වේ

5. ඕ (ලොග් එන්) ල ar ු ගණක වේලාව:

ඇල්ගොරිතමයක් ආදාන ප්‍රමාණයේ ල ar ු ගණකයට සමානුපාතික වන්නේ නම් එය ල ar ු ගණක වේලාවේ ක්‍රියාත්මක වන බව කියනු ලැබේ.

උදාහරණය: ද්විමය සෙවීම

"ප්‍රශ්න විස්සක්" ක්‍රීඩාව සිහිපත් කරන්න - කාර්යය වන්නේ සැඟවුණු අංකයක වටිනාකම පරතරයකින් අනුමාන කිරීමයි. ඔබ අනුමාන කරන සෑම අවස්ථාවකම, ඔබේ අනුමානය ඉතා ඉහළ හෝ අඩු දැයි ඔබට කියනු ලැබේ. ප්‍රශ්න විස්සක ක්‍රීඩාවෙන් ඇඟවෙන්නේ ඔබේ අනුමාන අංකය භාවිතා කරමින් කාල පරතරය අඩකින් අඩු කිරීමයි. මෙය ද්විමය සෙවීම ලෙස හැඳින්වෙන පොදු ගැටළු විසඳීමේ ක්‍රමයට උදාහරණයකි

6. O (n ² ) චතුරස්රාකාර කාලය

ඇල්ගොරිතමයක් එහි කාලය ක්‍රියාත්මක කිරීම ආදාන ප්‍රමාණයේ වර්ගයට සමානුපාතික නම් එය චතුරස්රාකාර වේලාවක ක්‍රියාත්මක වන බව කියනු ලැබේ.

උදාහරණ:

• බුබුලු වර්ග කිරීම
• තේරීම් වර්ග කිරීම
• ඇතුළත් කිරීමේ වර්ග කිරීම

7. ප්‍රයෝජනවත් සබැඳි කිහිපයක්

• බිග්-ඕ වැරදි වැටහීම්
• ඇල්ගොරිතමයේ සංකීර්ණත්වය තීරණය කිරීම
• බිග් ඕ වංචා පත්‍රය

මෙම ප්‍රශ්නයට හොඳ පිළිතුරු කිහිපයක් තිබුණද. උදාහරණ කිහිපයක් සමඟ මෙහි තවත් පිළිතුරක් දීමට මම කැමතියි loop.

• O (n) : ලූප විචල්‍යයන් නියත ප්‍රමාණයකින් වැඩි කළහොත් / අඩු කළ හොත් ලූපයක සංකීර්ණතාව O (n) ලෙස සැලකේ . උදාහරණයක් ලෙස පහත සඳහන් ශ්‍රිතයන්ට O (n) කාල සංකීර්ණතාවයක් ඇත.

  // Here c is a positive integer constant   
  for (int i = 1; i <= n; i += c) {  
      // some O(1) expressions
  }
  
  for (int i = n; i > 0; i -= c) {
      // some O(1) expressions
  }
  

• O (n ^ c) : කැදැලි වළළු වල කාල සංකීර්ණත්වය අභ්‍යන්තර ප්‍රකාශය ක්‍රියාත්මක කරන වාර ගණනට සමාන වේ. උදාහරණයක් ලෙස පහත දැක්වෙන නියැදි ලූපවල O (n ^ 2) කාල සංකීර්ණතාවයක් ඇත

  for (int i = 1; i <=n; i += c) {
     for (int j = 1; j <=n; j += c) {
        // some O(1) expressions
     }
  }
  
  for (int i = n; i > 0; i += c) {
     for (int j = i+1; j <=n; j += c) {
        // some O(1) expressions
  }
  

  උදාහරණයක් ලෙස තෝරා ගැනීමේ වර්ග කිරීම සහ ඇතුළත් කිරීමේ වර්ග කිරීම O (n ^ 2) කාල සංකීර්ණතාවයක් ඇත.

• O (Logn) වේලාව ලූප විචල්‍යයන් නියත ප්‍රමාණයකින් බෙදූ විට / ගුණ කළහොත් ලූපයක සංකීර්ණත්වය O (Logn) ලෙස සැලකේ .

  for (int i = 1; i <=n; i *= c) {
     // some O(1) expressions
  }
  for (int i = n; i > 0; i /= c) {
     // some O(1) expressions
  }
  

  උදාහරණයක් ලෙස ද්විමය සෙවුමට O (Logn) කාල සංකීර්ණතාවයක් ඇත.

• O (LogLogn) වේලාව ලූප විචල්‍යයන් නියත ප්‍රමාණයකින් on ාතීය ලෙස අඩු වුවහොත් / වැඩි වුවහොත් ලූපයක සංකීර්ණත්වය O (LogLogn) ලෙස සැලකේ .

  // Here c is a constant greater than 1   
  for (int i = 2; i <=n; i = pow(i, c)) { 
     // some O(1) expressions
  }
  //Here fun is sqrt or cuberoot or any other constant root
  for (int i = n; i > 0; i = fun(i)) { 
     // some O(1) expressions
  }
  

කාල සංකීර්ණතා විශ්ලේෂණයට එක් උදාහරණයක්

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

විශ්ලේෂණය :

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

එබැවින් ඉහත ඇල්ගොරිතමයේ මුළු කාල සංකීර්ණතාව වන්නේ (n + n/2 + n/3 + … + n/n), එය බවට පත්වේn * (1/1 + 1/2 + 1/3 + … + 1/n)

ශ්‍රේණියේ වැදගත් දෙය O (Logn)(1/1 + 1/2 + 1/3 + … + 1/n) ට සමාන වේ . එබැවින් ඉහත කේතයේ කාල සංකීර්ණතාව O (nLogn) වේ.

අංකය: 1 2 3

උදාහරණ සමඟ කාල සංකීර්ණත්වය

1 - මූලික මෙහෙයුම් (අංක ගණිතය, සැසඳීම්, අරාවේ මූලද්‍රව්‍යයන්ට ප්‍රවේශ වීම, පැවරුම): ධාවන කාලය සැමවිටම නියත වේ O (1)

උදාහරණයක් :

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - එසේ නම් වෙනත් ප්‍රකාශයක්: හැකි ප්‍රකාශ දෙකකින් හෝ වැඩි ගණනකින් උපරිම ධාවන කාලය ගැනීම පමණි.

උදාහරණයක්:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

එබැවින්, ඉහත ව්‍යාජ කේතයේ සංකීර්ණතාව T (n) = 2 + 1 + උපරිම (1, 1 + 2) = 6. මේ අනුව, එහි විශාල ඕ තවමත් නියත T (n) = O (1) වේ.

3 - ලූප් කිරීම (සඳහා, නැවත නැවත සඳහා): මෙම ප්‍රකාශය සඳහා ධාවන කාලය යනු එම ලූපය තුළ ඇති මෙහෙයුම් ගණනින් ගුණ කළ හැකි ලූප ගණනයි.

උදාහරණයක්:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

ඉතින්, එහි සංකීර්ණත්වය T (n) = 1 + 4n + 1 = 4n + 2. මේ අනුව, T (n) = O (n) වේ.

4 - නෙස්ටඩ් ලූප් (ලූප ඇතුළත ලූප): ප්‍රධාන ලූපය තුළ අවම වශයෙන් එක් ලූපයක්වත් ඇති බැවින්, මෙම ප්‍රකාශයේ ධාවන කාලය O (n ^ 2) හෝ O (n ^ 3) භාවිතා කරයි.

උදාහරණයක්:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

පොදු ධාවන කාලය

ඇල්ගොරිතමයක් විශ්ලේෂණය කිරීමේදී පොදු ධාවන වේලාවන් කිහිපයක් තිබේ:

1. O (1) - නියත වේලාව නියත වේලාව යනු ධාවන කාලය නියත ය, එය ආදාන ප්‍රමාණයට බලපාන්නේ නැත .

2. O (n) - රේඛීය වේලාව ඇල්ගොරිතමයක් n ආදාන ප්‍රමාණය පිළිගත් විට, එය n මෙහෙයුම් ද සිදු කරයි.

3. O (log n) - O (log n) ධාවන කාලය ඇති ල ar ු ගණක කාල ඇල්ගොරිතම O (n) ට වඩා මඳක් වේගවත් වේ. පොදුවේ ගත් කල, ඇල්ගොරිතම ගැටළුව එකම ප්‍රමාණයේ උප ගැටළු වලට බෙදයි. උදාහරණය: ද්විමය සෙවුම් ඇල්ගොරිතම, ද්විමය පරිවර්තන ඇල්ගොරිතම.

4. O (n log n) - රේඛීය ගණිත කාලය මෙම ධාවන කාලය බොහෝ විට "බෙදීම් සහ යටත් කිරීමේ ඇල්ගොරිතම" වල දක්නට ලැබෙන අතර එමඟින් ගැටළුව උප ගැටළු වලට පුනරාවර්තනය වන අතර ඒවා n වේලාවට ඒකාබද්ධ වේ. උදාහරණය: වර්ග කිරීමේ ඇල්ගොරිතම ඒකාබද්ධ කරන්න.

5. O (n ² ) - චතුරස්රාකාර වේලාව බලන්න බබල් වර්ග කිරීමේ ඇල්ගොරිතම!

6. O (n ³ ) - ic න කාලය එයට O (n ² ) හා සමාන මූලධර්මයක් ඇත .

7. O (2 ⁿ ) - on ාතීය කාලය ආදානය විශාල වන විට එය ඉතා මන්දගාමී වේ, n = 1000.000 නම්, T (n) 21000.000 වනු ඇත. තිරිසන් බල ඇල්ගොරිතමයට මෙම ධාවන කාලය තිබේ.

8. ඕ (එන්!) - සාධක වේලාව අඩුයි !!! උදාහරණය: සංචාරක විකුණුම්කරුගේ ගැටලුව (TSP)

සිට ගෙන මෙම ලිපිය . ඉතා හොඳින් පැහැදිලි කළ විට කියවීමක් කළ යුතුය.

ඔබ කේතය විශ්ලේෂණය කරන විට, ඔබ එය පේළියකින් විශ්ලේෂණය කළ යුතුය, සෑම මෙහෙයුමක්ම ගණනය කිරීම / කාල සංකීර්ණත්වය හඳුනා ගැනීම, අවසානයේදී, සම්පූර්ණ පින්තූරය ලබා ගැනීම සඳහා ඔබ එය එකතු කළ යුතුය.

උදාහරණයක් ලෙස, ඔබට රේඛීය සංකීර්ණතාවයෙන් යුත් එක් සරල පුඩුවක් තිබිය හැකිය , නමුත් පසුව එම වැඩසටහනේදීම ඔබට ත්‍රිත්ව පුඩුවක් cub නක සංකීර්ණතාවයක් තිබිය හැකිය , එබැවින් ඔබේ වැඩසටහනට ic නක සංකීර්ණතාවයක් ඇත. වර්ධනයේ ක්‍රියාකාරී අනුපිළිවෙල මෙතැනින් ක්‍රියාත්මක වේ.

ඇල්ගොරිතමයක කාල සංකීර්ණත්වය සඳහා ඇති හැකියාවන් මොනවාදැයි අපි බලමු, මා ඉහත සඳහන් කළ වර්ධන අනුපිළිවෙල ඔබට දැක ගත හැකිය:

• නියත කාලයට වර්ධන අනුපිළිවෙලක් ඇත1, උදාහරණයක් ලෙස :a = b + c.

• ල ar ු ගණක වේලාවට වර්ධන අනුපිළිවෙලක් ඇතLogN, එය සාමාන්‍යයෙන් සිදුවන්නේ ඔබ යමක් අඩකින් බෙදූ විට (ද්විමය සෙවීම, ගස්, ලූප පවා) හෝ යමක් එකම ආකාරයකින් ගුණ කිරීමෙනි.

• Nඋදාහරණයක් ලෙස රේඛීය , වර්ධන අනුපිළිවෙල

  int p = 0;
  for (int i = 1; i < N; i++)
    p = p + 2;
  

• රේඛීය ගණිතය , වර්ධන අනුපිළිවෙලn*logNසාමාන්‍යයෙන් සිදුවන්නේ බෙදීම් සහ ඇල්ගොරිතම ජය ගැනීමෙනි.

• ඝන වර්ධනය, සඳහාN^3, කදිම උදාහරණයක් ඔබ සියලු ත්රිත්ව පරීක්ෂා එහිදී ත්රිත්ව පුඩුවක් වේ:

  int x = 0;
  for (int i = 0; i < N; i++)
     for (int j = 0; j < N; j++)
        for (int k = 0; k < N; k++)
            x = x + 2
  

• On ාතීය , වර්ධන අනුපිළිවෙල2^N, සාමාන්‍යයෙන් සිදුවන්නේ ඔබ පරිපූර්ණ සෙවීමක් කරන විටය, උදාහරණයක් ලෙස යම් කට්ටලයක උප කුලක පරීක්ෂා කරන්න.

ලිහිල්ව කිවහොත්, කාල සංකීර්ණතාව යනු ආදාන ප්‍රමාණය වැඩි වන විට ඇල්ගොරිතමයක මෙහෙයුම් ගණන හෝ ධාවන කාලය වර්ධනය වන ආකාරය සාරාංශ කිරීමේ ක්‍රමයකි.

ජීවිතයේ බොහෝ දේ මෙන්, කොක්ටේල් සාදයක් අපට තේරුම් ගැනීමට උපකාරී වේ.

මත)

ඔබ සාදයට පැමිණෙන විට, ඔබ සෑම දෙනාගේම අත සොලවන්නට සිදුවේ (සෑම අයිතමයක් සඳහාම මෙහෙයුමක් කරන්න). සහභාගිවන්නන්ගේ සංඛ්‍යාව Nවැඩි වන විට, සෑම දෙනාගේම අත සොලවන්නට ගතවන කාලය / වැඩ වැඩි වේ O(N).

ඇයි O(N)සහ නැත්තේ cN?

මිනිසුන් සමඟ අත් හුවමාරු කර ගැනීමට ගතවන කාලයෙහි වෙනසක් ඇත. ඔබට මෙය සාමාන්‍යකරණය කර නියතයකින් අල්ලා ගත හැකිය c. නමුත් මෙහි මූලික මෙහෙයුම --- සෑම කෙනෙකු සමඟම අත් හුවමාරු කර ගැනීම --- O(N)කුමක් වුවත් සෑම විටම සමානුපාතික වේc . අපි කොක්ටේල් සාදයකට යා යුතුද යන්න ගැන වාද විවාද කිරීමේදී, අපි බොහෝ විට උනන්දු වන්නේ එම රැස්වීම්වල පෙනුම කෙබඳුද යන්න පිළිබඳ මිනිත්තුවේ විස්තර වලට වඩා අප සියලු දෙනා මුණගැසීමට සිදුවනු ඇත.

ඕ (එන් ^ 2)

කොක්ටේල් සාදයේ සත්කාරක සමාගමට අවශ්‍ය වන්නේ ඔබ සියලු දෙනා මුණගැසෙන මෝඩ ක්‍රීඩාවක් කිරීමටයි. එමනිසා, ඔබ N-1වෙනත් පුද්ගලයින් හමුවිය යුතු අතර, ඊළඟ පුද්ගලයා දැනටමත් ඔබව මුණගැසී ඇති හෙයින්, ඔවුන් N-2මිනිසුන් හමුවිය යුතුය , සහ එසේ ය. මෙම ලිපි මාලාවේ එකතුව වේ x^2/2+x/2. සහභාගිවන්නන්ගේ සංඛ්යාව වැඩි වන විට, මෙම x^2පදය විශාල වේගයක් ලබා ගනී , එබැවින් අපි අනෙක් සියල්ල අතහැර දමමු.

ඕ (එන් ^ 3)

ඔබ අනෙක් සියල්ලන් මුණගැසිය යුතු අතර, සෑම රැස්වීමකදීම, ඔබ කාමරයේ සිටින අනෙක් සියල්ලන් ගැන කතා කළ යුතුය.

ඕ (1)

ධාරකයාට යමක් ප්‍රකාශ කිරීමට අවශ්‍යයි. ඔවුන් වයින් වීදුරුවක් ගසා ශබ්ද නඟා කතා කරති. හැමෝම ඒවා අසයි. සහභාගිවන්නන් කොපමණ සංඛ්‍යාවක් සිටියත් කමක් නැත, මෙම මෙහෙයුම සෑම විටම එකම කාලයක් ගතවේ.

ඕ (ලොග් එන්)

ධාරකයා අකාරාදී පිළිවෙලට සියල්ලන්ම මේසයේ තබා ඇත. දාන් කොහෙද? ඔහු ආදම් සහ මැන්ඩි අතර කොතැනක හෝ සිටිය යුතු යැයි ඔබ තර්ක කරයි (නිසැකවම මැන්ඩි සහ සාක් අතර නොවේ!). ඒ අනුව, ඔහු ජෝර්ජ් සහ මැන්ඩි අතරද? ඔහු ආදම් සහ ෆ්‍රෙඩ් අතරද සින්ඩි සහ ෆ්‍රෙඩ් අතරද විය යුතුය. සහ එසේ ය ... අපට සෙට් එකෙන් අඩක් සහ එම කට්ටලයේ අඩක් බැලීමෙන් ඩෑන් කාර්යක්ෂමව සොයාගත හැකිය. අවසානයේදී, අපි O (log_2 N) පුද්ගලයන් දෙස බලමු .

ඕ (එන් ලොග් එන්)

ඉහත ඇල්ගොරිතම භාවිතා කර මේසයේ වාඩි වී සිටින්නේ කොතැනදැයි ඔබට සොයාගත හැකිය. විශාල පිරිසක් මේසය වෙත පැමිණියේ නම්, එක් වරකට, සහ සියල්ලන්ම මෙය කළේ නම්, ඒ සඳහා O (N log N) කාලය ගතවනු ඇත. ඕනෑම භාණ්ඩ එකතුවක් සැසඳිය යුතු විට ඒවා වර්ග කිරීමට කොපමණ කාලයක් ගතවේද යන්න මෙයින් පෙනේ.

හොඳම / නරකම නඩුව

ඔබ සාදයට පැමිණ ඉනිගෝව සොයා ගැනීමට අවශ්‍යයි - කොපමණ කාලයක් ගතවේද? එය ඔබ පැමිණෙන විට රඳා පවතී. සෑම කෙනෙකුම ඔබ වටා ඇඹරෙන්නේ නම්, ඔබ නරකම තත්වයට පත්ව ඇත: එයට O(N)කාලය ගතවනු ඇත. කෙසේ වෙතත්, සෑම කෙනෙකුම මේසයේ වාඩි වී සිටින්නේ නම්, එය ගත වන්නේ O(log N)කාලය පමණි . එසේත් නැතිනම් ඔබට ධාරකයාගේ වයින් ග්ලාස්- ing ෝෂා කිරීමේ බලය භාවිතා කළ හැකි අතර ඒ සඳහා ගත වන්නේ O(1)කාලය පමණි .

ධාරකය ලබා ගත නොහැකි යැයි උපකල්පනය කිරීමෙන්, ඔබ පැමිණෙන විට පක්ෂයේ තත්වය මත පදනම්ව, ඉනිගෝ-සොයා ගැනීමේ ඇල්ගොරිතමයට පහළ සීමාවක් O(log N)සහ ඉහළ සීමාවක් ඇති බව අපට පැවසිය හැකිය O(N).

අවකාශය සහ සන්නිවේදනය

ඇල්ගොරිතම අවකාශය හෝ සන්නිවේදනය භාවිතා කරන්නේ කෙසේද යන්න තේරුම් ගැනීමට එකම අදහස් යොදා ගත හැකිය.

නත් විසින් "ගීතවල සංකීර්ණත්වය" යන මාතෘකාව යටතේ කලින් ලිපියක් ලියා ඇත .

ප්‍රමේයය 2: සංකීර්ණ අත්තනෝමතික ලෙස දිගු ගීත O (1) පවතී.

සාධනය: (කේසි සහ සන්ෂයින් බෑන්ඩ් නිසා). (15) විසින් අර්ථ දක්වා ඇති Sk ගීත සලකා බලන්න, නමුත් සමඟ

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

සියල්ලටම k.

මෙම ප්‍රශ්නය පසුපසට යන බව මම දනිමි. මෙහි විශිෂ්ට පිළිතුරු කිහිපයක් ඇත, කෙසේ වෙතත් මට අවශ්‍ය වූයේ ගණිතමය මනසක් ඇති පුද්ගලයින් සඳහා මෙම ලිපියේ පැකිලෙන තවත් කොටසක් බෙදා ගැනීමට ය. එම මාස්ටර් ප්රමේයය සංකීර්ණත්වය අධ්යයනය කරන විට දැන ගැනීමට තවත් usefull දෙයක්. අනෙක් පිළිතුරු වල එය සඳහන් වී ඇති බවක් මා දුටුවේ නැත.

O (n) යනු ඇල්ගොරිතමයක කාල සංකීර්ණත්වය ලිවීම සඳහා භාවිතා කරන විශාල O අංකනයයි. ඔබ ඇල්ගොරිතමයක ක්‍රියාත්මක කිරීම් ගණන එකතු කළ විට ඔබට 2N + 2 වැනි ප්‍රකාශනයක් ලැබෙනු ඇත, මෙම ප්‍රකාශනයේ N යනු ප්‍රමුඛතම පදයයි (ප්‍රකාශනයේ වටිනාකම වැඩි වුවහොත් හෝ අඩු වුවහොත් ප්‍රකාශනයට විශාලතම බලපෑමක් ඇති කරන පදය). දැන් O (N) යනු කාල අනුකූලතාව වන අතර N ආධිපත්‍යය දරයි. උදාහරණයක්

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

මෙහි අභ්‍යන්තර ලූපය සඳහා වන මුළු මරණ සංඛ්‍යාව n + 1 වන අතර පිටත ලූපය සඳහා වන මුළු මරණ සංඛ්‍යාව n (n + 1) / 2 වේ, එබැවින් සම්පූර්ණ ඇල්ගොරිතම සඳහා වන මුළු මරණ සංඛ්‍යාව n + 1 + n (n + 1/2) ) = (n ^ 2 + 3n) / 2. මෙහි n ^ 2 යනු ප්‍රමුඛතම පදය වන බැවින් මෙම ඇල්ගොරිතමයේ කාල සංකීර්ණතාව O (n ^ 2) වේ.