"

*→xD
9¥
'

limn -so
< to
⇐ awoke → Siegen)⇐ lfnzno 0£ fan , ⇐ c. 9cm -

✗So pom
-

O
limn -
> • ¥? > 0 ⇐ *elk xp face 9in)⇐ In >_ No 0<-09 ( n ) ⇐ fcn ) -

1*00×-1
few fcn, r

limn >
-
• gTn) > o eel limn→N-gm< ✗ ⇐ tacos .ok Get ☒ He ⇐ FNZ No OECe.gov ← fcn) -2829cm -

☒ 27 00h
-

lfnsn tent ← c. 9cm) -

yep ik -
tch / =
019cm)
ten,
limn → a gin]
=
0 -
"

TM ok ⇐
plan ☒ ☒⇐ g
-
N - Honk IT t

lfnzo tcn) 2 C- 9cm ) -

yah
-

tch )=wC9cn))
limn → t =D pips ak⇐
tanks
⇐ g- N - Hawk fire t

ft Fo Size So *
- ' - -

ON →
oclogn ) → 0cm →
Ocnlogn) →
0cm ) → Oczn ) →
Ocn ! )

Éi =
ncn -11 )
2
=

① (n -
) :
gala me .

i=1

""

71ST
✗
Iz
c- -1
11--11 ② (✗ I
"
nwo ✗ =

✗ -
e
=

soap ic•
.

e. °
a. ¥0 d-
"
1×1<1 ✗ ① a)
§
ogk.ro#ic.lnln1sHnElncn)-1.s.Hn--&i----0(logn.gmaaniCa
no
= = '

✗ an ☒

i=^

ad -40 +☒ doin Naf

£ Ai -

Mi =
⑦ (nd ) dn.HN p§a•
5=0

-
a "CWNok ☐ JIND @ -
ji >✗
f- ( n)
=
( him) Jc gcn)=O( him ) od fin> =
Ocgcn) ) ok .

fcni-RChcnD.sk 91nF _R( hand and forth /gon) ok .

for)= ⑦ (hem) isk 91N __

⑤ ( hem ) ad for )= @ (9cm) ok .

9cn)=I( fan,) •
"
ok f- In )= 019cm ) •

91nF ② ten, ) a' ok

'

for/ =
-019cm) •

☒☒✗☒

* n↳kN7 GOIN -

→ xp RO -
*
-
13TH -

* 377 I' e-

: -437C .li
• TIN G ahh -28 Heat 3T 'kD am 83W Oya
'
G-item -4 Hey → -30 + nd ix. Tcm '
Of

9>-1
,
b > 1
,
for) > 0
,
Tcn )= AT (G) +
f- (n) :QokN7 Colt

Nl% ) ( nl%a
"

E)
-

1-
(a) =
②( .sk Eso flap fcn, =
• k e

① ( nl°%
"

TCnt-0~fcnilogn.sk fcn, = ) ok 2

T(n1= ② ( fin , /
gli Ccl flap af (G) ← c- fcn , et Eso gap • for )=I( nd E) pkz
 *☒TT
Linked List / → em am

2. head
⑦ (1) ⑦ (n )

prev next prev next Prev next

k k k

stack / - joint
Last in first out
-
LIFO →
A ⑥ → Solo -

top Knp pitch no'k7

-

bottom lap 73M notch -

stack CSI Joan'sso

create c) : create an empty stack
-

iscmptycs) return :
true if S is empty ,
else -

false .

pushes ,✗) add the item ✗ to the stack S

:
.

POP (S) remove and return the

: most recently added item from stacks .

① (d) :#027×10150

TON-l83Nka_jonNeWN.nfalaaSynoN-WNka_y0ANeN@HS.t
010=407254
-0€ ☒a raw 6 oxy'M top Manner .

HONG Toya
-

top ogk -_
-
j NA Ako •

✗ ✗ Xz ✗4 S [ 1] 2ND
D gone no 'k7
i z
YOMA
-

-
"

② (1) .
>

+1%02--10150 -

Queue 1nA
Q .
head Q - tail first in first Out
-

FIFO -
QQ D8 Solo -

head lay -1138 in nah info one

, yeah →
'
ka -

tail xp) -1-38 ☒+ 7*7 WIG je Mili n' k5

Queue is) £00 rise

creates creat an empty queue
-

iscmptycoi : return true if Q is empty , else -

false

enqueuecQ.it add the items ✗ to the stack Q

-

:
.

dequeuecs) : remove and return the least recently added item from the queue 0
 8Wh
:p A
TON -183N Hank
HON * lmao) fates ↳ H -
*
-

:p .HN je a.
xp pond dojo -

Ga CA ) ⑥
TONS *Tae 1hpm n msn.sk 8- Close * Wha ) ka la *agha head •
-
- -

Nc aim @ OpTic ) tail •

risk km
of
' -

head
taitl-NITNas.HN#in5ctai--head--o-rfmNNn*-
,
head -11 . - - - -

② a) * lion Hsia
' -

-
'

snot - MOS -170176 - Nien

N'e- or
' '
→*
- 1) ' ASK N
77137 ☒ '
N' 3 MS 'S -4377
-

-
ya 37 Ms 'S 01ft -13T£ +13 1 " ' -

"
AHN KO NAM -41317
7h
f3NkN risk
" -

>

.
on ND -7148 Msa amah
*
so to
ONS
'

;)
- -
YI
⑦ (1) xD 07Th D8 nailed I. e-

110 20
In fact
f) not -17071×1--13150
joint ANA
. -

-1×1 ADT
,
 #
- Got D8 It Kia To#

MBS do
Irisa -1£ ma ) • *ftp.ask we Kia new Po #
foil 21¥77 ki 882 217217
@ ok ?
-

→ ink 07 ok 1×14 - k e '

amah jec ok -

2×11 12-1×88 of 31*17 147 t.jo 217217

-

-
ja ☒ 317217 147 780 -

I @ ajñ
'

ON K' 7
317217 @ INT
-

If 28 Givat -062 How yh ki ✗ 217217 & ✗NOT

-

I → 1 's fam kin 887 the

-

a - v13
TN
this kiX-lpX@H3k3a.n3h Ron 147 X-D PAINT 887--5
-
l kit
g- in Pf Dale
-

- mate @ -310 +3107 Ki Hyo do #

his first Kf arty

.

> 80 -

fi #N '
↳ -48 His oh -301 * MESA 88 WHN IM
Api ly's mya
-

→
'

- e *

a a

=/
☒ if b
b

↳ ink
1*22 - v13 e. is It 1st II
'
←
pya 2h O
b '
- v3 88 we 80 KIT left my 's 88 -

:InN7
°

kg THO His • 6 we lift 80 hi • Globin Hyo Po -

↳ re
k

Kahn -0 AND HAD 14 'S lion D) DX

-

: in

KE - HAN offs it
'

80 -
a #3
•

kz - that ffa fine % - xD ✗ xN3•

for Maine Toa key

-

① MAN jk hull km ☒ +07 ok) Kor ① IN P -

HUH 1-17
+07 ☒ HoH fines por AMN left -

(hull ki ok ) yh 108 JIN right

-

poi ago µ
a hied fast T .
root
-

7750
'
K'712Th

DLR µ
'
← Gene ← Gie -

preorder -

HIM -17247 _-ky8 it ← Ioa #a own

-

⑦ (n) LDR µ
.
← his ← fine -

Inorder
-

LRD em ←
*
← Gene -

post order -

Nor fours -1M D8 soon ← Into .no#aoHGweNas-s..IoaaQG-Lere1order-

① ( h)
⑦ ( h)
⑦ Chl
:3 -8 ✗ GIN at apian ✗ GOD
-
1- O ' '
All MN ) ,
Ho Ki ) ✗
ya ik X -

S - Kal

X-p Gpa -15.8 2- *

102811 RAN ✗ - k MN ) ,
2×11 to ✗ -5 all -2

② Clogn ) wya ye
✗ -5 ok >

(4) IN a- 3170 21¥77 baton at HHI fine go to the > 8 a. e) -

8321 2/1 npt If -

IN a.

In ✗ alma y -
K sie , -
?⃝
 ••
Hbd ☒ $8 • 338
"
→ ☒*
↳ :L told ,
HOL *v3 N Go ab ask ;D IN
nD§ Ni = Zi : i THOS
-
HI
'
ON -1

# h
L=Nn=
h
2h :p -807 ON -2

2h
"
h= { hi =
{ 2i= l -

:p #37
'
ON 3
i -0 i=o

h=lo9zCn+l ) -
1 : adf.tt
N L -
-_ 2h -1 =L -

f :p "Nj☒ own
'

ON I

AAVVK a. ☐ j§W a- 300 0001 ) yah ⑦ Clognl aka on • jslkt only 'D 810'M 30 '

① (logn) @ INS -101500 03M

'

① Tdlj 't - K' 3N / 02171*101 rapist 170571010'M IN -

① (n ) G → stood for → no -1180 -

l hated Kit Ro : avoid #

Tin
-

h(✗ left ) -

hcx right)
. £1 Has naan ✗ Matt G *a -140 -

.
-1 1k 1 1k O ki lista ATO > NIG .

- f)V2 -415 - K "

TNG i -
ly -
a 812 'm RO ki AVL 88

f- shot
'

-8287713 knifed holt ) ② Clognl AVL 80 basic :( It

1-
.
K tales AVL ⑥ a - ×N3 @ ftp.NT OM NK '
7'

NK =
Nk -
et Nk -2+1 :
the -11^38 -86 '
04

AVL a -
→ Ifip
HIM 03N Ystad '
XD Hc3ihoµ I a * ☒ a) • ☒ 8 7k BST -
a no -5027 YIK
☒ thaws a- 278 ANKHS

⑦ Clog n ) : -1027 b → 10150

! - is >8 alla
1- Smell •
Joanna ↳ 070 -
joys kfk Foro je ya 1-8 ,
an Ioa @ listen 41st ,
AVL too -

HO ION 1- d Fae of fist

15th IT Goa ao a' ye -178 to
'

•
n -

-1.3cm ① (e) -

*K Ch -030×6 800 aojs.rs -

Heap t.tn Doors offal ✗MD .
- ja je l '

,
• 20ft ,
exist

We
G see

88
% ki -

@ CONS Hyo
ab mys 80
If
# IQ 7*8 73 147 a
'
*
'
:O • " -

→
ja je Tha
e .
2-1×0 807 ask @ * 37 68.1
. -
ya je e .
Geneve - v13 685 fine
'

µ l ' l -1172 807 tale - XD P - NBS ok ?

887

P-N138ak.3Heaph.ninO.ae@nsHyisGk.7.wG
Je JN e l I
'

we
µ e. if - e lo
'
- 7012 → v72

, pjD7n2o8_1sln.k.ijojesoiaE_nl3Gial.a@Cov.s ly 's IO K' 7

jobs tag V13 G

.
aint WON / ain't → ✗ - N' 782

MOI

① ( n) -2 ☒N lion ⑦ CN -
a
a.jo -
l

①(lognl Dongen -
* 3N -101N 's 't -4317.2

7 N' 787 -
flax

Cmax-heaPlWQyo8HeikoiaealHh@T87X.ke
✗ -

key ⇐ parental) key .

G) ⑥
yz parent (✗ 1. key 1min heap) 42 -
08 am 1k FT 31721T pot
-

LET 072 ;D 13N

"

p.jo 18 Die
Yinka 21,721M
-

¥7 Kia → a e. e oof → No -

- y So →Nie

v8 "

① ( n) : -10150

① Clogn ) → miso

⑦ ( logh) : -101N

⑦ Cnlogn ) : -10120

① Clog n) Hsiao ① Clog n) '

also

-
IN'D → 12015

014 't * 782 AN

'

-0 → 808 0Th +07 × -

-

Ne -

68 I
WON -N' ☒ at -0
jut got
'

• →
-

'
link A)ON
• p.no
'k V2 D '
7×0 Go -
pilot → K oNjN - ✗ K :
-
IN -0
'

2 TONN -
JIN

→ IN ☒
'
-
- ✗
k fl Gil 2. NJ 7't
'

i' 3177

Dk Pdk 2W M
'

N' V7 I -23 insert A clip

• * - 2-
☒ a.

⑦ Clogn) -

a
✗ * N I a. fam
 '

03W IN iii.as -K SHE ✗ she D8 Ike a. to

BB -
trees 227

:O 'k5 -42 → KEN *a →is G-

V32 NINJA 1hAM ON ix.N

'

053
-
•

→ -

X key X.keyzE.n.tl/.Keyx.n2nik8naoaomoN7oN30--moN7 •
-

, ←

xN137aky3NajKHfo-X.leafoo.i@si3Oax-8X.Ci.X.ca
KID

, . . . X.cn-ireja3NX.nl Boys fist X '

N 'D ☒3 G-

✗ Cia
-
-1 X.ci P'30h jet * →Na '

- HAH ☒ * ON X -

key ; not
-

a 6 ☒27 k€ -1>-2 o@ot-If3Nkan2eNaPkhon.xNDGo_tmot.roN8noxs.n@W Io 68 -

- HAN t -1 - hor 8.x ,

enter Cnd , - v3 ↳ •

*pot 2+-1 uh 88 5*8 813 '

,
AN orris , > v13 I •

371k MAN -1×08 ↳ '

em , If 807 ok •

(1-22) he logt Ronnie -

Cpu :
0111
Disk OU )
:

CPU Oltlogtnl
:
CPU Oct )
:

Disk : 01109in) Disk : 0111

Delete
let Go) Me aye → 137

AM jaakko 2h MON) Hmat t → 1*85*8 *

Cpu Octlogtnl
:

Disk: 01109in )
Cpu Octlogtn )
:
Cpu 04109in )
:

Disk: 01109in ) Disk: 01109in )

 ayy jaws brief a gun

⑨ Dok SK -

MN TOWN build p ok ☒c) → -0 ikys -

my 'd µ§ build -

0Mt N
→HN 4317
'

j N 'T TAN
- -
-

- →

Hft MO of AVL -

-01109N µ 1*1 N of 00 Met

-

play -10C HAD he if

k.IO
→ *

KI llognl ☒ AVL NCD ① lion

-

20 iyatfalc µ.rs Has ajar rate banned IG ) Out ☒ → Ma

-

☒3 GD 4317183*6100 GIMPO AVL % - ins 'll ✗ 6 151

03Wh / e. Noo
-

.
• . .

→
☒ NOD mate -0 Boy AVL folk -
* →Not @ IM am -0 AVL do -

→ is 6×1*1 no 'k
-

↳ 27023 d) a. 307 µ 71671

YAN KO
TON K' 7 ANTO : 71058
µ§µNSert
,
search delete ,
-
food swift - mate @ → ya at -1*8 .
3) * To am

-
☒ as -
jib -
HAND oh ,
0706 a. OOD Hall man e- * a note

- → WH - HAND ✗ INF 01Mt M 7010 ,M fates ✗ ON ITS plot → A

GOTIK II K' a IN 671>81 → 0*7 -

HAND →
36yd * ON G ↳§ ID '

DA ,
h da 'd
'

2 J Roys
flat 1USD 83kt at >
'

27 -
' '

3410 shine sijj a' NX .

4-ON ) Facs > kx

*a →I
'

1081 a- Aoki - listen -

Not AN ICT 7. fact fate fb
, > 20
f. da AKE - not ↳
1am jib :# He 1k
oj 1081 Jim k h 07
'

MON je y # # at > a)
'
'
* - - ,

-10€ ITS →Na [i =/ j ,

hci ) =
hcj ) ] Taco kx.is/k-k7jmh ①
-10*0 Got
-

nine of also

he Jae - na
'

ka G - K fol ka Go avast ,
22h ask Kot →
01M AND > For Ca * 8's

text
0725k - K also 77 7

# Chem ] ✗ siemens nah Roy Geo] -0111 omen AND aoji

'

0 fears Ms
Kaadhal alphas -
'

3h jk * →
'
Kor OIN Jail Mia] -011) finch # a N
'

2 & In µ
← jll'S 12

⑦ (n) '
Otomi kx idk 8
'

Co ☒ ka G ☒set *No 410 'M '

0 of fat
MT top - a.
-

,
"
CAN INCISE "

→ MAD RAJ 117407

,
Taco Him ☒K Go oj
> if d-* ☒ 7×111 -KO
'
k not Gf Nis
Fm 1- a
'

weak a 'M M girl i KA

Ojo
'
K MOM -17*07 1k

✗ =
Em .
> taiga C @ ONIOT 02M → K X-D / NO )

Cs n
'

pinata ON -

Ca fate -
M

217k 1*6 ans

'
k If 831N N '
ON
-

-
031×1No ② (1+2) AT
'
I' ☒ AID 012117 "
CHOI sik ☐ lay
"

*a →× Cd IN
(hash ⑥ ON 'M loyal awk ✗ a aorta * Ga )
M= ⑦ ( n ) -0 Ij tool ✗ =
Am ,
2=0-11) all ①☒ →
so 0151 MS 031dm fax ⇐
① at MD 0*0,0×4 pis He sina.li ↳If G. xk a. list MIG
2. Stay 37310 nina8 23 'S

C- ME Doa Garth jisa.HN#fn--Io)jQamniaosiCaiaOihCKl=KmodM- Him ✗ C. e. i

PhD M=kP my oj 8 HA N
sifl ② more is :D 'M
'
leg Koon a' 317 ONT K AN
"
-

sic * - -
' .

2=78-9%3514 (jem) M=7o1 my SK (✗~~3) 831ms He ain't 3 8*8 Pyon ykl A- 2000 ok : 28

JI
'

ON - Miko Misako IG Olaf ,

0 - A - 1 7063 hckt-LMCK-modlH-cosa-C.biz
•
2 G a # Hae m → ☒8 INN IONS

Open Addressing
ok C-IN ① 7C 'M
.
-
MCW MK * ☒ 2N ,
010×720 1*1 →
'
k
Oj > 78734 ,
1881*30 Go * NC ) pins'k7 IS

2<-1 1081 NEM is Kim Hsia a. taxi is 8 a > 81yd AND

⇐ find God)a☒-
'

oh not :*Cha je ↳☒ p yd hash -7 D - Ka H -

,
please ,
Alex ask 01*8
'
D

-
ADD A hlkio) tick , ,
e) . -
.
hck ,
I -

1) AKA ✗k
p ✗
+
i -

A * 3-G' KD KX Had

7707
'
-

* Me Ho'M > 22 CIA b' 30 -1312T + so is aC% HID ya )

,
ago a →

kxr deleted reason 18 , -in Rosa @ a

joss ☒
'

as far a N ne end 1×1

8
( flat Highness lion -1in Karak PAN 1*8 TO ojioyxju Kie 24
'

>a
"
yo
" '

/
'

- 2- I left deleted -2 python Kx ans a + C- a 't '

Ii Ms
 .jo 15134420 :p Text hlk.at#-tipl2a.fwD,hashjaIx-W-eioMxfifd
§ Nato ON 281k , Skin k k3Nb - - 1k Ask * sk ,
a' a -K D ,
☒ at 210 He ntlk as )
focal,
① (Itn # 1) *Gw win -0¥) :@is no'm -

031am INS

.jo kx 1.34020
)
>
jowl ,
'

yo hlk 01 , # ok Maj ÑMD ,

hash '

ON MA ) -

00pm →
•
008 mail.tk ojsj 1344
,

pins'k 208 am Hiked HIM silk 75,134 Kd ok

⑦ ( ¥) :@ 13 lid 'M 831M >

:
75 µ

Open Addressing AND state -13×10

Linear
probing
t.hn#2gMafls-8sO2Goap-.yNNfm.fX
-

fast
IwhCK.il-ChYk1-i1modmDkfN-skX@Aliz-n3tyk7Cio2.C
hash
'

ON is

'
e
U yiot.BA
ml.gs#3GNnof-MIIemp7l'.tI1s-7J0-0ap * Ghote
'
•

Gie hlk i-lhecktxha.lk/-i)modm-

↳ -

M : news
,
Double
Hashing .2
383
'

2- hz ( K) ,
-
'
ha
'

d- heck)

1. nioso alex
that's MIND fix
'
I 1+8 114*10 ☒* KS ,
031AM / Nsa Diaz - KID -1%07 -

HK xk faith legged (2) load factor

'
Da 'M 83Wh MONA
'

2D a
TO
-

✗
'
ON
-

- -

-831Wh 77Th 88 nah N nous

p Iz Moraes even 8 -

, -

day fac ⇐ 091 ATAN Hoya 8 WINN INS

-

=
-

168 848.23 a 'M INT G fate 720 I Saiga ASC fate in

'

1-8 Ak
✗ f. 38 021
'
•
-

'
-
,

Gay ✗ -8 @ @ si lay ↳ 81 Is@ G K je @

"
aka risk I > 2 pinata ojsj ✗ noon also
' =
-
-

I a -
,

%08 jefe again

"

→☒ am ✗ ON ON
'

☒a 74
-

0100
" " =

Linear probing
linear probing open Addressing

↳ not a)TON
hash chaining -

50 →88
* AN IQ ok *

open addressing
-

80--088 ← ↳ N -10pA '

p
e 't -1Mt Y
'
PK *
 * A
1C
H1N1 @ •

"
.

: - →

"
merge sort & quick sort 0308 yd →
sealane acts -

Tent anon →
C. e-

Don 'M also 790 ) 04

-

grow ①I ① 6807 TONS match -0017 -20 forme 1h -

☐ 3
' '

i' N
-

( 2>1
'

HI +2011 Mo 's -11377 Cha KI AN Alpha

As -
i't
-

•
:p Na

-11111W 0010N IN
-

Insertion sort -

↳ 011 µs 'S-11377 4127 alma k8 His '3

'

yd -111ha ,
0010N IN
-

merge Sort -

D) MS'S -4377 AR KS) alpha 11't 3

'
717072 If i't ,
-1141ha 0010N
µ d- Quick Sort -

Up NON aint 't Kj 's yd Counting sort

-

☒a
' -

mi i
'

→ ,
a -3 ,
-

I to → Not "
anjt ,
23
'

i. d ,
-
+ § xD pit
-

Radix sort -

( merge Sort -1 Quick sort ☒or -

-
↳live.sc#:ohNasoa--Ceoo

:p -283 3 as e 't + a' off D) 8 ACH -

act goat ☒ Hal a)CT AfD -03N KD €22 if He :#a #

- too *
'

ONE yah -
K
y it 07.1

( → 50 iks
-

- I '
idk -1×2 IT ¥7 OH DOM Alka → * - k - : fill -2

<3 'T
'

1*28 -1807 .
# MA →
k f > 3 : f-3.3

• Mate je * If ☒ I 7k faint ** -20 88 02't 100 Me 147 :#107 '

0010N
oyi.to

② Wiek=§or€
•
GON IN →Chek xk CNN.tk#1H
IN two Act - ☒7 → He b ¥0M HK
[ v1 , map DINA ①or a ON → + 2- 8 TOM -4 aphid -

p→§k7 71K

pivot is apt ☒KD IOAN risk a) ,

aisle 20 AM l -

pivot -
d apple.no'M 1821
'

A- [from . . -
i]
pho :)ONO • sina.li 8 → K -201.2

Pivot d Iaea A- [ it pivot-1%1

'

.
-

man ☒I . - ✓

☒20h # N → K G so * Hh - K f. 02
) ,
•

Doth 101110.3
→ JINN ibis MOD SKI *Krak X '
Ako Kia * yÑ ⑥ 307 yyx -4

'

-
l )/ D
'

I'll Go ☒ ☒
jed find TOM 70113 ① Cnlogn) :D Apna
-

1- Cnt 2T (E) +
① ( n)
N-1 Glad 06 Go sit ☒a µN pom ⑦ (n ) '

TONI ✗ ON A nots Hca da

-

TlM=T(n 1) -

+ ② ( n) Alya Mariano ryoji D) -

l GHS

(pivot # * HMA notch ☐

joys - insta ↳ xk and -

Partition ①a
-

-03*2 AKI 233 yid akee insta G kl fine 23N

µ
'
-

① (n) 150

a' 3
'
1-8 , in-place /IN
?⃝
MM @Agg@ $88# =
men anon He →3ha 03am A " 'M 11W
→#
/l't
'

a Ifk 7 711C

- a -2212 His +827 20 GOT a INN 2- or pom ,

- k shed a@ Go

*Nda post → rat 20 e. * ye

G sd Go a .HN Ako Bon DG a Tom -4 ✗
js
p.ge#mskDje--khx 8 -83W cyst IN
"
+

082 Go xD →
'

Ii --k3H CH *me a ON

a @ Go .li#oo-0Cnlogn):a3Txs--Ma'0
as

835
'

assist • WOOD ON -

log n

1- ( n )=2T( E) +
⑦ (n) :
yoga
'

01J

23
'

p.in Place / I

ccoouunnttiinngg-ssoorrt.CH To -WON Min ajM MIND IN

A 20 A alma ad ON ki '

om n dark
-
G :C So - hp -

a ca
'
Hk -7 Gi Jama M
'
at -7 Ge 1-17 :
0*1*7 I ☒7-
AS got Ma CHI Gye HO
'
ONA MICH +828 hah -

p→yÑ 71115

← ODIN G In K 82h0 C 713J A

* ,
TON
.la →
'
K G @ Ogawa
'

ON → K a) HI *7 YON ) A TON → K
T -01.2
'

.
C [ i l] -

WIT - k f '
1) < [ i] GO 082ND -
'

ON -41 Also ) .
3

A I 8 am Ik IM ain't'T ON nth C [ i] lexa

'

TONS as ☒ska
-
-

C[ Aci]] ☒ B Ina
Yona idk ☒N Aci] K G nwo 8 Road A K Tho ) 4
A
TON
'
☒ → ☒ →
-

1- I C[ Aci]] @
KEANU 1st -0--11 RT )
is

MN ☒ Jk →OH B 5
Town µ ,
.

- match
'

ON -
N ,
② ( n -1kt IT INS -10150
(CAN 812 '

- in}) ONA NIC

'
-

✗ I na'M Ako '

21pm sofa → 88 Nie -

☐
'

3
'
/It
in place ko
Pha @☒ =§②rr# NAMI so
www.ym-xoom.K
flap 10 0107 48
'

OMG { '
3D -1-207 '
ON Xp
→ He 000 GO.pj.tk D
xk.MN :*
'

,
ONS 720 H) -

ON

IN -40dam moon a * love # - in → oat ii.

IN @ f- a' 3
'
-

Ma

①N -

N ⑦ Cdcnik) ) :# is -
'
0

-
gate
'

ONN -1-007 His -

0^00
-

07
Iiiii
•

I
-

nuts k=g news 0 . - - k a. a

'

11W a A ① NO
• ^
I n NIG K=2 DID 0 . - -
K 7 'T
'

t.tt •
"

714 'S ODD

② (dlhtk) ) 1- 17 IT INS § k o
-
ODD → DO d • if e. ,
'

ON n -8 ok :(Ot

,D'3 IN
'

ewers ymoey.ua + C- -

in place

B3eke*=§•r*
→I
'

1k the 0640046 (buckets) £0K * n -

8 CO > 1) Xp - k §N :*
.pji↳ -0cm µ CH h JOJI ,(2Hc ☒ grow Chae D8)
'

ON - k no 7

.PH 2h Go * SHH 0.22117207 of -

'

OCH 88 ✗ SO ) SKI so GO ONT '

- K YN )

.CO ,l ) * CD a' He ☒KD and'm xk ☒ di -

Kyle fax £8 734 ⑦7 A) 7

pxiyflinlkx.info#-kc5G-MGpN-1NhGBns0yngNDlwxh
.tn
.

G.cn
GIN MC
⇐ Nfa

pika CH pot ] A to halo

•

( NA [i ] G y# ☒ ☒☒8) Bcn
☒ Aci] ] :-# Ni Eso =p
.oysN Aci]
- "
note G-
G fix him µ £0 #k oy.int/By0M AND 6
- of Dinoto
•

.MN Ñ jor µ B 80 raft

TOM k
gift
' •
-

C. ☒3) → Hi
'

-kÑ ⑦( n)
:# i is -10150

☒ * MM ② (na )

53 '

p ,
in place Kor
 - -

-
Best
Keys Average Worst Case Extra Space In-Place Stable
Runtime Runtime
✓ Insertion Sort Any

✓Merge Sort Any

✓Heap Sort Any

✓Quick Sort Any

