"ക്യൂ (ഡാറ്റാ സ്ട്രക്‌ച്ചർ)" എന്ന താളിന്റെ പതിപ്പുകൾ തമ്മിലുള്ള വ്യത്യാസം

Content deleted Content added

വരിക്കിടയിൽ

07:20, 11 ഏപ്രിൽ 2010-നു നിലവിലുണ്ടായിരുന്ന രൂപം

ഇംഗ്ലീഷ് വിലാസം

https://ml.wikipedia.org/wiki/Queue_(data_structure)

പുതിയ അംഗങ്ങളെ പിന്നിൽ ചേർക്കുക, നിലവിലുള്ള അംഗങ്ങളെ മുൻഭാഗത്തുനിന്ന് നീക്കുക എന്നീ രണ്ട് പ്രക്രിയകൾ മാത്രം അനുവദിക്കുന്ന ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌ ക്യൂ. സാധാരണ ടിക്കറ്റിനും മറ്റും ജനങ്ങൾ ക്യൂ നിൽക്കുന്നതിന്‌ സമാനമാണ്‌ ഇതിന്റെ പ്രവർത്തനം. ക്യൂവിൽ ആദ്യം ചേർക്കപ്പെടുന്ന അംഗങ്ങളാണ്‌ ആദ്യം നീക്കം ചെയ്യപ്പെടുക എന്നതിനാൽ ഇതിനെ ഫസ്റ്റ്-ഇൻ-ഫസ്റ്റ്-ഔട്ട് (FIFO) ഡാറ്റാ സ്ട്രക്‌ചർ എന്നു വിളിക്കുന്നു. ഒരു രേഖീയ ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌ ഇത്.

ഉപയോഗം

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

ക്യൂ ഉപയോഗിച്ച് പ്രോസസ്സിങ്ങ് നടത്തേണ്ടത് ആവശ്യമുള്ള അൽഗൊരിതങ്ങൾ ഉണ്ട്. ഗ്രാഫുകളിൽ ഉപയോഗിക്കുന്ന ബ്രെഡ്ത് ഫസ്റ്റ് സർച്ച് ആണ്‌ ഒരുദാഹരണം. ഇതിൽ ആദ്യം കാണുന്ന ശീർഷങ്ങളെയാണ്‌ ആദ്യം പ്രോസസ് ചെയ്യേണ്ടത് എന്നതിനാൽ ശീർഷങ്ങളെ ഒരു ക്യൂവിൽ സൂക്ഷിക്കുന്നു.

സി++ സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറി

സി++ സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയുടെ ഭാഗമായി ക്യൂ എന്ന ടെം‌പ്ലേറ്റ് ഉണ്ട്^[1]. ഇത് ഒരു കണ്ടെയ്നർ അഡാപ്റ്റർ ആണ്‌. queue എന്ന ഹെഡർ ഫയലിലാണ്‌ ഇത് നിർവ്വചിക്കപ്പെട്ടിരിക്കുന്നത്. ഇതിലെ പ്രധാന ഫങ്ഷനുകൾ ഇവയാണ്‌:

void push(T&) : പുതിയ ഒരംഗത്തെ ക്യൂവിന്റെ പിന്നിലേക്ക് ചേർക്കുക
void pop() : ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ നീക്കുക
T& front() : ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ റിട്ടേൺ ചെയ്യുക
bool empty() : ക്യൂ ശൂന്യമാണോ അല്ലയോ എന്ന് പറയുക

ഉദാഹരണം

സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയിലെ ക്യൂ ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാം ഭാഗം:

queue<int> theQueue;                            // സംഖ്യകൾക്കായുള്ള ക്യൂ നിർമ്മിക്കുക
theQueue.push(1);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1
theQueue.push(2);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1 2
theQueue.push(3);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1 2 3
while( !theQueue.empty() )                    // ക്യൂവിൽ അംഗങ്ങൾ ഉള്ളിടത്തോളം
{
    cout <<  theQueue.front() << endl;   // ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ ഔട്പുട്ട് ചെയ്യുക
    theQueue.pop();                                  // ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ നീക്കുക
}

ഇതിന്റെ ഔട്പുട്ട് ഇപ്രകാരമായിരിക്കും:

1
2
3

അവലംബം

↑ http://www.sgi.com/tech/stl/queue.html

[1] ttp://www.sgi.com/tech/stl/queue.html

[1]

@@ വരി 1: / വരി 1: @@
 {{prettyurl|Queue (data structure)}}
-പുതിയ അംഗങ്ങളെ പിന്നില്‍ ചേര്‍ക്കുക, നിലവിലുള്ള അംഗങ്ങളെ മുന്‍ഭാഗത്തുനിന്ന് നീക്കുക എന്നീ രണ്ട് പ്രക്രിയകള്‍ മാത്രം അനുവദിക്കുന്ന [[ഡാറ്റാ സ്ട്രക്‌ച്ചര്‍|ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌]] '''ക്യൂ'''. സാധാരണ ടിക്കറ്റിനും മറ്റും ജനങ്ങള്‍ ക്യൂ നില്‍ക്കുന്നതിന്‌ സമാനമാണ്‌ ഇതിന്റെ പ്രവര്‍ത്തനം. ക്യൂവില്‍ ആദ്യം ചേര്‍ക്കപ്പെടുന്ന അംഗങ്ങളാണ്‌ ആദ്യം നീക്കം ചെയ്യപ്പെടുക എന്നതിനാല്‍ ഇതിനെ ഫസ്റ്റ്-ഇന്‍-ഫസ്റ്റ്-ഔട്ട് (FIFO) ഡാറ്റാ സ്ട്രക്‌ചര്‍ എന്നു വിളിക്കുന്നു. ഒരു രേഖീയ ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌ ഇത്.
+പുതിയ അംഗങ്ങളെ പിന്നിൽ ചേർക്കുക, നിലവിലുള്ള അംഗങ്ങളെ മുൻഭാഗത്തുനിന്ന് നീക്കുക എന്നീ രണ്ട് പ്രക്രിയകൾ മാത്രം അനുവദിക്കുന്ന [[ഡാറ്റാ സ്ട്രക്‌ച്ചർ|ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌]] '''ക്യൂ'''. സാധാരണ ടിക്കറ്റിനും മറ്റും ജനങ്ങൾ ക്യൂ നിൽക്കുന്നതിന്‌ സമാനമാണ്‌ ഇതിന്റെ പ്രവർത്തനം. ക്യൂവിൽ ആദ്യം ചേർക്കപ്പെടുന്ന അംഗങ്ങളാണ്‌ ആദ്യം നീക്കം ചെയ്യപ്പെടുക എന്നതിനാൽ ഇതിനെ ഫസ്റ്റ്-ഇൻ-ഫസ്റ്റ്-ഔട്ട് (FIFO) ഡാറ്റാ സ്ട്രക്‌ചർ എന്നു വിളിക്കുന്നു. ഒരു രേഖീയ ഡാറ്റാ സ്ട്രക്‌ച്ചറാണ്‌ ഇത്.
 == ഉപയോഗം ==
-കൈവരുന്ന ക്രമത്തില്‍ അംഗങ്ങളുടെമേല്‍ പ്രോസസ്സിങ്ങ് നടത്തേണ്ട ഘട്ടങ്ങളിലെല്ലാം ക്യൂ ആണ്‌ ഉപയോഗിക്കുക. ഉദാഹരണമായി, രണ്ട് കം‌പ്യൂട്ടറുകള്‍ തമ്മിലുള്ള ആശയവിനിമയത്തിന്റെ കാര്യമെടുക്കുക. ഒരു കം‌പ്യൂട്ടറില്‍ നിന്ന് മറ്റൊന്നിലേക്ക് അയക്കേണ്ട ബൈറ്റുകളെല്ലാം ഒരു [[ബഫര്‍|ബഫറിന്റെ]] രൂപത്തില്‍ സൂക്ഷിച്ച് ഒന്നിനു പിറകെ ഒന്നായി അയക്കുകയാണ്‌ ചെയ്യുന്നത്. ഇവിടെ ആദ്യം ലഭിക്കുന്ന ബൈറ്റുകളാണ്‌ ആദ്യം അയക്കേണ്ടത് എന്നതിനാല്‍ ബഫര്‍ ഒരു ക്യൂവിന്റെ രൂപത്തിലായിരിക്കണം.
+കൈവരുന്ന ക്രമത്തിൽ അംഗങ്ങളുടെമേൽ പ്രോസസ്സിങ്ങ് നടത്തേണ്ട ഘട്ടങ്ങളിലെല്ലാം ക്യൂ ആണ്‌ ഉപയോഗിക്കുക. ഉദാഹരണമായി, രണ്ട് കം‌പ്യൂട്ടറുകൾ തമ്മിലുള്ള ആശയവിനിമയത്തിന്റെ കാര്യമെടുക്കുക. ഒരു കം‌പ്യൂട്ടറിൽ നിന്ന് മറ്റൊന്നിലേക്ക് അയക്കേണ്ട ബൈറ്റുകളെല്ലാം ഒരു [[ബഫർ|ബഫറിന്റെ]] രൂപത്തിൽ സൂക്ഷിച്ച് ഒന്നിനു പിറകെ ഒന്നായി അയക്കുകയാണ്‌ ചെയ്യുന്നത്. ഇവിടെ ആദ്യം ലഭിക്കുന്ന ബൈറ്റുകളാണ്‌ ആദ്യം അയക്കേണ്ടത് എന്നതിനാൽ ബഫർ ഒരു ക്യൂവിന്റെ രൂപത്തിലായിരിക്കണം.
-ക്യൂ ഉപയോഗിച്ച് പ്രോസസ്സിങ്ങ് നടത്തേണ്ടത് ആവശ്യമുള്ള [[അല്‍ഗൊരിതം|അല്‍ഗൊരിതങ്ങള്‍]] ഉണ്ട്. [[ഗ്രാഫ്|ഗ്രാഫുകളില്‍]] ഉപയോഗിക്കുന്ന [[ബ്രെഡ്ത് ഫസ്റ്റ് സര്‍ച്ച്]] ആണ്‌ ഒരുദാഹരണം. ഇതില്‍ ആദ്യം കാണുന്ന [[ശീര്‍ഷം|ശീര്‍ഷങ്ങളെയാണ്‌]] ആദ്യം പ്രോസസ് ചെയ്യേണ്ടത് എന്നതിനാല്‍ ശീര്‍ഷങ്ങളെ ഒരു ക്യൂവില്‍ സൂക്ഷിക്കുന്നു.
+ക്യൂ ഉപയോഗിച്ച് പ്രോസസ്സിങ്ങ് നടത്തേണ്ടത് ആവശ്യമുള്ള [[അൽഗൊരിതം|അൽഗൊരിതങ്ങൾ]] ഉണ്ട്. [[ഗ്രാഫ്|ഗ്രാഫുകളിൽ]] ഉപയോഗിക്കുന്ന [[ബ്രെഡ്ത് ഫസ്റ്റ് സർച്ച്]] ആണ്‌ ഒരുദാഹരണം. ഇതിൽ ആദ്യം കാണുന്ന [[ശീർഷം|ശീർഷങ്ങളെയാണ്‌]] ആദ്യം പ്രോസസ് ചെയ്യേണ്ടത് എന്നതിനാൽ ശീർഷങ്ങളെ ഒരു ക്യൂവിൽ സൂക്ഷിക്കുന്നു.
-== സി++ സ്റ്റാന്‍ഡേര്‍ഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറി ==
+== സി++ സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറി ==
-[[സി++]] [[സ്റ്റാന്‍ഡേര്‍ഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറി|സ്റ്റാന്‍ഡേര്‍ഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയുടെ]] ഭാഗമായി ക്യൂ എന്ന [[ടെം‌പ്ലേറ്റ്]] ഉണ്ട്<ref>http://www.sgi.com/tech/stl/queue.html</ref>. ഇത് ഒരു [[കണ്ടെയ്നര്‍ (ഡാറ്റാ സ്ട്രക്‌ച്ചര്‍)|കണ്ടെയ്നര്‍]] അഡാപ്റ്റര്‍ ആണ്‌. queue എന്ന ഹെഡര്‍ ഫയലിലാണ്‌ ഇത് നിര്‍വ്വചിക്കപ്പെട്ടിരിക്കുന്നത്. ഇതിലെ പ്രധാന ഫങ്ഷനുകള്‍ ഇവയാണ്‌:
+[[സി++]] [[സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറി|സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയുടെ]] ഭാഗമായി ക്യൂ എന്ന [[ടെം‌പ്ലേറ്റ്]] ഉണ്ട്<ref>http://www.sgi.com/tech/stl/queue.html</ref>. ഇത് ഒരു [[കണ്ടെയ്നർ (ഡാറ്റാ സ്ട്രക്‌ച്ചർ)|കണ്ടെയ്നർ]] അഡാപ്റ്റർ ആണ്‌. queue എന്ന ഹെഡർ ഫയലിലാണ്‌ ഇത് നിർവ്വചിക്കപ്പെട്ടിരിക്കുന്നത്. ഇതിലെ പ്രധാന ഫങ്ഷനുകൾ ഇവയാണ്‌:
-* '''void push(T&)''' : പുതിയ ഒരംഗത്തെ ക്യൂവിന്റെ പിന്നിലേക്ക് ചേര്‍ക്കുക
+* '''void push(T&)''' : പുതിയ ഒരംഗത്തെ ക്യൂവിന്റെ പിന്നിലേക്ക് ചേർക്കുക
-* '''void pop()''' : ക്യൂവിന്റെ മുന്‍ഭാഗത്തെ അംഗത്തെ നീക്കുക
+* '''void pop()''' : ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ നീക്കുക
-* '''T& front()''' : ക്യൂവിന്റെ മുന്‍ഭാഗത്തെ അംഗത്തെ റിട്ടേണ്‍ ചെയ്യുക
+* '''T& front()''' : ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ റിട്ടേൺ ചെയ്യുക
 * '''bool empty()''' : ക്യൂ ശൂന്യമാണോ അല്ലയോ എന്ന് പറയുക
 === ഉദാഹരണം ===
