mirror of
https://github.com/TMD44/elte-ik-pti-bsc-zarovizsga.git
synced 2025-08-12 13:59:07 +02:00
268 lines
16 KiB
TeX
268 lines
16 KiB
TeX
\documentclass[margin=0px]{article}
|
|
|
|
\usepackage{listings}
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage{graphicx}
|
|
\usepackage{float}
|
|
\usepackage[a4paper, margin=1in]{geometry}
|
|
\usepackage{amsthm}
|
|
\usepackage{amssymb}
|
|
\usepackage{t1enc}
|
|
|
|
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
|
% A dokument itt kezdődik
|
|
|
|
\title{Záróvizsga tételsor \\ \large 13. Alapvető algoritmusok és adatszerkezetek}
|
|
\date{}
|
|
\author{Fekete Dóra}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
|
|
\begin{tetel}{Alapvető algoritmusok és adatszerkezetek}
|
|
Egyszerű adattípusok ábrázolásai, műveletei és fontosabb alkalmazásai. A hatékony adattárolás és visszakeresés néhány megvalósítása (bináris keresőfa, AVL-fa, 2-3-fa és B-fa, hasítás (,,hash-elés”)). Összehasonlító rendező algoritmusok (buborék és beszúró rendezés, ill. verseny, kupac, gyors és összefésülő rendezés); a műveletigény alsó korlátja.
|
|
\end{tetel}
|
|
|
|
\section{Egyszerű adattípusok ábrázolásai, műveletei és fontosabb alkalmazásai}
|
|
|
|
\subsection{Adattípus}
|
|
|
|
\textit{Adatszerkezet}: $\sim$ struktúra. \\
|
|
\textit{Adattípus}: adatszerkezet és a hozzá tartozó műveletek. \\
|
|
\textit{Adatszerkezetek}:
|
|
\begin{itemize}
|
|
\item \textit{Tömb}: azonos típusú elemek sorozata, fix méretű.
|
|
\item \textit{Verem}: Mindig a verem tetejére rakjuk a következő elemet, csak a legfelsőt kérdezhetjük le, és vehetjük ki.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Verembe.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Verembol.jpg}
|
|
\caption{Verem műveletei}
|
|
\end{figure}
|
|
\item \textit{Sor}: Egyszerű, elsőbbségi és kétvégű. A prioritásos sornál az elemekhez tartozik egy érték, ami alapján rendezhetjük őket.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Sorba.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Sorbol.jpg}
|
|
\caption{Sor műveletei}
|
|
\end{figure}
|
|
\item \textit{Lista}: Láncolt ábrázolással reprezentáljuk. 3 szempont szerint különböztethetjük meg a listákat: fejelem van/nincs, láncolás iránya egy/kettő, ciklusosság van/nincs. Ha fejelemes a listánk, akkor a fejelem akkor is létezik, ha üres a lista. \\
|
|
A lista node-okból áll, minden node-nak van egy, a következőre mutató pointere, illetve lehet az előzőre is, ha kétirányú. Ezen kívül van egy első és egy aktuális node-ra mutató pointer is, és az utolsó elem mutatója NIL. A listát megvalósíthatjuk úgy, hogy tetszőleges helyre lehessen elemet beszúrni, illetve törölni.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Listaba.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Torol.jpg}
|
|
\caption{Lista műveletei}
|
|
\end{figure}
|
|
\item \textit{Fa}: Egyszerű, bináris és speciális (kupac, bináris keresőfa, AVL-fa). A bináris fát rekurzívan definiáljuk: $t \in T(E)$ [bin. fák típusérték halmaza(alaptípus)] $\iff$ $t$ üres fa (jele: $\Omega$), vagy $t$-nek van gyökéreleme, $bal(t)$, $jobb(t)$ részfája. Láncoltan ábrázoljuk, tömbösen csak teljes fák, illetve kupac esetén.
|
|
\item \textit{Kupac}: Olyan bináris fa, melynek alakja majdnem teljes és balra rendezett. Tömbösen ábrázoljuk, mert pointeresen a bonyolult lépkedést nem teszi lehetővé, tömbösen indexösszefüggésekkel könnyen megoldható.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/KupacbaBeszur.jpg}
|
|
\caption{Kupac műveletei}
|
|
\end{figure}
|
|
\item \textit{Hasítótábla}
|
|
\item \textit{Gráf} [Nem egyszerű adattípus.]
|
|
\end{itemize}
|
|
|
|
\subsection{Ábrázolásai}
|
|
|
|
Absztrakciós szintek:
|
|
\begin{enumerate}
|
|
\item \textit{absztrakt adattípus (ADT)}: specifikáció szintje, itt nincs szerkezeti összefüggés, csak matematikai fogalmak, műveletek logikai axiómákkal vagy előfeltételekkel.
|
|
\begin{itemize}
|
|
\item algebrai (axiomatikus) specifikáció, példa: $Verembe : V \times E \to V$. Axióma, példa: $Felso(Verembe(v,e)) = e$
|
|
\item funkcionális (elő- és utófeltételes) specifikáció, példa: (elsőbbségi) sor $S(E), s \in S$ egy konkrét sor, $s = \{(e_1, t_1), ..., (e_n, t_n)\}$, $n \geq 0$. Ha $n=0$, akkor a sor üres. \\
|
|
$\forall i,j \in [1..n]: i \neq j \to t_i \neq t_j$. \\
|
|
$Sorbol: S \to S \times E$, $\mathcal{D}_{Sorbol} = S \backslash \{ures\}$. Előfeltétel: $Q = (s = s' \wedge s' \neq \emptyset)$, utófeltétel: $R = (s = s' \backslash \{(e,t)\} \wedge (e,t) \in s' \wedge \forall i (e_i, t_i) \in s' : t \leq t_i)$.
|
|
\end{itemize}
|
|
\item \textit{absztrakt adatszerkezet (ADS)}: kognitív pszichológia szintje, ábrák. Az alapvető szerkezeti tulajdonságokat tartalmazza (nem mindet). Ennek a szintnek is része a műveletek halmaza. Példák: az ábra egy irányított gráf, művelet magyarázata, adatszerkezet definiálása.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=1\textwidth]{img/ads.png}
|
|
\caption{ADS}
|
|
\end{figure}
|
|
\item \textit{ábrázolás/reprezentáció}: döntések (tömbös vagy pointeres ábrázolás), a nyitva hagyott szerkezeti kérdések. Egy adatszerkezetet többféle reprezentációval is meg lehet valósítani (pl. prioritásos sor lehet rendezetlen tömb, rendezett tömb, kupac).
|
|
\begin{itemize}
|
|
\item \textit{tömbös ábrázolás}: takarékos ábrázolás, elhelyezése, tetszőleges rákövetkezések, bejárások, de ezeket meg kell adni.
|
|
\item \textit{pointeres ábrázolás}: minden pointer egy összetett rekord elejére mutat.
|
|
\end{itemize}
|
|
\item \textit{implementálás}
|
|
\item \textit{fizikai szint}
|
|
\end{enumerate}
|
|
|
|
\subsection{Műveletei}
|
|
|
|
\begin{itemize}
|
|
\item Üres adatszerkezet létrehozása
|
|
\item Annak lekérdezése, hogy üres-e az adatszerkezet
|
|
\item Elem berakása, itt ellenőrizni kell, hogy nem telt-e még meg
|
|
\item Elem kivétele vagy törlése, itt ellenőrizni kell, hogy nem üres-e
|
|
\item Adott tulajdonságú elem (például maximum, veremben a felső) lekérdezése, itt is ellenőrizni kell, hogy üres-e az adatszerkezet
|
|
\item Bejárások (preorder, inorder, postorder, szintfolytonos), listáknál az első, előző vagy következő elemre lépés
|
|
\item Elem módosítása bizonyos adatszerkezeteknél (pl. listák)
|
|
\end{itemize}
|
|
|
|
\subsection{Fontosabb alkalmazásai}
|
|
|
|
\textit{Prioritásos sor}: nagygépes programfuttatásnál az erőforrásokat a prioritás arányában osszuk el, adott pillanatban a maximális prioritásút válasszuk. Sürgősségi ügyeleten, gráfalgoritmusoknál is alkalmazható.
|
|
\textit{B-fa}: ipari méretekben adatbázisokban használják.
|
|
|
|
\section{A hatékony adattárolás és visszakeresés néhány megvalósítása (bináris keresőfa, AVL-fa, 2-3-fa és B-fa, hasítás (,,hash-elés”))}
|
|
|
|
\subsection{Bináris keresőfa}
|
|
|
|
Nincsenek benne azonos kulcsok, a követendő elv: ,,kisebb balra, nagyobb jobbra". Inorder bejárással növekvő kulcssorozatot kapunk. \\
|
|
Műveletigénye fa magasságú nagyságrendű. \\
|
|
Az a cél, hogy a bináris keresőfa ne nyúljon meg láncszerűen, erre jó az AVL-fa és a 2-3-fa.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Beszur.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Kovetkezo.jpg}
|
|
\caption{Bináris keresőfa műveletei}
|
|
\end{figure}
|
|
|
|
\subsection{AVL-fa}
|
|
|
|
Cél: a $t$ bináris keresőfa magasságának $\log_2(n)$ közelében tartása, azaz $h(t) \leq c \cdot \log_2(n)$, ahol $c$ elfogadhatóan kicsi. Az ilyen fát kiegyensúlyozottnak nevezzük. \\
|
|
\textit{AVL}: Adelszon-Velszkij, Landisz 1962-ben alkották meg. \\
|
|
A $t$ bináris keresőfát egyúttal AVL-fának nevezzük $\iff$ $t$ minden $x$ csúcsára $|h(bal(x))-h(jobb(x))| \leq 1$. \\
|
|
Minden csúcsnak van egy címkéje $+,-,=$ (gyerekek magasságának különbsége). A beszúrás helyétől felfelé ellenőrizzük ezeket, és ha kell, akkor módosítjuk. Ha valahol $++$ vagy $--$ alakul ki, akkor ott elromlik az AVL-tulajdonság, egy vagy több forgatással vagy átkötéssel konstans műveletigénnyel helyre lehet hozni. \\
|
|
Többféle séma is van: $(++,+), (++,-), (++,=)$ és a tükörképeik.
|
|
|
|
\subsection{2-3-fa és B-fa}
|
|
|
|
2-3-fa kis méretben az elmélet számára jó, a B-fa a gyakorlati változat adatbázisban. \\
|
|
$t$ 2-3-fa $\iff$ minden belső csúcsnak 2 vagy 3 gyereke van, a levelek azonos szinten helyezkednek el, adatrekordok csak a levelekben vannak, belső pontokban kulcsok és mutatók, levelekben a kulcsok balról jobbra nőnek. \\
|
|
Ha 4 gyerek lenne a beszúrás után, akkor csúcsot kell vágni. Ha törlésnél 1 gyerek lenne valahol, akkor csúcsösszevonásokat és gyerekátadást alkalmazunk. \\
|
|
B-fa nagyobb méretű, itt két határ között mozog a gyerekszám: $\lceil\frac{r}{2}\rceil$ és $r$, ahol $50 \leq r \leq 1000$.
|
|
|
|
\subsection{Hasítás}
|
|
|
|
Kulcsos rekordokat tárol.
|
|
\begin{itemize}
|
|
\item \textit{Hasítás láncolással}: a kulcsütközést láncolással oldja fel. Van egy hasítófüggvény: $h: U \to [0..m-1]$, elvárás vele kapcsolatban, hogy gyorsan számolható és egyenletes legyen. $m$-et úgy választjuk meg $n$ nagyságrendjének ismeretében, hogy $\alpha = \frac{n}{m}$ lesz a várható listahossz, ha egyenletes hasítást feltételezünk.\\
|
|
Például kétirányú listát használhatunk a hasításhoz. Műveletek: beszúrás, keresés, törlés. \\
|
|
Gyakorlatban érdemes $m$-et úgy megválasztani, hogy olyan prímszám legyen, ami nem esik 2-hatvány közelébe.
|
|
\item \textit{Hasítás nyitott/nyílt címzéssel}: A kulcsokat lehessen egészként értelmezni, ekkor vannak jó hasítófüggvények. \\
|
|
Próbálkozás általános képlete: $h(k) + h_i(k)$ $(mod$ $M)$, $0 \leq i \leq M-1$. Egész addig alkalmazza, amíg üres helyet nem talál.
|
|
\begin{enumerate}
|
|
\item \textit{Lineáris próba}: $h_i(k) = -i$ $(mod$ $M)$, egyesével balra lépegetve keressük az üres helyet. Hátránya az elsődleges csomósodás, ez jelentős lassulást okoz beszúrásnál és keresésnél.
|
|
\item \textit{Négyzetes próba}: $h_i(k) = (-1)^i(\lceil\frac{i}{2}\rceil)^2$ $(mod$ $M)$, a négyzetszámokkal lépegetünk balra-jobbra, ezek az eltolások kiadják $\{0,1,...,M-1\}$-et. Hátrány: másodlagos csomósodás.
|
|
\item \textit{Kettős hash-elés}: $h_i(k) =-ih'(k)$ $(mod$ $M)$, $h'(k)$ a $k$-hoz tartozó egyedi lépésköz, $(h'(k),M)=1$ relatív prímek. Ha az $M$ elég nagy, akkor nincs csomósodás.
|
|
\end{enumerate}
|
|
\item \textit{Hasítófüggvények}: Leggyakoribb: $k$ egész, kongruencia reláció. Általánosan: $h(k) = (ak +b$ $(mod$ $p))$ $(mod$ $M)$, az univerzális hasítás családja. Tapasztalat: $k$ egyenletesen hasít.
|
|
\end{itemize}
|
|
|
|
\section{Összehasonlító rendező algoritmusok (buborék és beszúró rendezés, ill. verseny, kupac, gyors és összefésülő rendezés)}
|
|
|
|
Buborék- és beszúró rendezés klasszikusak, $n^2$-es műveletigényűek, a többi hatékony, $n\log(n)$-es idejűek.
|
|
|
|
\subsection{Buborékrendezés}
|
|
|
|
A legnagyobb értéket cserékkel a végéig felbuborékozza, ezt minden ciklus végén elhagyjuk. A gyakorlatban nem használják.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Buborekrendezes.png}
|
|
\caption{Buborékrendezés}
|
|
\end{figure}
|
|
|
|
\subsection{Beszúró rendezés}
|
|
|
|
Kis $n$-re (kb 30) ez a rendezés a legjobb. \\
|
|
Itt az elemmozgatás mindig 1 értékadás (buborékrendezésnél a csere 3 értékadás). Listára is implementálni lehet, ez esetben a pointereket állítjuk át, az elemek helyben maradnak. \\
|
|
$A[1..j]$ rendezett, $j=1..n$.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Beszurorend.jpg}
|
|
\caption{Beszúró rendezés}
|
|
\end{figure}
|
|
|
|
\subsection{Versenyrendezés}
|
|
|
|
Gyakorlatban nem használják. \\
|
|
Teljes bináris fa az alapja, egy versenyfa. Szintfolytonosan ábrázoljuk tömbösen.\\
|
|
\begin{enumerate}
|
|
\item A versenyfa kitöltése (a verseny lejátszása). Maximum a gyökérben, ennek kiírása az outputra.
|
|
\item $(n-1)$-szer
|
|
\begin{itemize}
|
|
\item[a)] gyökérben szereplő maximális elem helyének megkeresése a levélszinten és $-\infty$ írása a helyére
|
|
\item[b)] az egészet újrajátsszuk (azt az ágat, ahol volt) $\to$ 2. legjobb feljut a gyökérbe
|
|
\end{itemize}
|
|
\end{enumerate}
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Versenyrend.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/VFaKitolt.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/VFaMax.jpg}
|
|
\caption{Versenyrendezés}
|
|
\end{figure}
|
|
|
|
\subsection{Kupacrendezés}
|
|
|
|
\begin{enumerate}
|
|
\item Kezdő kupac kialakítása. Rendezetlen input tömbből tartalmi invariánst készítünk, ami már kupac struktúrájú. Elv: cserékkel lesüllyesztjük az elemet a nagyobb gyerek irányába, ha kisebb a nagyobbik gyereknél. A süllyesztés eljuthat ahhoz a csúcshoz, amelynek nincs jobb gyereke.
|
|
\item $(n-1)$-szer
|
|
\begin{itemize}
|
|
\item[a)] gyökérelem és az alsó szint jobb szélső (=utolsó) aktív elemének cseréje, és a csere után lekerült elem inaktívvá tétele
|
|
\item[b)] a gyökérbe került elem süllyesztése az aktív kupacon
|
|
\end{itemize}
|
|
\end{enumerate}
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/Kezdokupac.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Sully.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/KupacRend.jpg}
|
|
\caption{Kupacrendezés}
|
|
\end{figure}
|
|
|
|
A kezdőkupac kialakításánál, és a ciklus közben a süllyesztés módja kicsit különbözik, hiszen az első esetben a változó elem süllyed le a teljes kupacon, a másodikban a gyökér süllyed az aktív kupacon. A képen látható algoritmus mindkét műveletet teljesíti.
|
|
|
|
\subsection{Gyorsrendezés}
|
|
|
|
Elve: véletlenül választunk egy elemet. A nála kisebb elemeket tőle balra, a nagyobbakat jobbra rakjuk, az elemet berakjuk a két rész közé. Rekurzív algoritmus.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/GyorsRend.jpg}
|
|
\includegraphics[width=0.3\textwidth]{img/Helyrevisz.jpg}
|
|
\caption{Gyorsrendezés}
|
|
\end{figure}
|
|
|
|
\subsection{Összefésülő rendezés}
|
|
|
|
Alapja: 2 rendezett sorozat összefésülése. Ezt alkalmazhatjuk felülről lefelé (rekurzív) vagy alulról felfelé (iteratív), ez utóbbit szekvenciális fájloknál.
|
|
\begin{figure}[H]
|
|
\centering
|
|
\includegraphics[width=0.3\textwidth]{img/OFRend.jpg}
|
|
\caption{Összefésülő rendezés}
|
|
\end{figure}
|
|
|
|
\section{A műveletigény alsó korlátja összehasonlító rendezésekre}
|
|
|
|
\subsection{Műveletigény}
|
|
|
|
Kijelöljük a domináns műveleteket, és az $n$ inputméret függvényében hányszor hajtódnak végre, ezt nézzük. Jelölés általánosan $T(n)$, de lehet konkrétan is, pl $Cs(n)$ [csere]. $mT(n)$ a minimális műveletigény, $MT(n)$ a maximális és $AT(n)$ az átlagos.
|
|
\begin{itemize}
|
|
\item[$\Theta$]: nagyságrendileg azonos, két konstans közé beszorítható
|
|
\item[$\mathcal{O}$]: nagyságrendi felső becslés, $o$: nincs megengedve az egyenlőség
|
|
\item[$\Omega$]: nagyságrendi alsó becslés, $\omega$: nincs megengedve az egyenlőség
|
|
\end{itemize}
|
|
|
|
\subsection{Alsókorlát}
|
|
|
|
Például: $n$ elem maximumkiválasztása legalább $(n-1)$ összehasonlítást igényel. Bizonyítása: Ha ennél kevesebb összehasonlítás lenne, akkor legalább 1 elem kimaradt, és ezzel ellentmondásba kerülhetünk. \\
|
|
\textit{Döntési fa}: Algoritmus $n$ méretű inputra. Kiegyenesednek a ciklusok véges hosszú lánccá, a végrehajtás nyoma egy fa struktúrát ad. Tökéletes fa: minden belső pontnak 2 gyereke van. Ennél az algoritmusnál nincs jobb, mert $2^{h(t)} \geq n!$, összehasonlító rendezés esetén, $n!$ input.
|
|
|
|
\subsection{Alsókorlát legrosszabb esetben}
|
|
|
|
Tétel: $MO_R(n) = \Omega(n\log{n})$ A legkedvezőtlenebb permutációra legalább $n\log{n}$ összehasonlítás. Bizonyítás: $\log_2{n!} \leq n\log_2{n} = \Omega(n\log{n})$, és $MO_R(n)=h(t) \geq \log_2{n!}$ (lemma miatt) $\Rightarrow$ $MO_R(n)=\Omega(n\log{n})$.
|
|
|
|
\subsection{Alsókorlát átlagos esetben}
|
|
|
|
Legyen minden input egyformán valószínű ($\frac{1}{n!}$). \\
|
|
$AO_R(n) = \frac{1}{n!}\sum_{p \in Perm(n)}{O_R(p)}$, és könnyű belátni, hogy $\sum_{p}{O_R(p)} = lhsum(h(t_R(n)))$ [levél-magasság-összeg]. \\
|
|
Lemma: Az $n!$ levelet tartalmazó tökéletes fák közül azokra a legkisebb az $lhsum(h(t_R(n)))$ érték, amelyek majdnem teljesek. \\
|
|
Tétel: $AO_R(n) = \Omega(n\log{n})$.
|
|
|
|
\end{document} |