21T¥)-10in) T(n et ⑦ ( n )
-

Counting Sort Integers

Radix Sort digits Depends on the Depends on the

in base stable sort used stable sort used
Bucket Sort
Uniform Z
 - -

Average Case Worst Case

Create() Search(k) Insert(k) Delete(k) Create() Search(k) Insert(k) Delete(k)
Linked List
ADT
Binary Tree
AVL Tree

Skip-List

B-Tree

Hash Table
(Chaining)

AVL

Hash-Table
(Open
Addressing)
 - -

Heap

-
Make-Set(x) Find(x) Union(x,y) total actions
Make-set,
Linked List

Tree

using Path-
Compression
 ‫סיכום חומר לקראת מבחן – מבנה נתונים‬

‫עדכנו אותי על טעויות או אי‪-‬דיוקים! תודה‪ ,‬אפרת‪.‬‬

‫נושאים חסרים‪ :‬פתרון נוסחאות נסיגה‪ ,‬ניתוח פחת‪ ,‬וחלק קטן מהאלגוריתמים שנלמדו‪.‬‬
‫בצהוב‪ :‬עידכונים מה‪23/6-‬‬

‫‪ .1‬טבלת מיונים‪:‬‬

‫הערות חשובות ווריאציות של המיון‬ ‫זמן ריצה ‪ +‬הסבר‬ ‫מיון יציב?‬
‫מיון יעיל במקרה של מערכים קצרים או‬
‫)‪ O(n^2‬במקרה הגרוע ובמקרה‬
‫במקרה שרוב המערך כבר ממוין‪.‬‬
‫הממוצע‪.‬‬
‫לאלגוריתם רקורסיבי ניתן לחשב את‬
‫זמן הריצה באמצעות זמן נסיגה‪ .‬במקרה‬
‫)‪ O(n) – O(nlogn‬פעולת המיזוג‬
‫זה‪:‬‬
‫בכל שלב‪ – logn .‬מספר הפעמים‬
‫)‪T(n) = 2*T(n/2)+O(n‬‬ ‫שמיזוג זה מתבצע‪.‬‬
‫)‪T(1)=O(1‬‬
‫)פירוט מטה(‬
‫)‪ O(nlogn‬במקרה הגרוע‪.‬‬
‫הסבר‪ :‬בניית ערימת‪-‬מקסימום –‬
‫‪X‬‬
‫)‪ ,O(n‬תיקון הערימה אחרי כל‬
‫הוצאת מקסימום – )‪.O(logn‬‬
‫לבחירת ה‪ pivot-‬חשיבות מכרעת‬
‫בקביעת זמן הריצה‪ .‬אם הציר יהיה‬
‫תמיד החציון‪ ,‬נקבל זמן ריצה אידיאלי‪,‬‬
‫)‪ O(n^2‬במקרה הגרוע ו )‪O(nlogn‬‬
‫אם הציר יבחר להיות האיבר הקטן או‬
‫במקרה הממוצע ‪ .‬זמן הריצה תלוי‬ ‫‪X‬‬
‫הגדול ביותר‪ ,‬נקבל )‪.O(n^2‬‬ ‫בבחירת הציר‪.‬‬
‫שיטות לבחירת הציר‪ :‬בחירת ‪ 3‬איברים‬
‫באקראיות ולקיחת האמצעי מתוכם‪.‬‬
‫?‪In place‬‬ ‫הסבר המיון‬ ‫שם המיון‬
‫מיון השוואה פשוט‪.‬‬
‫לולאה חיצונית עוברת על כל תא במערך מתחילתו עד סופו‪ .‬בלולאה פנימית‪,‬‬
‫מיון הכנסה‬
‫כל תא נכנס במקומו בין כל האיברים עד אליו ע"י השוואות והחלפות‪.‬‬
‫מיון השוואות‪.‬‬
‫מיון רקורסיבי‪ .‬בכל שלב מפצלים את המערך לשניים‪ ,‬ממשיכים לפצל עד‬
‫קבלת תאים בודדים‪ ,‬ובונים את המערך חזרה כלפי מעלה כאשר ממזגים‬
‫‪X‬‬ ‫בכל שלב כל שני חלקים עד קבלת המערך בשלמותו‪ .‬פעולת המיזוג מתבצעת‬ ‫מיון מיזוג‬
‫ע"י השוואת שני האיברים הראשונים בשני המערכים שרוצים למזג והוצאת‬
‫הקטן ביותר בכל פעם‪.‬‬
‫עץ חיפוש בינארי‬
‫מיון המתבסס על ערימת מקסימום‪/‬מינימום‪.‬‬
‫בונים ערימה מהמערך הנתון )ללא צריכת זיכרון נוסף(‪ .‬אח"כ עוברים‬
‫בלולאה מ‪) n-‬מס' האיברים( עד ‪ :1‬מושכים כל פעם את איבר המקסימום‪,‬‬ ‫‪Heap-sort‬‬
‫מציבים במקום האחרון הפנוי במערך ומתקנים את הערימה )פחות האיבר‬
‫שכבר במקומו(‪.‬‬
‫מיון השוואה‪ .‬מממש אסטרטגיה של הפרד ומשול‪.‬‬
‫בהינתן סדרת מפתחות‪:‬‬
‫‪ .1‬בוחרים איבר‪-‬ציר‪ ,pivot ,‬לרוב באופן אקראי‪.‬‬
‫‪ .2‬מסדרים את המערך כך שכל הקטנים מהציר יופיעו לפניו וכל‬
‫הגדולים יופיעו אחריו‪) .‬איך עושים זאת? פונקציית עזר –‬
‫‪ :partition‬עוברים על המערך מתחילתו‪ .‬עבור איבר קטן מהציר‬
‫ממשיכים הלאה‪ .‬עבור איבר גדול מהציר מחפשים את האיבר הבא‬ ‫‪Quick-Sort‬‬
‫הקטן מהציר ומחליפים ביניהם‪ .‬שומרים "חוצצים" במערך‬
‫מיון מהיר‬
‫המסמלים‪ :‬כל האיברים שכבר התגלו כקטנים מהציר‪ ,‬כל‬
‫הגדולים מהציר‪ ,‬ואלו שטרם נבדקו‪ .‬את הציר עצמו נשים בינתיים‬
‫בסוף המערך הנבדק(‪ .‬זמן ריצה‪.O(n) :‬‬
‫‪ .3‬קוראים באופן רקורסיבי לגבי כל צד של הציר‪.‬‬
‫‪ .4‬תנאי עצירה‪ :‬כאשר המערך עליו השיטה מופעלת מכיל איבר אחד‬
‫בלבד‪.‬‬

‫‪1‬‬
 ‫הערות חשובות ווריאציות של המיון‬
‫זמן הריצה הוא )‪ O(n+k‬כאשר אם‬
‫)‪ k=O(n‬אז זמן הריצה הוא לינארי‬
‫יש לנו גמישות בבחירת הבסיס‪.‬‬
‫משפט‪ :‬נתונים ‪ n‬מספרים בעלי ‪b‬‬
‫ביטים‪ ,‬ונתון מס' שלם חיובי ‪ r‬הקטן מ‪-‬‬
‫‪ .b‬מיון בסיס ממיין את המספרים הנ"ל‬
‫‪b‬‬
‫בזמן‪. O( (n 2r )) :‬‬
‫‪r‬‬
‫כלומר‪ ,‬עבור ‪ n‬ו‪ b‬נתונים נרצה לבחור ‪r‬‬
‫כך שזמן הריצה יצא מינימלי‪.‬‬
‫ללא הנחת ההתפלגות האחידה‪ ,‬זמן‬
‫הריצה עולה אך האלגוריתם עדיין נשאר‬
‫נכון‪.‬‬
‫‪2‬‬
‫זמן ריצה ‪ +‬הסבר‬
‫– )‪.O(n‬‬
‫))‪ – O(d(n+k‬מכיוון שמבוצע מיון‬
‫מנייה‪ ,‬כפול מס' הספרות ‪ .d‬אם ‪d‬‬
‫קבוע ו‪ k=O(n)-‬נקבל זמן ריצה‬
‫לינארי )‪.O(n‬‬
‫)‪ ,O(n‬בהנחת התפלגות אחידה‪.‬‬
‫)‪ O(n^2‬במקרה הגרוע‪.‬‬
‫מיון יציב?‬ ‫?‪In place‬‬ ‫הסבר המיון‬ ‫שם המיון‬
‫כל איברי הקלט הם מספרים שלמים בתחום ‪.1-k‬‬
‫רעיון‪ :‬מחשבים עבור כל איבר כמה איברים קטנים ממנו או שווים לו‪ .‬אם‬
‫יש ‪ y‬איברים קטנים מאיבר ‪ ,x‬הרי ש‪ x‬יהיה במקום ה‪ y-‬במערך הממוין‪.‬‬
‫האלגוריתם משתמש ב‪ 2-‬מערכי עזר‪ :‬מערך ‪ C‬באורך ‪ k‬לשמירת המנייה לכל‬
‫איבר‪ ,‬ומערך פלט ‪ B‬באורך מערך הקלט ‪.A‬‬
‫פירוט האלגוריתם‪:‬‬
‫מיון מנייה –‬
‫מאתחלים את מערך ‪ C‬באפסים‪.‬‬
‫‪X‬‬ ‫‪counting‬‬
‫עוברים פעם ראשונה על מערך ‪ .C‬אם ]‪ ,i=A[i‬כלומר מצאנו איבר במערך‬
‫‪sort‬‬
‫הקלט השווה לאינדקס הנוכחי‪ ,‬נגדיל באחד את ערך התא ]‪.C[i‬‬
‫עוברים פעם שנייה על ‪ ,C‬הפעם סוכמים לכל איבר את עצמו וכל אלה שלפניו‬
‫)כלומר המספר בתא ]‪ C[i‬מייצג עתה את מס' האיברים הקטנים‪/‬שווים ל‪.(i -‬‬
‫כעת עוברים על מערך הקלט מהסוף להתחלה‪ ,‬כל איבר עליו עוברים מועבר‬
‫למקום המתאים ב‪ B-‬לפי המספר השמור ב‪ ,C -‬וערך ‪ C‬מתעדכן ע"י הפחתת‬
‫‪.1‬‬
‫מיון לפי ספרות‪.‬‬
‫תלוי במיון‬ ‫מסתמך על כך שמספר הספרות בייצוג המספר חסום ע"י ‪.d‬‬
‫שבחרנו‬ ‫האלגוריתם מבצע מיון של המערך לפי ספרת האחדות של המספר )כשהייצוג‬ ‫מיון בסיס –‬
‫להשתמש‬ ‫הוא בבסיס ‪ ,(10‬לאחר מכן מיון לפי ספרת העשרות‪ ,‬וכן הלאה – עד מיון‬ ‫‪radix sort‬‬
‫בו‪.‬‬
‫הספרה ה‪.d-‬‬
‫כל אחד מהמיונים יתבצע ע"י מיון יציב כלשהו‪ .‬לצורך העניין – מיון מנייה‪.‬‬
‫הנחה‪ :‬המספרים הם ממשיים בתחום ‪ 0,1‬ומתפלגים באופן יחיד בתחום‬
‫זה‪.‬‬
‫)ניתן להשתמש גם על כל טווח מספרים סופי אחר(‪.‬‬
‫נשתמש במערך עזר ‪ B‬של רשימות מקושרות שייצג את ה"דליים"‪ .‬כל דלי‬
‫מייצג טווח בגודל ‪.1/n‬‬
‫מיון דלי –‬
‫‪X‬‬ ‫עוברים על מערך הקלט ‪) A‬באורך ‪ .(n‬כל איבר ]‪" A[i‬מכניסים" לדלי‬
‫‪bucket sort‬‬
‫המתאים‪) B[n A[i ]] :‬לוקחים את הערך התחתון של ]‪.(nA[i‬‬
‫לאחר מכן עוברים על כל רשימה במערך ‪ B‬וממיינים אותה ע"י מיון השוואות‬
‫רגיל כלשהו‪.‬‬
‫כעת מעבר על מערך ‪ B‬ייתן את המערך כולו ממוין‪.‬‬
‫הערה‪ :‬מיוני השוואות חסומים ע"י )‪ .O(nlogn‬המיונים בזמן ריצה לינארי אינם מיוני השוואות‪.‬‬
 ‫‪ .2‬גרפים‬
‫‪ 2‬דרכים לייצוג גרפים‪:‬‬

‫‪  ‬‬
‫רשימת שכנויות‪:‬‬
‫זהו מערך שגודלו כמספר הקודקודים בגרף |‪|V‬‬
‫מכל איבר במערך יוצאת רשימה מקושרת של שכני קודקוד זה‪ .‬הרשימה‬
‫של קודקוד ‪ v‬למשל תכיל את כל קודקודי ‪ u‬המקיימים ‪. (v, u ) E‬‬
‫עובד גם על גרפים מכוונים וגל על לא‪-‬מכוונים‪.‬‬
‫מקום בזיכרון‪.O(V+E) :‬‬
‫זמן ריצה למציאת כל שכני קודקוד ‪.O(deg(u)) :u‬‬
‫זמן ריצה לבדיקת קיום הצלע )‪.O(deg(u)) :(u,v‬‬
‫ב‪.‬‬ ‫‪  ‬‬
‫מטריצת שכנויות‪.‬‬ ‫א‪.‬‬
‫זוהי מטריצה בגודל |‪.|V|X|V‬‬
‫תא ‪ ai , j‬יכיל ‪ 1‬אם ‪ (i, j ) E‬ו‪0-‬‬
‫אחרת‪.‬‬
‫מקום בזיכרון‪.O(V^2) :‬‬
‫זמן ריצה למציאת כל שכני קודקוד ‪:u‬‬
‫)‪.O(V‬‬
‫זמן ריצה לבדיקת קיום הצלע )‪.O(1) :(u,v‬‬

‫הערה כללית לגבי שאלות על גרפים‪ :‬ישנן שתי גישות לפתרון בעיות גרפים – האחת‪ ,‬התייחסות לאלגוריתמים מטה כאל "קופסאות שחורות" וביצוע מניפולציות על הקלט כדי שיתאים לאלגוריתם‪ .‬גישה שנייה –‬
‫התאמת האלגוריתם לבעיה הספציפית ע"י ביצוע שינויים באלגוריתם עצמו‪.‬‬

‫‪ = MST‬עץ פורש מינימלי‪ .‬יכול להיות יותר מאחד כזה בגרף‪ .‬יהיו בו ‪ |V|-1‬צלעות‪ .‬עבור גרף ממושקל – מינימאליות העץ תתבטא בסכום משקלי צלעות העץ‪.‬‬

‫זמן ריצה ‪ +‬הסבר‬ ‫הסבר‬ ‫שם האלגוריתם‬

‫לא עובד על גרפים ממושקלים‪ .‬עובד גם על מכוונים וגם על לא מכוונים‪.‬‬
‫בהינתן גרף )‪ G=(V,E‬וקודקוד מקור ‪ s‬האלגוריתם מגלה את כל הקודקודים אליהם ניתן להגיע מ ‪ s‬ומחשב את המסלול הקצר ביותר מבחינת‬
‫מספר קשתות לכל קודקוד שניתן להגיע אליו‪.‬‬
‫בניסוח אחר‪ ,‬האלגוריתם בונה "עץ רוחב" ששורשו ‪.s‬‬
‫הוא עושה זאת ע"י עידכון שני שדות בכל קודקוד בגרף‪:‬‬
‫)‪ .O(V+E‬הסבר‪ :‬כל קודקוד נכנס‬ ‫]‪ - Pred[v‬הקודקוד הקודם ל‪ v-‬בעץ הרוחב )=מי "גילה" אותו(‪ .‬מאותחל ב ‪.null‬‬
‫לתור פעם אחת ויוצא ממנו פעם‬
‫]‪ – d[v‬המרחק המינימלי מקודקוד המקור ל‪ .v -‬מאותחל ב‪. -‬‬
‫אחת‪ .‬כש"מטפלים" בכל קודקוד‬ ‫‪BFS‬‬
‫במהלך האלגוריתם נשתמש בשדה נוסף‪:‬‬
‫עוברים על כל שכניו‪ ,‬כלומר סה"כ‬
‫]‪ – color[v‬לבן )כך מאותחל( = קודקוד שטרם "גילינו"‪ .‬אפור = קודקוד שגילינו וממתין בתור‪ ,‬כלומר טרם גילינו את שכניו‪ ,‬שחור = היה‬
‫עוברים על בדיוק |‪ |E‬הצלעות‪.‬‬
‫ויצא מהתור‪ ,‬גמרנו "לטפל" בו‪.‬‬
‫האלגוריתם משתמש בתור‪ .‬בכל שלב מוציאים את הקודקוד הראשון בתור‪ ,x ,‬ועוברים על שכניו הצבועים בלבן‪ .‬לכל שכן לבן מעדכנים את‬
‫צבעו לאפור‪ ,‬מכניסים אותו לתור‪ ,‬מעדכנים את ה ‪ pred‬שלו להיות ‪ x‬ואת מרחקו ‪ d‬מקודקוד המקור להיות ‪.d[x]+1‬‬
‫מתחילים מלהכניס את קודקוד המקור לתור ‪.Q‬‬
‫בגמר האלגוריתם‪ ,‬הדפסת המסלול מקודקוד מסוים ‪ v‬ל‪ s-‬תתבצע ע"י שיטה רקורסיבית שקוראת לשיטה על ]‪ pred[v‬ואז מדפיסה את ‪.v‬‬

‫‪3‬‬
 ‫זמן ריצה ‪ +‬הסבר‬
‫)‪ .O(V+E‬הסבר‪ :‬הלולאה החיצונית ביותר עוברת על כל קודקוד‪,‬‬
‫למקרה שכל קודקוד נמצא ברכיב קשירות אחר‪ .‬מכל קודקוד‬
‫סורקים את כל המסלולים האפשריים‪ ,‬סה"כ |‪.2|E‬‬
‫החישוב הוא בהנחה שייצוג הגרף נעשה ע"י רשימת שכנויות‪.‬‬
‫הבדל בין קשת חוצה לקשת קדימה‪ :‬בקשת חוצה‪ ,‬לקודקוד אליו הגענו תהיה חותמת זמן סגירה קטנה מחותמת‬
‫כמו ‪DFS‬‬
‫הסבר האלגוריתם‪ :‬מפעילים את ‪ ,DFS‬אך בכל השחרה של קודקוד‪ ,‬מצרפים קודקוד זה בראש רשימה מקושרת‬
‫בהינתן גרף‪ ,‬האלגוריתם הבסיסי למציאת ‪ MST‬יבנה סדרה ריקה ‪ A‬של צלעות ה‪ MST-‬ויוסיף בכל שלב צלע לסדרה אם"ם צלע זו היא "צלע בטוחה"‪" .‬צלע בטוחה" היא כזו שלא סוגרת מעגל עם שאר‬
‫זמן ריצה‪:‬‬
‫בניית הקבוצות הזרות – )‪ .O(V‬מיון הצלעות‪.O(ElogE) :‬‬
‫בניית העץ – עוברים פעם אחת על כל צלע‪ ,‬כלומר ‪ ,E‬ועל כל צלע‬
‫שאנו רוצים להוסיף לעץ עלינו לחבר בין שתי קבוצות זרות דרך‬
‫‪ ,union-find‬כלומר בזמן ריצה ממוצע של ‪O(ElogV) – .logv‬‬
‫סה"כ‪O((V E log E E log V ) :‬‬
‫‪ |E|>|V|-1‬ובנוסף )‪) O(loge)=O(logV‬משיקולים מתמטיים( ולכן‬
‫ניתן לרשום סה"כ‪:‬‬
‫) ‪O( E log V‬‬
‫‪4‬‬
‫הסבר‬ ‫שם האלגוריתם‬
‫סריקה לעומק‪ :‬יוצאים מנקודה מסוימת ומנסים להגיע הכי "עמוק" שניתן‪.‬‬
‫האלגוריתם מתחיל את החיפוש מצומת שרירותי בגרף ומתקדם לאורך הגרף )עפ"י סדר השכנים ברשימת‬
‫השכנויות( עד שנתקע‪ .‬לאחר מכן חוזר על עקבותיו ) ‪ (backtracking‬עד שהוא יכול לבחור דרך אלטרנטיבית‬
‫להתקדמות‪ .‬כאשר עבר על כל הדרכים האפשריות ברכיב קשירות זה‪ ,‬מגריל קודקוד חדש שטרם עברו בו‪.‬‬
‫אלגוריתם זה‪ ,‬בניגוד לקודם‪ ,‬עובר על כל קודקודי ‪.G‬‬
‫האלגוריתם מגלה מעגלים‪ ,‬מצייר את הגרף כיער עצים‪ ,‬מאפשר מיון טופולוגי )בהמשך(‪.‬‬
‫שדות שמעודכנים במהלך ריצת האלגוריתם בכל אחד מהקודקודים‪:‬‬
‫]‪" – d[v‬חותמת זמן" – הגעה לקודקוד‪.‬‬
‫]‪" – f[v‬חותמת זמן" – סיום טיפול בקודקוד‪.‬‬
‫)מתקיים‪( 1 d [v] f [v] 2 | V | :‬‬
‫] ‪ - [v‬שומר את הקודקוד ממנו הגענו ל‪ .v -‬ה‪.predecessor-‬‬ ‫‪DFS‬‬
‫לכל קודקוד יש גם צבע‪ :‬לבן = קודקוד שטרם גילינו‪ ,‬אפור = קודקוד שגילינו אבל לא סיימנו לבדוק את כל‬
‫הדרכים היוצאות ממנו‪ ,‬שחור = גילינו וסיימנו לעבור על שכניו‪.‬‬
‫מיון צלעות‪:‬‬
‫‪ – Tree edge‬קשת המרכיבה את אחד העצים ביער‪ ,‬כלומר קשת שבה "גילינו" קודקוד חדש‪.‬‬
‫קשת אחורה – ‪ – back edge‬קשת שמגלה מעגל‪ ,‬כלומר קשת מצאצא לאחד מאבותיו הקדמונים‪.‬‬
‫צלעות נוספות‪ ,‬מופיעות רק בגרפים מכוונים‪:‬‬
‫קשת קדימה – ‪ - forward edge‬קשת מאב קדמון לצאצא שכבר גילינו קודם לכן‪.‬‬
‫קשת חוצה – ‪ – cross edge‬כל צלע אחרת‪ ,‬לרוב מחברת בין שני עצים ביער‪.‬‬
‫זמן הפתיחה של הקודקוד ממנו יצאנו‪.‬‬
‫משפט‪ :‬קשת אחורה מורה על מעגל והפוך‪.‬‬
‫זהו מיון המבוסס על ‪ DFS‬כאשר הגרף שניתן כקלט הוא גרף מכוון ללא מעגלים – ‪.DAG‬‬
‫מיון זה יוצר סידור ליניארי של הקודקודים כך שאם גרף מכיל קשת )‪ (u,v‬אזי ‪ u‬נמצא בסידור לפני ‪.v‬‬
‫לכל גרף יש יותר מסדר טופולוגי יחיד‪ ,‬הדבר תלוי בקודקוד ממנו התחלנו ב‪.DFS -‬‬
‫מיון טופולוגי‬
‫נפרדת‪ .‬הרשימה שתתקבל בסוף היא רשימת הקודקודים הממוינת‪ .‬או‪ :‬לאחר הפעלת ‪ DFS‬מסדרים את כל‬
‫הקודקודים בשורה לפי השדה ]‪ f[v‬בסדר יורד‪.‬‬
‫הצלעות בסדרה‪ ,‬כלומר גם אחרי הוספתה‪ ,‬הצלעות ב‪ A-‬מהוות תת‪-‬גרף של ‪.MST‬‬ ‫‪GenericMST‬‬
‫נועד לגרף ממושקל לא מכוון וקשיר‪ .‬מוצא עץ פורש מינימלי‪.‬‬
‫זהו אלגוריתם חמדן‪ ,‬כלומר כזה המבצע בכל שלב את מה שנראה "טוב ביותר" עבורו בטווח הקצר‪.‬‬
‫באלגוריתם זה‪ ,‬בכל שלב מוכלים ב‪ A -‬כל צלעות תת‪-‬הגרף של ה‪ ,MST -‬כלומר יער של עצים‪ .‬בהתחלה ‪ A‬ריקה –‬
‫כל קודקוד מהווה "עץ" בפני עצמו‪ .‬בכל שלב בלולאה מוצאים "צלע בטוחה" ומצרפים ל ‪ ,A‬עד ש‪ A‬הופכת ל‪.MST‬‬
‫מימוש האלגוריתם נעשה ע"י שימוש בקבוצות זרות – ‪ ,union find‬כל קבוצה מכילה קודקוד‪.‬‬ ‫האלגוריתם של‬
‫מציאת צלע בטוחה‪ :‬ממיינים את הצלעות לפי משקלן‪ ,‬זה סדר סריקתן בלולאה‪ .‬לגבי כל צלע בודקים אם‬ ‫קרוסקל‬
‫קודקודיה נמצאים בקבוצות זרות‪ .‬אם כן – מצרפים אותה‪ .‬אם לא – ממשיכים הלאה‪ .‬מפסיקים כאשר סיימנו‬
‫לסרוק את הצלעות‪.‬‬
 ‫אלגוריתם חמדן גם כן‪ .‬מוצא עץ פורש מינימלי בגרף ממושקל קשיר )לא מכוון(‪.‬‬
‫זמן ריצה‪:‬‬ ‫‪ A‬מהווה עץ בכל שלב‪ .‬נתייחס לכל הקודקודים המופיעים ב‪ A -‬כחלק מ"ענן" אחד‪.‬‬
‫אתחול והכנסה לתור עדיפות‪) .O(V) :‬רק כי אנחנו כבר יודעים‬ ‫מתחילים בקודקוד רנדומאלי כלשהו ומצרפים ל ‪ A‬בכל שלב את הצלע הקלה ביותר שמחברת בין הענן לבין שאר‬
‫שכל המפתחות שוות אינסוף(‪.‬‬ ‫הגרף מחוצה לו‪.‬‬
‫עידכון מפתח השורש‪.O(logV) :‬‬ ‫מימוש‪:‬‬
‫נשתמש בתור עדיפויות עבור הקודקודים מחוץ לענן‪.‬‬
‫בניית ‪– MST‬‬
‫=]‪ key[v‬כאשר אין צלע‬ ‫לכל קודקוד יהיה שדה ‪ key‬ובו המשקל המינימלי של צלע המחברת בינו לבין הענן‪.‬‬
‫הוצאת קודקוד מינימלי בכל פעם – ‪V‬קודקודים‪ logV ,‬עלות‬ ‫האלגוריתם של‬
‫ישירה מ‪ v‬לענן‪ .‬אם המפתח אינו ‪ ,0‬סימן שיש צלע כלשהי שמחברת ישירות בין הענן לקודקוד הזה‪.‬‬
‫עידכון ‪.O(VlogV) -‬‬ ‫פרים‬
‫תחילה – נאתחל את כל ערכי ‪ key‬באינסוף‪ ,‬מלבד קודקוד השורש שהוגרל‪ ,‬ונכניסם לתור עדיפויות )נניח שימוש‬
‫עידכון שדות השכנים – על כל צלע עוברים פעם אחת )סה"כ ‪(E‬‬ ‫בערימה בינארית(‪.‬‬
‫ועדכון המפתח שלו בערימה לוקח ‪O(ElogV) .logV‬‬ ‫כל עוד יש קודקודים בתור – נוציא את הקודקוד שמפתחו מינימלי ) ‪ (extractMin‬ונצרף ל‪ .A‬נעבור על כל שכניו‬
‫סה"כ )משיקולים דומים לשיקולים בפרים(‪:‬‬
‫של קודקוד זה ונעדכן את ערכי המפתח ‪ key‬שלהם‪ ,‬רק בהנחה שמשקל הצלע הנבדקת קטן מהמפתח שהיה שם‬
‫) ‪O( E log V‬‬ ‫קודם‪.‬‬
‫בסוף התהליך נקבל עץ פורש מינימלי‪.‬‬
‫***אלגוריתם זה כמעט זהה לאלגוריתם דייקסטרה***‬
‫אלגוריתם למציאת המסלול הקצר ביותר מקודקוד מקור כלשהו לשאר הקודקודים‪.‬‬
‫האלגוריתם עובד על גרפים מכוונים או לא מכוונים בעלי משקולות אי‪-‬שליליות‪ w(u,f) .‬היא פונקצית המשקל‬
‫של הגרף‪.‬‬
‫רעיון‪:‬‬
‫נשמור בכל רגע קבוצת קודקודים מהגרף‪ ,S ,‬נתייחס אליהם כאל "ענן" קודקודים שבכולם כבר חישבנו את‬
‫המסלול הקצר ביותר‪.‬‬
‫מימוש‪:‬‬
‫נשתמש בתור עדיפויות עבור הקודקודים מחוץ לענן‪.‬‬
‫לכל קודקוד ‪ v‬יהיה שדה ]‪ d[v‬ובו המשקל המינימלי של מסלול בינו לבין קודקוד המקור ‪ d[v]= .s‬כאשר אין‬
‫האלגוריתם של‬
‫חישוב זהה לאלגוריתם פרים‬ ‫מסלול מ‪ v‬ל‪ s‬או שמסלול זה טרם נתגלה‪ .‬בנוסף יהיה שדה ]‪ π[v‬ובו נשמור את ה"אבא" של כל קודקוד )כלומר‬ ‫דייקסטרה‬
‫הקודקוד ממנו הגענו ל‪ v -‬השייך למסלול הקל ביותר(‪.‬‬ ‫)לא למבחן(‬
‫=]‪ ,d[v‬מלבד קודקוד השורש שהוגרל ) ]‪ d[s‬מאותחל ב‪ ,(0-‬ונכניסם לתור‬ ‫תחילה – נאתחל את כל ערכי‬
‫עדיפויות )נניח שימוש בערימה בינארית(‪.‬‬
‫כל עוד יש קודקודים בתור – נוציא את הקודקוד שמפתחו מינימלי ) ‪ (extractMin‬ונצרף לענן ‪ .S‬נעבור על כל‬
‫שכניו של קודקוד זה ונעדכן את ערכיהם באופן הבא‪ .if(d[u]>d[v]+w(u,v)) then d[u] d[v]+ w(u,v) :‬כלומר‪,‬‬
‫אם המסלול שמצאנו עכשיו טוב יותר מכל מסלול שמצאנו עד כה‪ ,‬נעדכן את השדה למשקל המסלול החדש‪,‬‬
‫ונעדכן את האבא‪ ,π[u] ,‬גם כן‪.‬‬
‫בסופו של התהליך יכיל כל קודקוד בגרף שדה ובו המסלול ה"קל" ביותר מ‪ s -‬עד אליו ומצביע לקודקוד הקודם‬
‫לו במסלול זה‪.‬‬

‫‪5‬‬

‫הערות חשובות ווריאציות של המבנה‬
‫וריאציה נוספת – רשימה מקושרת דו‬
‫כיוונית – בה לכל איבר יש מצביע לזה‬
‫שאחריו ולה שלפניו‪.‬‬
‫רשימה מעגלית – הסוף מחובר להתחלה‪.‬‬
‫ניתן למימוש או בעזרת מערך או בעזרת‬
‫רשימה מקושרת‪ .‬זמני הריצה נותרים‬
‫זהים‪.‬‬
‫במימוש בעזרת מערך נתייחס למערך כאל‬
‫רשימה מעגלית‪ ,‬כלומר כשהתור מגיע‬
‫לסוף המערך מתחילים למלא אותו‬
‫מראשיתו‪ ,‬כל עוד נשמר התנאי שהתור לא‬
‫יכיל יותר מגודל המערך פחות אחד‪.‬‬
‫ניתן למימוש או בעזרת מערך או בעזרת‬
‫רשימה מקושרת‪.‬‬
‫פעולה מיוחדת‪ – multi-pop :‬מרוקנת את‬
‫כל תכולת המחסנית‪ .‬בחישוב של ניתוח‬
‫פחת‪ ,‬עבור מחסנית בעלת הפעולות ‪push,‬‬
‫‪ pop, multi-pop‬זמן הריצה הממוצע‬
‫לפעולה הוא )‪.O(1‬‬
‫‪6‬‬
‫‪ .3‬מבנים ושונות‪:‬‬
‫תיאור פעולות עיקריות‪ /‬מבנה אלגוריתם ומשתניו‪ /‬זמני ריצה‬ ‫ייצוג גרפי ‪+‬הערות‬ ‫הסבר כללי‬ ‫שם מבנה‬
‫)‪ – Create(list‬יצירת רשימה ריקה‪O(1) .‬‬
‫)‪ – Search(k,list‬מוצאת את האיבר הראשון ברשימה עם מפתח ‪ O(n) .k‬במקרה‬
‫הגרוע‪.‬‬ ‫‪ADT‬‬
‫סדרת אובייקטים המחוברים ע"י‬
‫)‪ – Insert(item, list‬מכניס איבר ספציפי לראש הרשימה‪.O(1) .‬‬ ‫מצביעים‪.‬‬ ‫רשימה‬
‫מקושרת‬
‫)‪ – Delete(item,list‬מוחק איבר ספציפי מהרשימה ומחבר בין זה שלפניו לזה‬
‫שאחריו‪ O(n) .‬במקרה הגרוע‪.‬‬
‫)‪ – Create(Q‬יצירת תור ריק ‪.Q‬‬
‫‪ADT‬‬
‫)‪ – IsEmpty(Q‬מחזיר ערך בוליאני האם התור ריק‪.‬‬ ‫מבני נתונים אבסטרקטי המתנהג כתור‬
‫רשימה‪/‬מערך‬ ‫ממתינים‪ :‬הראשון שנכנס הוא הראשון‬ ‫תור ‪-‬‬
‫)‪ – enqueue(Q,item‬מכניס את האיבר ‪ item‬לסוף התור‪.‬‬ ‫לצאת )‪.(FIFO‬‬
‫‪Queue‬‬
‫)‪ – dequeue(Q‬מוחק ומוציא את האיבר ה"ישן" ביותר בתור‪.‬‬
‫)‪ – Create(S‬יצירת מחסנית ריקה ‪.S‬‬
‫‪ADT‬‬
‫)‪ – IsEmpty(S‬מחזיר ערך בוליאני האם המחסנית ריקה‪.‬‬ ‫מבנה נתונים אבסטרקטי המתנהג‬
‫רשימה‪/‬מערך‬ ‫כמחסנית‪ :‬האחרון שנכנס הוא הראשון‬ ‫מחסנית‪-‬‬
‫)‪ – Push(S,item‬דוחף את האיבר ‪ item‬לראש המחסנית‪.‬‬ ‫שיוצא )‪.(LIFO‬‬ ‫‪Stack‬‬
‫)‪ – Pop(S‬מוציא מהמחסנית את האיבר האחרון שהוכנס לתוכו ומחזירו‪.‬‬
 ‫הערות חשובות ווריאציות של המבנה‬ ‫תיאור פעולות עיקריות‪ /‬מבנה אלגוריתם ומשתניו‬ ‫ייצוג גרפי ‪+‬הערות‬ ‫הסבר כללי‬ ‫שם מבנה‬

‫נסמן ב‪ h-‬את גובה העץ‪ .‬במקרה הטוב‪ ,‬ובמקרה הממוצע )‪) h=O(logn‬לפי משפט(‪.‬‬
‫במקרה הגרוע )‪.h=O(n‬‬ ‫עץ = מבנה היררכי בו לקודקודים יש‬
‫יחסי אב‪-‬בן‪.‬‬
‫)‪ – Search(T,k‬חיפוש מפתח ‪ k‬בעץ ‪ .O(h) .T‬ניתן לממש רקורסיבית או‬
‫איטרטיבית‪.‬‬ ‫מושגים )חלק(‪ :‬עומק = מס' קשתות‬
‫משורש לקודקוד מסוים‪ .‬דרגה של‬
‫)‪ – Minimum/maximum(x‬חיפוש מפתח מקסימלי‪/‬מינימלי בתת העץ המושרש‬ ‫צומת = מספר הבנים‪ .‬גובה = מס'‬
‫קיימות ‪ 3‬סריקות של איברי עץ חיפוש‬ ‫ב‪ .x-‬זמן ריצה‪.O(h) :‬‬ ‫קשתות מקודקוד מסוים לעלה שהוא‬
‫בינארי‪:‬‬ ‫הצאצא הכי רחוק ממנו‪ .‬גובה עץ ריק‬
‫)‪ – Insert(T,x‬הכנסת איבר ‪ x‬לעץ‪ .‬זמן ריצה‪.O(h) :‬‬ ‫מוגדר )‪ .(-1‬עץ בינארי = עץ בו לכל‬
‫‪ – Inorder‬בן שמאלי‪ ,‬אני‪ ,‬בן ימני‪.‬‬ ‫עץ‬ ‫צומת יש לכל היותר ‪ 2‬בנים‪ .‬עץ בינארי‬ ‫עצי חיפוש‬
‫)‪ – Delete(T,x‬מחיקת איבר ‪ x‬לעץ‪ .‬זמן ריצה‪ .O(h) :‬תיאור אלגוריתם‪ :‬תחילה‬ ‫מלא = עץ בו לכל צומת יש ‪ 2‬או ‪ 0‬בנים‪.‬‬ ‫בינאריים‬
‫‪ – Preorder‬אני‪ ,‬בן שמאלי‪ ,‬בן ימני‪.‬‬ ‫מוצאים את ‪ x‬בעזרת ‪ .search‬אם ‪ x‬הוא עלה – פשוט מוחקים‪ .‬אם ל‪ x‬בן יחיד –‬ ‫עץ בינארי מושלם = לכל העלים אותו‬
‫פשוט מעבירים את המצביע מאביו של ‪ x‬אל אותו בן יחיד‪ .‬אם ל‪ x -‬שני בנים‪ :‬נמצא‬ ‫עומק‪.‬‬
‫‪ – Postorder‬בן שמאלי‪ ,‬בן ימני‪ ,‬אני‪.‬‬
‫את הקודקוד המינימלי בתת העץ הימני של ‪ x‬ונחליף ביניהם‪ ,‬ואז נמחק את ‪x‬‬ ‫עץ חיפוש בינארי מקיים תנאי נוסף‪:‬‬
‫)בוודאות לא יהיו לו שני בנים ולכן המחיקה תהיה פשוטה(‪.‬‬ ‫לכל קודקוד‪ ,‬המפתח של בנו הימני גדול‬
‫משלו והמפתח של בנו השמאלי קטן‬
‫)‪ – Successor/predecessor(T,x‬מציאת האיבר העוקב‪/‬קודם לקודקוד ‪ .x‬תיאור‬ ‫משלו‪.‬‬
‫אלגוריתם‪ :‬אם הבן הימני קיים‪ ,‬קוראים לפונקציית מציאת מינימום על תת העץ‬
‫המושרש בבן הימני‪ .‬אם לא – מחפשים את האב הקדמון הקרוב ביותר כך ש‪x -‬‬ ‫עץ זה משמש למימוש מילון דינאמי‪.‬‬
‫נמצא בתת העץ המושרש משמאלו‪ .‬סה"כ – )‪.O(h‬‬

‫‪ – Insert‬הכנסה מתבצעת כמו בעץ חיפוש בינארי רגיל‪ ,‬עם תוספת‪ :‬לאחר‬
‫שהקודקוד החדש מוכנס‪ ,‬עולים חזרה למעלה עד השורש ובמידה ומוצאים קודקוד‬
‫לא מאוזן מבצעים רוטציה יחידה‪ .‬הרוטציות יכולות להיות מ‪ 4 -‬צורות‪right, :‬‬
‫‪ ,left, right-left, left-right‬לפי המצב בעץ‪.‬‬
‫זהו עץ חיפוש בינארי בעל תכונה נוספת‪:‬‬
‫זמן ריצה)הכנסה(‪ :‬חיפוש רגיל – )‪ ,O(logn‬טיפוס חזרה עד השורש – )‪,O(logn‬‬ ‫לכל קודקוד בצומת מתקיים שגובה הבן‬
‫תיקון במידה ונדרש – )‪ .O(1‬סה"כ‪.O(logn) :‬‬ ‫כל צומת בעץ מחזיק‬ ‫הימני וגובה הבן השמאלי נבדלים ב ‪1‬‬
‫שדה נוסף –‬ ‫לכל היותר‪.‬‬
‫‪ – Delete‬מתבצע כמו בעץ חיפוש בינארי רגיל רק שגם הפעם נצטרך לעלות חזרה‬ ‫‪AVL-tree‬‬
‫עד השורש ולבצע רוטציות מתקנות בכל צומת בו התגלה חוסר איזון‪ .‬בניגוד‬ ‫גובה תת העץ המושרש‬ ‫משפט‪ :‬גובה של ‪ AVL‬בעל ‪ n‬צמתים‬
‫להכנסה‪ ,‬במחיקה ייתכן ונצטרך לבצע יותר מרוטציה אחת בדרך חזרה לשורש‪.‬‬ ‫בצומת זו‪.‬‬ ‫הוא )‪.O(logn‬‬
‫במקרה הגרוע ביותר נצטרך לתקן כל שלב ושלב בדרך לשורש‪.‬‬
‫זמן ריצה)מחיקה(‪ :‬מחיקה רגילה – )‪ ,O(logn‬טיפוס חזרה עד השורש – )‪O(logn‬‬
‫ותיקון בכל שלב אם נחוץ – )‪ .O(1‬סה"כ‪.O(logn) :‬‬
‫‪ – Search‬כמו בעץ חיפוש רגיל‪.O(logn) .‬‬

‫‪7‬‬
 ‫הערות חשובות‬
‫הערה – בחירת פונקציית ‪– hash‬‬
‫יש שתי שיטות עיקריות‪:‬‬
‫בממוצע )‪ ,O(1+α/2‬כלומר )‪ O(1+α‬גם כן‪) .‬מכאן‬
‫שיטת החילוק –‬
‫‪h(k ) k mod m‬‬
‫)יעבוד טוב עבור ‪ m‬ראשוני‬
‫שרחוק ככל הניתן מחזקה של ‪.(2‬‬
‫שיטת הכפל –‬
‫) ‪h(k‬‬ ‫])‪floor[m (kA mod1‬‬
‫כאשר ‪ A‬בין ‪ 0‬ל‪) .1-‬שיטה זו‬
‫איטית יותר אך ערך ‪ m‬כאן אינו‬
‫קריטי ואף יעיל כאשר ‪.(m=2^p‬‬
‫בחירת פונקציית הצעד‪ :‬צריך‬
‫שלא תהיה בעלת מחלק משותף‬
‫עם ‪ .m‬בפרט‪ ,‬אם ‪ m‬זוגי עליה‬
‫להיות אי‪-‬זוגית‪.‬‬
‫‪----‬‬
‫יתרונו הגדול של מבנה זה הוא אך‬
‫ורק במקרה הממוצע ‪ ,‬תחת הנחת‬
‫הגיבוב האחיד‪) .‬בשרשור למשל‪,‬‬
‫במקרה הגרוע ביותר החיפוש‬
‫יעלה לנו ‪.(O(n‬‬
‫‪----‬‬
‫‪O‬‬
‫וריאציה לצורך הקטנת‬
‫ההסתברות ליפול באותו התא‪:‬‬
‫עבודה עם מס' טבלאות זהות‬
‫בגודלן במקביל‪ ,‬לכל טבלה‬
‫פונקציה משלה‪ .‬איבר קיים אך‬
‫ורק אם הוא נמצא בכל אחת‬
‫מהטבלאות‪.‬‬
‫‪8‬‬
‫תיאור פעולות עיקריות‪ /‬מבנה אלגוריתם ומשתניו‬ ‫ייצוג גרפי ‪+‬הערות‬
‫)‪ – Search(T,k‬נחפש את מפתח ‪ k‬ברשימה‬
‫המקושרת שב‪ .T[h(k)]-‬חיפוש לא מוצלח יצרוך‬
‫זמן ריצה של )‪ .O(1+α‬חיפוש מוצלח יצרוך‬
‫שאם )‪ n=O(m‬אזי זמן הריצה הוא קבוע )‪.O(1‬‬
‫מערך באורך ‪ m‬שכל‬
‫)‪ – Insert(T,k‬מכניס את איבר ‪ x‬בראש הרשימה‬
‫שבתא ])‪ .T[h(x.key‬זמן ריצה‪.O(1) :‬‬
‫)‪ – Delete(T,k‬מחיקת האיבר ‪ x‬מהרשימה שבתא‬
‫])‪ .T[h(x.key‬זהה לזמני חיפוש‪.‬‬
‫)‪– Search(T,k‬‬
‫‪1‬‬
‫‪O‬‬ ‫חיפוש לא מוצלח ייקח בממוצע‬
‫‪1‬‬
‫וחיפוש מוצלח ייקח בממוצע‬
‫‪1‬‬ ‫‪1‬‬
‫‪.O 1‬‬ ‫‪ln‬‬
‫‪1‬‬
‫‪1‬‬
‫)‪ – Insert(T,k‬זמן ריצה בממוצע‪:‬‬
‫‪1‬‬
‫הסבר כללי‬ ‫שם מבנה‬
‫טבלאות גיבוב נועדו לאפשר מערך דינאמי בעל הפעולות‪ :‬הכנסה‪ ,‬חיפוש ומחיקה‪,‬‬
‫כאשר טווח ערכי המפתחות גדול בהרבה ממספר המפתחות הנתונים‪ .‬נתייחס‬
‫למפתחות כאל מספרים טבעיים‪ .‬הנחה מקדימה‪ :‬כל המפתחות שונים זה מזה‪.‬‬
‫פונקציית ה‪ ,hash -‬נסמנה ב‪ ,h -‬תיקח כל מספר טבעי ותצמיד לו ערך בטווח‬
‫‪Chaining‬‬
‫המערך‪ ,‬כלומר מ‪ 0-‬עד ‪ m-1‬שהגדרנו‪ .‬זאת ב‪ .O(1) -‬הבעיה‪ :‬מפתחות שונים עלולים‬
‫‪ (chaining‬ו‪open -‬‬ ‫לקבל אותו ערך ) ‪ h‬איננה חח"ע(‪ .‬שני פתרונות‪ :‬שירשור )‬
‫תא בו הוא רשימה‬ ‫‪.addressing‬‬
‫מקושרת‪.‬‬
‫מבנה זה נותן זמני ריצה טובים ב ממוצע‪ ,‬כאשר מתקיימת הנחת הגיבוב האחיד‬
‫)ההסתברות ליפול בתא כלשהו במערך שווה ל‪.(1/m -‬‬
‫חישוב זמני הריצה נעזר ב"מקדם העומס"‪ .‬מקדם העומס זהו ממוצע באיברים לכל‬
‫‪.‬‬ ‫תא‪ ,‬כלומר‪n :‬‬
‫‪m‬‬
‫‪ :Chaining‬מכניס לתא ‪ i‬במערך את כל המפתחות שקיבלו את הערך ‪ i‬בפונקציה‬
‫ושומר אותם כרשימה מקושרת‪.‬‬
‫‪ :Open addressing‬הרעיון הוא שאם התא אליו איבר מסוים נשלח ע"י ‪ h‬תפוס‬
‫כבר‪ ,‬האיבר יוכוון לתא אחר‪ .‬במילים אחרות הפונקציה תקבל גם את המפתח וגם‬
‫את מספר הבדיקה ותיתן כל פעם אינדקס אחר במערך‪ ,‬באחת משלושת דרכים‬ ‫‪Hash-‬‬
‫אלו‪:‬‬
‫‪tables‬‬
‫‪ – linear probing‬התקדמות ליניארית לתא הבא במערך עד שמגיעים לתא‬ ‫‪.1‬‬
‫ריק‪ .‬שיטה פשוטה אך יוצרת גושים‪ .‬פרמוטציות אפשריות להצעות‬
‫למיקומים‪.O(m) :‬‬
‫‪ – quadratic probing‬התקדמות בקפיצה קבועה‪ ,‬למשל‪:‬‬ ‫‪.2‬‬
‫‪Open addressing‬‬ ‫‪2‬‬
‫‪ . h(k , i) (h '(k ) c1i c2i ) mod m‬כאשר ‪ i‬מייצג את מספר‬
‫מערך באורך ‪m‬‬ ‫הקפיצות שביצענו )כלומר מספר הפעמים שהגענו לתא שהיה כבר מלא( ו‪-‬‬
‫‪ c1,c2‬קבועים‪ .‬פועל מעט טוב יותר מהקודם‪ .‬אותו סדר גודל של פרמוטציות‬
‫אפשריות‪.‬‬
‫‪ – double hashing‬משלבים בין שתי פונקציות ‪:hash‬‬ ‫‪.3‬‬
‫‪ . h(k , i) (h1 (k ) i h2 (k )) mod m‬את הפונקציה השנייה נכנה‬
‫"פונקציית הצעד"‪ .‬כך‪ ,‬שני מפתחות שקיבלו אותו ערך‪ ,‬יוכלו לקבל צעדים‬
‫שונים במידה ומיקום זה במערך כבר תפוס‪ .‬פרמוטציות‪ ,O(m^2) :‬כלומר‬
‫הסיכוי להיווצרות גושים קטן‪.‬‬
‫זוהי שיטה עדיפה כאשר אין צורך במחיקה‪ .‬זמן הריצה של מחיקה בשיטה זו לא‬
‫יהיה תלוי במקדם העומס ‪ .α‬אם נרצה להוסיף אפשרות מחיקה נוסיף "דגל" בשם‬
‫"‪ "deleted‬שיסמן לנו מאיפה מחקנו בעבר איבר‪ .‬בנוסף המקום בזיכרון מנוצל‬
‫באופן "חסכוני" יותר‪.‬‬
 ‫הערות חשובות‬
‫באמצעות קוד הופמן ניתן לחסוך ‪20-‬‬
‫‪ 90%‬מקום בזיכרון‪.‬‬
‫טענה‪ :‬כאשר הקוד הוא אופטימלי‪,‬‬
‫העץ יהיה עץ מלא‪ .‬כלומר‪ ,‬לכל צומת‬
‫שאינו עלה יהיו בדיוק שני בנים‪.‬‬
‫לדוגמה‪ ,‬נניח כי בקוד כלשהו לשורש‬
‫של העץ יש רק בן אחד‪ ,‬שאליו‬
‫מובילה הקשת ‪ .0‬פירוש הדבר הוא‬
‫שבקוד לא יהיו כלל אותיות שקידודן‬
‫מתחיל ב‪ ,1-‬וזהו כמובן בזבוז של‬
‫מקום )כי אפשר היה‪ ,‬לכל הפחות‪,‬‬
‫לתת לאות כלשהי את הקידוד " ‪,"1‬‬
‫ובכך לחסוך במקום (‪.‬‬
‫‪ -‬משפט‪ :‬גובה העץ‪ ,h ,‬חסום ע"י‬
‫‪n 1‬‬
‫‪ . h‬כאשר ‪ n‬מספר‬ ‫‪logt‬‬
‫‪2‬‬
‫המפתחות סה"כ בעץ‪.‬‬
‫‪ -‬שורש העץ תמיד ישמר בזיכרון הראשי‬
‫כדי שקריאתו לא תצריך ‪.disk-read‬‬
‫‪9‬‬
‫תיאור פעולות עיקריות‪ /‬מבנה אלגוריתם ומשתניו‬ ‫ייצוג גרפי ‪+‬הערות‬ ‫הסבר כללי‬ ‫שם מבנה‬
‫‪-‬‬ ‫‪ = C‬סדרה של ‪ n‬תווים‪.‬‬ ‫עץ בינארי‪ .‬כל קודקוד‬ ‫קוד הופמן הוא שיטה לדחיסת נתונים‬
‫מכיל את סך‬ ‫ע"י הצגת סימנים נפוצים באמצעות‬
‫‪-‬‬ ‫)‪ = f(c‬השכיחות של התו ‪.c‬‬ ‫השכיחויות של העלים‬ ‫מספר סיביות קטן לעומת סימנים‬
‫תחתיו )ומייצג ‪ 0‬או ‪.(1‬‬ ‫נדירים במספר סיביות גדול יותר‪.‬‬
‫)‪ = d(c‬עומק העלה ‪ c‬בעץ‪ = .‬אורך קידוד התו‪.‬‬ ‫כל עלה מייצג תו‬
‫ומכיל את שכיחות תו‬ ‫הקוד הוא "קוד תחיליות"‪prefix- -‬‬
‫האלגוריתם של הופמן בונה "עץ" המייצג את הקידוד‪:‬‬ ‫זה בטקסט‪/‬קלט‬ ‫‪Huffman‬‬
‫‪ ,code‬כלומר כל מחרוזת ביטים‬
‫הנתון‪.‬‬ ‫‪code‬‬
‫מתחילים מתחתית העץ‪ ,‬כל עלה הוא תו‪ .‬מכניסים לערימת מינימום את כל סדרת‬ ‫שמייצגת אות‪ ,‬איננה יכולה להיות‬
‫התווים ושכיחויותיהם‪ .‬מושכים מהערימה את שתי השכיחויות המינימליות‪.‬‬ ‫ה"דרך" לתו מסוים‬ ‫תחילית של מחרוזת ביטים אחרת‪.‬‬
‫יוצרים קודקוד חדש שהוא סכום שני הקודקודים שהוצאנו ומכניסים אותו‬ ‫הוא הקידוד שלו‪.‬‬
‫לערימה‪ .‬מבצעים את הלולאה עד שנשאר איבר אחד בערימה – הוא שורש העץ‪.‬‬ ‫משמעות‪ :‬פענוח הקוד הוא חד‪-‬ערכי‪.‬‬
‫ניתן לממש בעזרת‬
‫זמן ריצת האלגוריתם‪O(nlogn) :‬‬ ‫מערך‪.‬‬
‫]‪ – Leaf[x‬שיטה החזירה ערך בוליאני‪ .‬אמת – אם הצומת הוא עלה‪ ,‬שקר – אחרת‪.‬‬
‫)‪ – Search(x,k‬החיפוש יתחיל מקודקוד ‪) ,x‬או מהשורש( ויסרוק את המפתחות‬ ‫זהו מבנה המבוסס על עץ ונועד לצמצם‬
‫עץ‪.‬‬ ‫את מספר הפניות לדיסק החיצוני כאשר‬
‫שבקודקוד עד מציאת ‪ k‬או עד הגעה לערך הגדול מ‪ .k -‬לפי הסריקה – או‬ ‫בסיס הנתונים גדול מדי‪) .‬כלומר לקרוא‬
‫שמחזירים את המיקום הרלוונטי‪ ,‬או שקוראים לשיטה רקורסיבית על הקודקוד‬ ‫]‪ – n[x‬מס' המפתחות‬ ‫כמה שיותר מהדיסק בבת אחת במקום‬
‫אליו יש הצבעה לפני המפתח שגדול מ ‪ ,k‬או שמחזירים ‪ null‬אם ‪ k‬לא נמצא‪ .‬זמן‬ ‫שבכל צומת של העץ‪.‬‬ ‫לגשת אל הדיסק כמה פעמים(‪.‬‬
‫המפתחות עצמם‬
‫ריצה‪ .O(t*h) = O(tlogn) :‬מס' גישות לדיסק‪.O(h) = O(logn) :‬‬
‫ממוינים מקטן לגדול‬ ‫הדבר נעשה ע"י דחיסת כמה שיותר‬
‫ומצביעים מוחזקים‬ ‫מפתחות ומצביעים בקודקוד יחיד‪.‬‬
‫‪ – Create‬יוצר עץ ריק ב‪ O(1) -‬זמן ריצה וגישות לדיסק‪.‬‬
‫לפני ואחרי כל מפתח‪.‬‬
‫לכל עץ קיים קבוע ‪ t>=2‬שלפיו נקבעים‬ ‫‪B-tree‬‬
‫)‪ – splitChild(x,I,y‬פונקציית עזר שמפצלת את הקודקוד ‪ y‬המלא‪ ,‬שהוא בנו של ‪.x‬‬
‫בעץ בעל ]‪ n[x‬מפתחות‬ ‫החסמים העליונים והתחתונים למספר‬
‫‪ i‬הוא אינדקס הבן‪ .‬זמן ריצה‪.O(t) :‬‬
‫מוחזקים )‪(n[x]+1‬‬ ‫המפתחות בצומת‪ :‬כל איבר מלבד‬
‫)‪ – Insert(t,k‬מתחילים מהשורש ויורדים למטה‪ .‬כל קודקוד שמכיל מקסימום‬ ‫מצביעים‪c1[x], :‬‬ ‫השורש יכיל לפחות )‪ (t-1‬מפתחות ולכל‬
‫מפתחות )‪ (2t-1‬מפוצל לשניים על ידי העברת המפתח האמצעי לאביו )לשם כך יש‬ ‫…‪.c2[x],  ‬‬ ‫היותר )‪ (2t-1‬מפתחות‪.‬‬
‫לשמור הצבעה(‪ .‬רק כאשר נגיע לקודקוד שהוא עלה ואינו מלא – נכניס את המפתח‬
‫כל העלים תמיד באותו‬
‫במקום המתאים‪ .‬זמן ריצה‪ .O(tlogn) :‬מס' גישות לדיסק‪.O(logn) :‬‬ ‫גובה‪.‬‬
‫‪ – Delete‬חלוקה למקרים לפי המצאות המפתח בעלה או בצומת פנימית ולפי מס'‬
‫המפתחות בצומת )יש רף תחתון(‪ .‬פירוט – בתירגול‪ .‬זמן ריצה – כמו הכנסה‪.‬‬
 ‫הערות חשובות‬ ‫תיאור פעולות עיקריות‪ /‬מבנה אלגוריתם ומשתניו‬ ‫ייצוג גרפי ‪+‬הערות‬ ‫הסבר כללי‬ ‫שם מבנה‬

‫ברמה העליונה וכל פעם שנתקל באיבר הגדול מ‪ k‬נרד רמה אחת מטה‬ ‫חיפוש – נתחיל באיבר‬
‫דרך למימוש מילון דינאמי‪.‬‬
‫ונמשיך להתקדם בחיפוש‪.‬אם אין יותר לאן לרדת – החיפוש הסתיים לא מציאת המפתח ‪ .k‬זמן ריצה‬
‫עובדות הסתברותיות‪:‬‬
‫במקרה הגרוע‪ ,O(n) :‬במקרה הממוצע‪.O(logn) :‬‬ ‫זהו אלגוריתם רנדומאלי‪.‬‬
‫ההסתברות שאיבר יעלה‬ ‫‪-‬‬ ‫הכנסה – תחילה מוצאים את המיקום המתאים )משתמשים בחיפוש(‪ .‬מכניסים את המפתח לרמה‬ ‫רשימת דילוגים עבוד קבוצת מפתחות‬
‫לרמה הבאה היא ‪.1/2‬‬ ‫התחתונה ומגרילים האם יעלה לרמה שמעליו‪ .‬אם יצא שכן – מגרילים שוב לרמה הבאה שמעליה‪ ,‬כך‬ ‫רשימות מקושרות‬ ‫זרים היא סדרה של רשימות מקושרות‬
‫ההסתברות שאיבר מסוים‬ ‫‪-‬‬ ‫עד הרמה העליונה‪** .‬יש לקבוע מדיניות לגבי הגעה לרמה העליונה בעת הכנסה‪ .‬גישה ‪ :1‬נגביל את‬ ‫זו מעל זו‪ .‬מימוש‬ ‫המקיימת‪ (1) :‬כל רשימה מתחילה ב‪-‬‬
‫‪i‬‬
‫יכנס לרמה ‪ i‬היא ‪.1/2‬‬ ‫מספר הרמות למספר מסוים )אולי כתלות ב‪ .(n‬גישה ‪ :2‬לא נעצור את התהליך ונסתמך על כך‬ ‫בעזרת קודקודים‬ ‫ומסתיימת ב‪ (2) . -‬הרשימה‬ ‫‪Skip-list‬‬
‫שההסתברות לכך תהיה נמוכה‪ .‬זמן ריצה במקרה הגרוע‪ ,O(n) :‬במקרה הממוצע‪.O(logn) :‬‬ ‫עם ‪ 4‬מצביעים‬ ‫הראשונה ‪ S0‬מכילה את כל המפתחות‪.‬‬
‫ההסתברות שרשימה ‪i‬‬ ‫‪-‬‬
‫תהיה בעלת איבר אחד‬ ‫)אחד לכל כיוון(‪.‬‬ ‫)‪ (3‬כל רשימה היא תת רשימה של‬
‫מחיקה – נמצא את האיבר ונמחק אותו ואת המגדל מעליו‪ .‬זמן ריצה – כמו של חיפוש‪/‬הכנסה‪.‬‬
‫‪i‬‬
‫לפחות‪.n/2 :‬‬ ‫הקודמת לה‪ (4) .‬הרשימה האחרונה‬
‫פעולות ב‪ :O(1)-‬מציאת מינימום‪ ,‬מציאת מקסימום‪ ,‬עוקב ומקדים‪.‬‬ ‫בסדרה תכיל רק את שני המפתחות‬
‫‪ (5) . ,‬לכל איבר יש‬ ‫המיוחדים‬
‫סיבוכיות מקום‪ :‬תלויה בתהליך הרנדומאלי של ההכנסות‪ .‬לפי חישובי הסתברות‪ ,‬סיבוכיות המקום‬ ‫סיכוי של ‪ 50%‬להופיע ברשימה מעליו‪.‬‬
‫הממוצעת היא )‪.O(n‬‬

‫)‪ = Length(A‬מס' איברים מקסימלי בערימה = אורך המערך‪.‬‬

‫)‪ = Heap-size(A‬מס' איברים בערימה‪.‬‬
‫)‪ = A(1‬שורש הערימה‪.‬‬
‫לכל אינדקס ‪:i‬‬
‫ערימת מקסימום – )‪A(parent(i))>=A(i‬‬
‫)ערך תחתון( ‪Parent(i) = i/2‬‬
‫‪Left(i) = 2i‬‬
‫‪Right(i) = 2i+1‬‬
‫משפט‪ :‬מספר העלים בערימה הוא‬ ‫פעולות‪ :‬בניית הערימה – חישוב נאיבי‪ .O(nlogn) :‬בחישוב הדוק מקבלים‪.O(n) :‬‬ ‫עץ )לרוב בינארי(‬ ‫ערימות יכולות להיות מסוג מקסימום‬
‫‪) n/2‬ערך עליון(‪.‬‬ ‫מלא‪ ,‬כך שהרמה‬ ‫או מינימום‪ ,‬מיוצגת ע"י עץ‪.‬‬
‫)בהינתן מערך כלשהו‪ ,‬מיון ערימה על מערך זה‪ ,‬ללא בניית ערימה נפרדת‪ ,‬ייקח )‪ O(nlogn‬במקרה‬ ‫האחרונה בו מלאה‬
‫ניתן להוסיף שיטה המאפשרת‬ ‫הגרוע(‪.‬‬ ‫משמאל ועד נקודה‬ ‫ערימת מקסימום‪ :‬כל קודקוד גדול מבנו‬
‫הגדלת אחד המפתחות שכבר בעץ –‬ ‫ערימה ‪-‬‬
‫מסוימת‪.‬‬ ‫הימני וגדול מבנו השמאלי‪.‬‬ ‫‪heap‬‬
‫‪ .heap-increase-key‬אם המפתח‬ ‫‪ .insert‬רעיון הכנסה – מוסיפים עלה ע"י הוספת האיבר החדש במקום הראשון הפנוי במערך ואז‬
‫כבר גדול יותר – לא משנים כלום‪.‬‬ ‫מטפסים עד השורש ומחליפים בין ‪ 2‬קודקודים בכל פעם שאינם מקיימים שהעליון גדול‬ ‫גובה העץ – ‪logn‬‬ ‫השורש הוא האיבר המקסימלי בערימה‪.‬‬
‫יידרש תיקון כלפי מעלה )ערימת‬ ‫מהתחתון‪O(logn) – .‬‬
‫ניתן להצגה כמערך‪.‬‬
‫מקס'(‪.‬‬
‫הוצאה – מחליפים את הקודקוד האחרון עם זה שרוצים להסיר ואז מבצעים שורת תיקונים אחת‬
‫כלפי מטה ואחת כלפי מעלה‪O(logn) .‬‬
‫‪ - Heap-max‬מציאת ערך מקסימלי – )‪O(1‬‬
‫‪ - Heap-extract-max‬שליפת ערך מקסימלי ‪.O(logn) -‬‬
‫‪ :Max-heapify‬עידכון הערימה לערימת מקסימום כאשר איבר אחד אינו במקומו‪ :‬לכל איבר‬
‫נבדקים שני בניו‪ .‬אם אחד נמצא גדול יותר – הוא מוחלף עם אביו‪ .‬וממשיכים לרדת דרך האב‪– .‬‬
‫)‪.O(logn‬‬

‫‪10‬‬
 ‫פעולות‪ Insert(S,x) :‬מקבל מערך ‪ S‬ומכניס אליו את האיבר עם מפתח ‪) O(logn) .x‬או‪:‬‬
‫‪(enqueue‬‬ ‫‪ADT‬‬
‫)‪ – Maximum(S‬מחזיר את האיבר בעל המפתח הגדול ביותר במערך‪O(1) .‬‬ ‫תור בו לכל איבר יש עדיפות מסוימת‬ ‫תור‬
‫וניתן להכניס איבר חדש עם עדיפות‬ ‫עדיפות –‬
‫)‪ – extractMax(S‬מוציא ומחזיר את האיבר המקסימלי‪) O(logn) .‬או‪.(dequeue :‬‬ ‫ספציפית‪ ,‬כלומר הסדר לא מבוסס רק‬
‫על סדר הכניסה‪.‬‬ ‫‪Priority‬‬
‫)‪ – increaseKey(S,x,k‬מגדיל את ערך המפתח ‪ x‬ל‪O(logn) .k-‬‬
‫‪queue‬‬
‫)באופן מקביל פועל תור מינימום(‪.‬‬

‫)‪ – makeSet(x‬יצירת רשימה עם איבר אחד )‪.O(1‬‬ ‫רשימות‬

‫מקושרות‪.‬‬
‫)‪ – union(x,y‬מחבר בין ראש הקבוצה של ‪ y‬לבין זנב הקבוצה של ‪ x‬ומעדכן בכל איברי‬
‫הקבוצה של ‪ y‬את הנציג להיות הנציג של ‪.x‬‬ ‫כל קבוצה היא‬
‫רשימה )עם‬
‫שיפור‪ :‬איחוד לפי משקל‪ .‬שומרים לכל קבוצה שדה גודל וכאשר מבצעים איחוד מחברים‬ ‫מצביעים לראש‬
‫תמיד את הקבוצה הקטנה לזו הגדולה‪ .‬שינוי בזמני ריצה‪ :‬הפעולה עצמה עדיין יכולה להיות‬ ‫ולזנב( וכל איבר‬
‫בסדר גודל )‪ O(n/2‬כלומר ללא שינוי‪ ,‬אבל בניתוח פחת מקבלים שזמן הריצה הממוצע לכל‬ ‫בקבוצה בעל‬
‫פעולה מתוך סדרה של ‪ m‬פעולות יהיה )‪.O(logn‬‬ ‫מצביע לאיבר הבא‬
‫ובעל מצביע לנציג‬
‫)‪ – find(x‬מחזיר מצביע לנציג הקבוצה ע"י השדה המתאים ב‪.O(1) x -‬‬ ‫קבוצתו‪.‬‬
‫ניתוח זמן ריצה של מבנה זה מתבצע‬
‫ע"י ניתוח פחת‪ :‬חישוב זמן הריצה‬
‫של סה"כ ‪ m‬פעולות משלושת‬ ‫)‪ – makeSet(x‬יצירת עץ עם איבר אחד והוא השורש )‪.O(1‬‬ ‫מבנה המממש אוסף קבוצות זרות‪ .‬כל‬
‫הסוגים‪ find,‬כאשר נעשו ‪ n‬פעולות‬ ‫קבוצה בעלת נציג כלשהו )לרוב אין‬ ‫קבוצות‬
‫)‪ – union(x,y‬הופך את שורש העץ הראשון לבן של שורש העץ השני‪.O(1) .‬‬ ‫חשיבות לנציג(‪ .‬שתי דרכי מימוש‬ ‫זרות –‬
‫‪ makeSet‬מתוכן‪.‬‬
‫עיקריות‪ :‬יער )כל קבוצה מיוצגת ע"י‬ ‫‪disjoint‬‬
‫‪) .m>=n‬מכאן שלכל היותר נעשו ‪n-‬‬ ‫)‪ – find(x‬מטפס מקודקוד ‪ x‬אל שורש העץ בו ‪ x‬נמצא‪ .‬מחזיר את השורש שהוא נציג‬ ‫עץ( ורשימות מקושרות‪ .‬דרך המימוש‬ ‫‪sets‬‬
‫הקבוצה‪ .‬במקרה הגרוע – העץ הוא פשוט שרשרת של האיברים ולכן זמן הריצה יהיה )‪.O(n‬‬ ‫יער עצים‪.‬‬ ‫מכתיבה את זמן הריצה במקרה הגרוע‪.‬‬
‫‪ 1‬פעולות ‪.(union‬‬
‫שיפורים‪:‬‬ ‫כל קבוצה היא עץ‪.‬‬
‫שורש כל עץ הוא‬
‫‪ .1‬איחוד לפי דרגה‪ :‬נחבר את העץ בעל הדרגה הקטנה יותר כילד של שורש העץ בעל הדרגה‬ ‫נציג הקבוצה‪.‬‬
‫הגדולה יותר‪ .‬נקטין בכך את זמן הריצה של פעולת ה‪.find -‬‬ ‫כל צומת בעץ‬
‫‪ :path-compression .2‬נשנה את פעולת ה‪-‬‬ ‫מצביע אך ורק‬
‫‪ find‬באופן הבא‪ :‬כשאנו מטפסים‬ ‫לאביו‪.‬‬
‫מקודקוד ‪ x‬לשורש‪ ,‬נהפוך כל קודקוד‬
‫דרכו אנו עוברים לבן ישיר של השורש‪.‬‬
‫זמן ריצה לאחר שיפורים‪ :‬בניתוח פחת נקבל‬
‫)‪ O(logn‬ממוצע לפעולה‪.‬‬

‫‪11‬‬
 ‫‪ .4‬אלגוריתמים נוספים‪:‬‬

‫הערות חשובות ווריאציות‬ ‫זמן ריצה ‪ +‬הסבר‬ ‫הסבר‬ ‫שם האלגוריתם‬

‫אלגוריתם למציאת האיבר ה ‪ k‬בגודלו‪ ,‬מתוך ‪ n‬איברים‪.‬‬
‫המספר ה‪ k-‬בגודלו הוא זה שיש בדיוק )‪ (k-1‬איברים לפניו‪ .‬חציון הוא‬
‫המספר במקום ה‪.floor[n/2]-‬‬
‫אלגוריתם זה הוא רקורסיבי ומקבל כקלט את ‪ – A‬המערך‪ – p ,‬ערך‬
‫במקרה הממוצע – )‪) .O(n‬הוכחת זמן‬ ‫ממנו נתחיל לחפש‪ – r ,‬ערך בו נפסיק לחפש‪ – i ,‬מיקום הערך הרצוי‪.‬‬
‫הריצה מבוססת על הוכחה דומה לזו‬ ‫בכל פעם‪ ,‬האלגוריתם יתמקד בטווח מסוים שניתן לו במערך ויבחר‬
‫של מיון מהיר(‬ ‫באופן אקראי איבר שיתפקד כ‪.pivot-‬‬ ‫‪Randomized-‬‬
‫במקרה הגרוע )כלומר הפיבוט הנבחר‬ ‫בשלב הבא יחולקו איברי המערך כך שאלו הגדולים מהפיבוט יהיו אחריו‬ ‫)‪select(A,p,r,i‬‬
‫יקטין את הטווח הנסרק ב‪ 1 -‬כל פעם(‬ ‫במערך ואלו הקטנים ממנו יהיה לפניו‪) .‬באופן זה אנו יודעים שהפיבוט‬
‫– )‪.O(n^2‬‬ ‫עצמו מונח במקומו(‪ .‬אם מיקום הפיבוט = ‪ ,i‬סיימנו‪ .‬אם לא‪ ,‬נפעיל‬
‫מחדש את האלגוריתם‪ ,‬הפעם על ערכי הטווח הרלוונטי )מימין או‬
‫משמאל לפיבוט(‪ ,‬ועדכון ‪ i‬במידת הצורך‪) .‬הסבר מפורט ‪-‬‬
‫‪http://www.cs.technion.ac.il/~bshouty/DS/OTHER/M10sortB-‬‬
‫‪(Slide-Version.pdf‬‬
‫בשאלות בהם אנו נדרשים לבצע‬
‫מיון‪ ,‬וידוע שיש ערך שמופיע‬ ‫אלגוריתם זה מהווה תוספת לאלגוריתם מעלה‪.‬‬
‫‪ n/2‬פעמים ומעלה – נצטרך‬ ‫מחלקים מערך לקבוצות בגודל ‪) .5‬בקבוצה האחרונה יהיו ‪ 1-5‬איברים(‪.‬‬
‫להסיק שמספר זה הוא בהכרח‬ ‫)‪ – O(n‬במקרה גרוע‪.‬‬ ‫כל קבוצה ממוינת וחציונה נשמר במערך חדש )באורך ‪ .(A/5‬משווים בין‬ ‫)‪select(A,p,r,i‬‬
‫גם החציון ולכן אלגוריתם זה‬ ‫כל החציונים ומוצאים את החציון מביניהם‪ .‬האיבר שמצאנו ייבחר‬
‫יוכל למצוא עבורנו את המספר‬
‫בזמן ריצה לינארי‪.‬‬
‫כפיבוט והמשך האלגוריתם הוא כמו זה הנ"ל‪) .‬פירוט בלינק מעלה(‪.‬‬

‫‪12‬‬
 ‫‪ .5‬טבלת זמני ריצה מקוצרת‪:‬‬

‫זמן ריצה‪ :‬הוצאת‬ ‫זמן ריצה‪ :‬חיפוש‬ ‫זמן ריצה‪ :‬מציאת‬ ‫זמן ריצה‪ :‬חיפוש איבר‬
‫סיבוכיות מקום‬ ‫זמן ריצה‪ :‬מחיקה‬ ‫מינימלי‪ /‬מקסימלי‬ ‫‪successor/‬‬
‫מינימלי‪ /‬מקסימלי‬ ‫ספציפי‬ ‫זמן ריצה‪ :‬הכנסה‬ ‫מבנה הנתונים‬
‫‪predecessor‬‬
‫)‪O(h‬‬ ‫)‪O(h‬‬ ‫)‪O(h‬‬ ‫)‪O(h‬‬ ‫)‪O(h‬‬ ‫)‪O(h‬‬
‫במקרה הגרוע‪:‬‬ ‫במקרה הגרוע‪:‬‬ ‫במקרה הגרוע‪:‬‬ ‫במקרה הגרוע‪:‬‬ ‫במקרה הגרוע‪:‬‬ ‫במקרה הגרוע‪:‬‬
‫)‪O(n‬‬ ‫)‪O(h) O(n‬‬ ‫)‪O(h) O(n‬‬ ‫)‪O(h) O(n‬‬ ‫)‪O(h) O(n‬‬ ‫)‪O(h) O(n‬‬ ‫)‪O(h) O(n‬‬ ‫עץ חיפוש בינארי‬
‫במקרה הממוצע‪:‬‬ ‫במקרה הממוצע‪:‬‬ ‫במקרה הממוצע‪:‬‬ ‫במקרה הממוצע‪:‬‬ ‫במקרה הממוצע‪:‬‬ ‫במקרה הממוצע‪:‬‬
‫)‪O(h) O(log n‬‬ ‫)‪O(h) O(log n‬‬ ‫)‪O(h) O(log n‬‬ ‫)‪O(h) O(log n‬‬ ‫)‪O(h) O(log n‬‬ ‫)‪O(h) O(log n‬‬
‫)‪O(n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫‪AVL‬‬
‫‪-‬‬ ‫)‪O(t log n‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫)‪O(t log n‬‬ ‫)‪O(t log n‬‬ ‫‪B-tree‬‬
‫חיפוש כושל‪ ,‬בממוצע‪:‬‬
‫‪1‬‬ ‫במקרה הממוצע )תחת‬
‫‪O‬‬ ‫‪Hash-table‬‬
‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪1‬‬ ‫הנחת גיבוב אחיד(‪:‬‬
‫חיפוש מוצלח‪ ,‬בממוצע‪:‬‬ ‫‪1‬‬ ‫‪Open-addressing‬‬
‫‪1‬‬ ‫‪1‬‬
‫‪O‬‬
‫‪O 1‬‬ ‫‪ln‬‬ ‫‪1‬‬
‫‪1‬‬
‫מקרה ממוצע‪:‬‬ ‫מקרה ממוצע‪:‬‬ ‫‪Hash-table‬‬
‫‪-‬‬
‫) ‪O(1‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬
‫) ‪O(1‬‬ ‫)‪O(1‬‬
‫‪chaining‬‬
‫מקרה ממוצע‪:‬‬ ‫)‪O(n‬‬ ‫)‪O(n‬‬ ‫)‪O(n‬‬
‫)‪O(n‬‬ ‫מקרה ממוצע‪:‬‬ ‫‪-‬‬ ‫)‪O(1‬‬ ‫)‪O(1‬‬ ‫מקרה ממוצע‪:‬‬ ‫מקרה ממוצע‪:‬‬ ‫‪Skip-list‬‬
‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬
‫ערימת‬
‫)‪O(n‬‬ ‫)‪O(log n‬‬ ‫)‪O(log n‬‬ ‫‪-‬‬ ‫)‪O(1‬‬ ‫)‪O(n‬‬ ‫)‪O(log n‬‬ ‫מינימום‪/‬מקסימום‬
‫)‪O(n‬‬ ‫‪-‬‬ ‫)‪O(log n‬‬ ‫‪-‬‬ ‫)‪O(1‬‬ ‫‪-‬‬ ‫)‪O(log n‬‬ ‫תור עדיפות‬
‫** אלא אם מצוין אחרת‪ ,‬זמן הריצה הוא ‪.worst-case‬‬

‫‪13‬‬