-സ്റ്റാന്‍ഡേര്‍ഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയിലെ ക്യൂ ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാം ഭാഗം:
+സ്റ്റാൻഡേർഡ് ടെം‌പ്ലേറ്റ് ലൈബ്രറിയിലെ ക്യൂ ഉപയോഗിക്കുന്ന ഒരു പ്രോഗ്രാം ഭാഗം:
 <source lang="cpp">
-queue<int> theQueue;                            // സംഖ്യകള്‍ക്കായുള്ള ക്യൂ നിര്‍മ്മിക്കുക
+queue<int> theQueue;                            // സംഖ്യകൾക്കായുള്ള ക്യൂ നിർമ്മിക്കുക
 theQueue.push(1);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1
 theQueue.push(2);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1 2
 theQueue.push(3);                                  // ക്യൂവിന്റെ ഇപ്പോഴത്തെ രൂപം : 1 2 3
-while( !theQueue.empty() )                    // ക്യൂവില്‍ അംഗങ്ങള്‍ ഉള്ളിടത്തോളം
+while( !theQueue.empty() )                    // ക്യൂവിൽ അംഗങ്ങൾ ഉള്ളിടത്തോളം
 {
-    cout <<  theQueue.front() << endl;   // ക്യൂവിന്റെ മുന്‍ഭാഗത്തെ അംഗത്തെ ഔട്പുട്ട് ചെയ്യുക
+    cout <<  theQueue.front() << endl;   // ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ ഔട്പുട്ട് ചെയ്യുക
-    theQueue.pop();                                  // ക്യൂവിന്റെ മുന്‍ഭാഗത്തെ അംഗത്തെ നീക്കുക
+    theQueue.pop();                                  // ക്യൂവിന്റെ മുൻഭാഗത്തെ അംഗത്തെ നീക്കുക
 }
 </source>
@@ വരി 41: / വരി 41: @@
 <references/>
 {{Data structures}}
-[[വര്‍ഗ്ഗം:ഡാറ്റാ സ്ട്രക്‌ച്ചറുകള്‍]]
+[[വർഗ്ഗം:ഡാറ്റാ സ്ട്രക്‌ച്ചറുകൾ]]
 [[ar:طابور]]

ക സ തി ഡാറ്റാ സ്ട്രക്‌ച്ചറുകൾ
Types	കളക്ഷൻ · കണ്ടെയ്നർ
അറേകൾ	അസോസിയേറ്റീവ് അറേ · സെറ്റ് · മൾട്ടിസെറ്റ് · ഹാഷ് ടേബിൾ
ലിസ്റ്റുകൾ	ഡെക്ക് · ലിങ്ക്ഡ് ലിസ്റ്റ് · ക്യൂ · സ്റ്റാക്ക്
ട്രീകൾ	ബി-ട്രീ · ബൈനറി സർച്ച് ട്രീ · ഹീപ്
ഡാറ്റാ സ്ട്രക്‌ച്ചറുകളുടെ പട്ടിക