Ugrás a tartalomhoz

fésűs rendezés

A Wikiszótárból, a nyitott szótárból

Magyar

Kiejtés

  • IPA: [ ˈfeːʃyːʃrɛndɛzeːʃ]

Főnév

fésűs rendezés

  1. (matematika, algoritmusok) A fésűs rendezés egy hatékonyabb alternatíva a buborékrendezéshez. Az algoritmus alapja, hogy nemcsak egymás melletti elemeket hasonlít össze és cserél, hanem egy réstávolságot (gap) használ, amely a nagyobb távolságra lévő elemeket is vizsgálja. A rés értéke minden iterációban csökken, végül elérve az 1-et, ekkor a rendezés buborékrendezésként folytatódik.


Elmélet

Működése:

  1. Kezdő résméret:
    • A résméretet a lista hosszának ((n)) megfelelően állítjuk be.
  2. Résméret csökkentése:
    • A résméretet egy meghatározott konstanssal (általában (1.3)) osztva csökkentjük.
  3. Elemek összehasonlítása:
    • A listában az aktuális résméretnek megfelelő távolságban lévő elemeket összehasonlítjuk, és szükség esetén cseréljük őket.
  4. Utolsó fázis:
    • Amikor a résméret (1)-re csökken, az algoritmus az utolsó iterációban buborékrendezésként viselkedik, hogy biztosítsa a rendezést.


Tulajdonságok

  • Időkomplexitás:
    • Átlagos eset: (O(n n)).
    • Legrosszabb eset: (O(n^2)) (ritka esetekben).
  • Térkomplexitás: (O(1)), mivel helyben rendez.
  • Hatékonyság:
    • Általában gyorsabb, mint a buborékrendezés, mivel csökkenti a nagy távolságban lévő elemek hibáinak számát a korai fázisokban.


Pszeudokód

CombSort(A):
    n = A hossza
    gap = n
    swapped = igaz

    amíg gap > 1 vagy swapped:
        gap = max(1, int(gap / 1.3))
        swapped = hamis

        ciklus i = 0-tól (n - gap - 1)-ig:
            ha A[i] > A[i + gap]:
                cseréljük meg A[i] és A[i + gap] értékét
                swapped = igaz

Python implementáció

def comb_sort(arr):
    n = len(arr)
    gap = n
    shrink = 1.3  # Résméret csökkentésének aránya
    swapped = True

    while gap > 1 or swapped:
        gap = max(1, int(gap // shrink))
        swapped = False

        for i in range(n - gap):
            if arr[i] > arr[i + gap]:
                arr[i], arr[i + gap] = arr[i + gap], arr[i]
                swapped = True

# Példa
data = [64, 34, 25, 12, 22, 11, 90]
comb_sort(data)
print("Rendezett tömb:", data)
# Kimenet: Rendezett tömb: [11, 12, 22, 25, 34, 64, 90]

C++ implementáció

#include <iostream>
#include <vector>
using namespace std;

void combSort(vector<int>& arr) {
    int n = arr.size();
    int gap = n;
    const double shrink = 1.3; // Résméret csökkentésének aránya
    bool swapped = true;

    while (gap > 1 || swapped) {
        gap = max(1, static_cast<int>(gap / shrink));
        swapped = false;

        for (int i = 0; i < n - gap; ++i) {
            if (arr[i] > arr[i + gap]) {
                swap(arr[i], arr[i + gap]);
                swapped = true;
            }
        }
    }
}

int main() {
    vector<int> data = {64, 34, 25, 12, 22, 11, 90};
    combSort(data);

    cout << "Rendezett tömb: ";
    for (int num : data) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

Optimalizációk

  1. Résméret csökkentési aránya:
    • A (1.3) konstans optimálisnak bizonyult a legtöbb esetben. Más értékek lassabbá tehetik az algoritmust.
  2. Korai kilépés:
    • Ha egy iteráció során nem történt csere, az algoritmus azonnal befejezheti a futást.


Összegzés

A fésűs rendezés hatékonyabb, mint a buborékrendezés, különösen nagyobb adathalmazok esetén. Az algoritmus résméret-csökkentési megközelítése lehetővé teszi, hogy gyorsabban közelítse a végleges rendezett állapotot. Bár nem éri el a gyorsrendezés ((O(n n))) sebességét, egyszerűsége és helyben történő működése miatt egy hasznos algoritmus.

Fordítások

Tartalom

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=fésűs_rendezés&oldid=3479453”