Bevezetés az egyesítéshez a Java-ban

A Java szűrési program az egyik legszélesebb körben alkalmazott és hatékony algoritmus. Az egyesítés a „split and conquer” technikán alapul, amely magában foglalja egy adott probléma több részproblémára osztását és az egyes részproblémák egymástól független megoldását. Az alproblémák megoldása után egyesítjük eredményeiket, hogy a probléma végleges megoldást kapjon. Az egyesítési rendezési algoritmus rekurzióval valósítható meg, mivel az alproblémákkal való munka, nem pedig a fő probléma.

Hogyan működik a Merge Sort?

Vegyünk egy válogatott tömböt, amelyet az egyesítési rendezési algoritmus segítségével kell rendezni. Az alábbiakban bemutatjuk a tömb osztályozását: 18, 8, 4, 13, 10, 12, 7 és 11:

  • Az első lépés egy olyan pivot elem megkeresése, amely alapján a bemeneti tömböt alsó részekre osztjuk.
  • Tegyük figyelembe, hogy a 13 elem van választva pivotként, tehát az eredeti tömb két alsó részre oszlik. Az első alcsoport 18, 8, 4, 13, a második rész pedig a fennmaradó 10, 12, 7, 11 elemeket tartalmazza.
  • A 2. lépésben kapott alrétegeket tovább osztjuk fel az 1. lépésben leírtak szerint, és ez folytatódik.
  • Miután a fő tömb fel van osztva egyes elemekkel rendelkező alcsoportokra, kezdjük újra összevonni ezeket az alcsoportokat úgy, hogy az egyesített elemek rendezett sorrendben legyenek.
  • Így működik a tényleges osztás és meghódítás:

Program a rendezés egyesítéséhez Java-ban

Íme egy kódpélda, amely bemutatja az egyesítés rendezését a java-ban:

Kód:

package com.edubca.sorting;
public class MergeSort (
private int() array;
private int() tempMergedArr;
private int length;
public static void main(String a())(
int() inputArr = (18, 8, 4, 13, 10, 12, 7, 11);
MergeSort mergeSort = new MergeSort();
mergeSort.sort(inputArr);
for(int i:inputArr)(
System.out.print(i + " ");
)
)
public void sort(int inputArr()) (
this.array = inputArr;
this.length = inputArr.length;
this.tempMergedArr = new int(length);
performMergeSort(0, length - 1);
)
private void performMergeSort(int lowerIndex, int higherIndex) (
if (lowerIndex < higherIndex) (
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Sort the left side of the array call performMergeSort recursively
performMergeSort(lowerIndex, middle);
// Sort the right side of the array call performMergeSort recursively
performMergeSort(middle + 1, higherIndex);
// Merge subparts using a temporary array
mergeData(lowerIndex, middle, higherIndex);
)
)
private void mergeData (int lowerIndex, int middle, int higherIndex) (
for (int i = lowerIndex; i <= higherIndex; i++) (
tempMergedArr(i) = array(i);
)
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) (
if (tempMergedArr(i) <= tempMergedArr(j)) (
array(k) = tempMergedArr(i);
i++;
) else (
array(k) = tempMergedArr(j);
j++;
)
k++;
)
while (i <= middle) (
array(k) = tempMergedArr(i);
k++;
i++;
)
)
)

A fenti kód rendezett tömböt eredményez outputként.

Kimenet:

Mikor kell használni az egyesítés sort?

Az egyesítés rendezése a következő forgatókönyvekben használható:

  • Ha a rendezendő adatszerkezet nem támogatja a véletlenszerű hozzáférést, akkor az egyesítés rendezése hasznos és hatékony lehet.
  • Ha magas szintű párhuzamosság szükséges, akkor az egyesítési rendezés használható, mivel a különböző alproblémák egymástól függetlenül oldhatók meg, párhuzamosan futó több folyamat felhasználásával.
  • Az összevonás gyorsabb, ha összekapcsolt listákkal dolgozunk, mivel a mutatók a listák összevonásakor könnyen megváltoztathatók.
  • Az Egyesítés rendezése stabil rendezésnek tekinthető, ami azt jelenti, hogy a tömb ugyanaz az eleme megtartja eredeti helyzetét egymáshoz viszonyítva. Azokban az esetekben, amikor nagyfokú stabilitásra van szükség, az egyesülési rendezés folytatható.

Az egyesítési rendezés komplexitása

Az alábbiakban a pontok elemzése az egyesítés sorrendje:

  • Az egyesítés rendezése egy rekurzív algoritmus, amelynek időbeli összetettsége O (n * log n) mindhárom esetben (a legrosszabb, a legjobb és az átlagos), mivel az egyesítési sorrend osztja a tömböt két egyenlő felére, és lineáris időbe telik az összevonásuk.
  • Az összevonás térbeli komplexitása O (n), mivel a rekurzív megközelítésen működik. Az egyesítés tehát gyors, hely- és időhatékony algoritmusnak tekinthető.

Az Egyesítés rendezése összehasonlítása más algoritmusokkal

Az alábbiakban összehasonlítja az egyesítési rendezést más algoritmusokkal:

  • A Heap Sort ugyanolyan bonyolult idővel bír, mint az merge sort, de csak O (1) kiegészítő helyet igényel az merge sort O (n) helyett. Ezért a halomfajta térhatékonyabb, mint az egyesítéses.
  • A Gyors rendezés megvalósításai általában felülmúlják az egyesítési rendezést a RAM-alapú tömbök rendezéséhez.
  • Az egyesítés rendezése felülmúlja a gyors rendezés és a halom rendezés algoritmusait, amikor a hivatkozott listán dolgozik, mivel mutatók könnyen megváltoztathatók.

Összegzés-program az Összeválogatás Java programban

A cikkből az a következtetés vonható le, hogy az egyesítés sorrendje fontos fogalom, amelyet meg kell érteni az algoritmusok vonatkozásában.

Ajánlott cikkek

Ez egy útmutató a Java szűrési program egyesítéséhez. Itt tárgyaljuk, hogyan kell működnie, hogyan kell használni, a Merge Sort programja stb.

  1. Merge Sort of Java
  2. Egyesítési rendezési algoritmusok a Java-ban
  3. Halom C sorrendben
  4. Heap Sort in Java
  5. Java telepítési eszközök
  6. Halom Rendezés Pythonban
  7. Gyors rendezési algoritmusok a Java-ban
  8. A 6 legnépszerűbb rendezési algoritmus a JavaScript-ben
  9. A 6 legfontosabb rendezési algoritmus a Pythonban

Kategória: