What is the translation of " MERGE SORT " in Hungarian?

• összefésülő rendezés
• az összefésülős rendezése
• az egyesítés rendezését
• a összefésülősi rendezés
• egyesítési rendezési

Examples of using Merge sort in English and their translations into Hungarian

Parallel merge sort.
Párhuzamosított összefésülő rendezés.

Merge sort with parallel recursion.
Összefésülő rendezés párhuzamosított rekurzióval.

Optimizing merge sort.
Az összefésülő rendezés optimalizálása.

Merge sort with parallel merging..
Összefésülő rendezés párhuzamos egyesítéssel.

These are the steps a human would take to emulate merge sort(top-down).
Ezeket a lépéseket az ember megtenné, hogy utánozza az egyesítés rendezését(föntről lefelé).

Tiled merge sort applied to an array of random integers.
Csempézett összefésülősi rendezés véletlenszerű egész tömbre alkalmazva.

External sorting explains how merge sort is implemented with disk drives.
A külső rendezés elmagyarázza, hogy az összefésülős rendezése hogyan valósul meg a lemezmeghajtókkal.

Merge sort parallelizes well due to the use of the divide-and-conquer method.
Az egyesítés rendezése jól párhuzamos a divide-and-conquer módszer alkalmazása miatt.

Unlike some(efficient) implementations of quicksort, merge sort is a stable sort..
A quicksort néhány(hatékony) megvalósításától eltérően az összefésülős rendezése stabil rendezés..

A recursive merge sort algorithm used to sort an array of 7 integer values.
Rekurzív egyesítési rendezési algoritmus, amelyet 7 egész értékű tömb rendezésére használnak.

In the best case, the input is already sorted(i.e., is one run), so the natural merge sort need only make one pass through the data.
A legjobb esetben a bemenet már rendezve van(azaz egy futás), így a természetes egyesítéses rendezésnek csak egy adatot kell végrehajtania.

In sorting n objects, merge sort has an average and worst-case performance of O(n log n).
N objektum rendezésében az összefésülős rendezése átlagos és a legrosszabb esetben O( n napló n).

An intuitive approach is the parallelization of those recursive calls.[12] Following pseudocode describes the merge sort with parallel recursion using the fork and join keywords.
Az intuitív megközelítés a rekurzív hívások párhuzamosítása.[1] Az alábbi álkód leírja az egyesítés rendezését párhuzamos rekurzióval a villa és a csatlakozás kulcsszavakkal.

In the worst case, merge sort does about 39% fewer comparisons than quicksort does in the average case.
A legrosszabb esetben az összefésülős rendezése körülbelül 39% -kal kevesebb összehasonlítást végez, mint egy átlagos esetben a quicksort.

In this case, the notion of"in-place" can be relaxed to mean"taking logarithmic stack space", because standard merge sort requires that amount of space for its own stack usage.
Ebben az esetben a"helyben történő" jelző enyhítendő úgy, hogy"logaritmikus veremterületet" jelentsen, mivel a szokásos összefésülő rendezés ekkora helyet igényel a saját vermében.

In the typical case, the natural merge sort may not need as many passes because there are fewer runs to merge..
Tipikus esetben előfordulhat, hogy a természetes egyesítési rendezéshez nincs szükség annyi menetre, mert az egyesítéshez kevesebb futás van.

Each of these subarrays is sorted with an in-place sorting algorithm such as insertion sort, to discourage memory swaps, and normal merge sort is then completed in the standard recursive fashion.
Ezeket az alsávokat egy hely szerinti rendezési algoritmussal, például beillesztési rendezéssel rendezik, hogy megakadályozzák a memóriacseréket, majd a normál összefésülősi rendezés befejeződik a szokásos rekurzív módon.

A more sophisticated merge sort that optimizes tape(and disk) drive usage is the polyphase merge sort.
A kifinomultabb összefésülősi rendezés, amely optimalizálja a szalagos(és lemezes) meghajtó használatát, a többfázisú összefésülősi rendezés.

Other in-place algorithms include SymMerge, which takes O((n+ m) log(n+ m)) time in total and is stable.[10] Plugging such an algorithm into merge sort increases its complexity to the non-linearithmic, but still quasilinear, O(n(log n)2).
További helyben összefésülő algoritmus a SymMerge, ami összesen O(( n+ m) log( n+ m)) ideig tart és stabil.[4] Egy ilyen algoritmust beépítése az összefésülő rendezésbe nem-linearitmikusra növeli annak bonyolultságát, ami azért kvázilineáris marad, O( n(log n) 2) nagyságrendben.

A natural merge sort is similar to a bottom-up merge sort except that any naturally occurring runs(sorted sequences) in the input are exploited.
A"természetes" összefésülő rendezés hasonlít a"lentről fölfelé" haladóhoz, de kihasználja a bemenet már rendezett részsorozatait("természetes" futamait).

Both monotonic and bitonic(alternating up/down) runs may be exploited, with lists(or equivalently tapes or files) being convenient data structures(used as FIFO queues or LIFO stacks).[4] In the bottom-up merge sort, the starting point assumes each run is one item long.
Az egymással szomszédos futamok rendezési iránya ellentétes("bitonikus" futampárt alkotnak). Mindkettőt kézenfekvő adatszerkezetben, listában lehet kihasználni, de ezzel egyenértékű soros elérésű háttértáron is(szalagon vagy állományban, FIFO-sorként vagy LIFO-veremként).[1] A lentről fölfelé haladva összefésülő rendezéskor feltételezzük, hogy kezdetben minden futam egy elem hosszú.

It seems arbitrary to restrict the merge sort algorithms to a binary merge method, since there are usually p> 2 processors available.
Önkényesnek tűnik az összefésülő rendezés algoritmusainak bináris egyesítési módszerre történő korlátozása, mivel általában p> 2 processzor áll rendelkezésre.

Merge sort is a divide and conquer algorithm that was invented by John von Neumann in 1945.[2] A detailed description and analysis of bottom-up mergesort appeared in a report by Goldstine and von Neumann as early as 1948.[3].
Az összefésülő rendezés oszd meg és uralkodj-elvű algoritmusát Neumann János gondolta ki 1945-ben.[1] A lentről fölfelé haladó összefésülést már 1948-ban részletesen leírta és elemezte Goldstine és Neumann[2].

Example C-like code using indices for top-down merge sort algorithm that recursively splits the list(called runs in this example) into sublists until sublist size is 1, then merges those sublists to produce a sorted list.
C-nyelvcsaládban kódolt példában indexeléssel szemléltetjük a föntről lefelé haladva összefésülő rendezés algoritmusát. A listát rekurzívan osztjuk fel részlistákra, mígnem a méretük 1 lesz. A rendezett részlistákat(a példában futamokat) összefésülve magát a listát is rendezetté tesszük.

Merge sort is more efficient than quicksort for some types of lists if the data to be sorted can only be efficiently accessed sequentially, and is thus popular in languages such as Lisp, where sequentially accessed data structures are very common.
A rendezés összefésülőse a listák egyes típusainál hatékonyabb, mint a quicksort, ha a szétválogatni kívánt adatok csak egymás után hatékonyan érhetők el, és így népszerűek olyan nyelvekben, mint a Lisp, ahol a szekvenciálisan hozzáférhető adatstruktúrák nagyon gyakoriak.

Example C-like code using indices for bottom-up merge sort algorithm which treats the list as an array of n sublists(called runs in this example) of size 1, and iteratively merges sub-lists back and forth between two buffers.
Példa C-nyelvcsaládba sorolható kódra, amely indexeket használ a lentről fölfelé haladó összefésülő rendezés algoritmusához. Ebben a listát n számú, 1-elemű részlista vektoraként kezeljük. Egy puffer rendezett részlistáit(a példában futamokat) egy másik pufferbe fésüljük össze, majd onnan a hosszabb futamokat vissza iteratív módon.

Some parallel merge sort algorithms are strongly related to the sequential top-down merge algorithm while others have a different general structure and use the K-way merge method.
Egyes párhuzamos egyesítési rendezési algoritmusok szorosan kapcsolódnak a szekvenciális föntről lefelé egyesítési algoritmusokhoz, míg mások más általános szerkezettel rendelkeznek, és a K-irányú egyesítési módszert használják.

Cache-aware versions of the merge sort algorithm, whose operations have been specifically chosen to minimize the movement of pages in and out of a machine's memory cache, have been proposed.
Gyorsítótár- az összefésülősi rendezés algoritmusának olyan verzióit javasolták, amelyek műveleteit kifejezetten azért választották, hogy minimalizálják az oldalak mozgását a gép memóriájában.

Pseudocode for top-down merge sort algorithm which recursively divides the input list into smaller sublists until the sublists are trivially sorted, and then merges the sublists while returning up the call chain.
Pszeudokód a föntről lefelé haladó összefésülő rendezés algoritmusához. A bemeneti listát rekurzívan osztjuk fel egyre rövidebb részekre, mígnem a részlisták triviálisan rendezetté válnak. Ezután a hívásláncon visszafelé haladva egyre hosszabb részlistákat fésülünk össze.

Pseudocode for bottom-up merge sort algorithm which uses a small fixed size array of references to nodes, where array[i] is either a reference to a list of size 2i or nil. node is a reference or pointer to a node.
Pszeudokód a lentről fölfelé haladó összefésülő rendezés algoritmusához. Ebben a lista néhány csomópontjára mutató hivatkozásokat használunk egy rövid, rögzített méretű vektorban, melynek i-ik eleme vagy hivatkozás egy 2i méretű listára, vagy Null mutató. A node hivatkozás, vagyis mutató egy csomópontra.