‫درﺧﺖ‬

‫• ﺗﻌﺪادي ﻋﻨﺼﺮ ﻛﻪ ﺑﻴﻦ آﻧﻬﺎ راﺑﻄﻪ ﭘﺪر‪-‬ﻓﺮزﻧﺪي ﺑﺮﻗﺮار اﺳﺖ‪ .‬در‬

‫دارد‪.‬‬
‫ﭘﺪر دا د‬
‫دﻗﻴﻘﺎ ﻳﻚ ﭘﺪ‬
‫رﻳﺸﻪ دﻗ ﻘﺎً‬
‫ﻋﻨﺼﺮ ﺑﻪ ﻏﻏﻴﺮ از ﻳﺸﻪ‬
‫درﺧﺖ ﻫﻫﺮ ﻋﻨﺼ‬
‫د ﺧﺖ‬
‫درﺧﺖ ))‪((TREE‬‬
‫ر‬
‫• ﺗﻌﺮﻳﻒ رﺳﻤﻲ‪ :‬ﻳﻚ درﺧﺖ ﻣﺠﻤﻮﻋﻪ ﻣﺤﺪودي از ﻳﻚ ﻳﺎ ﭼﻨﺪ ﮔﺮه‬
‫زﻳﺮ ﻣﻣﻲ ﺑﺎﺷﺪ‪:‬‬
‫ﺻﻮرت زﻳ‬
‫ﺑﻪ ﺻﻮ ت‬
‫ﺳﻴﺪ ﻧﺎﺻﺮ رﺿﻮي‬ ‫– داراي ﮔﺮه ﺧﺎﺻﻲ ﺑﻪ ﻧﺎم رﻳﺸﻪ اﺳﺖ‪.‬‬
‫‪email:‬‬
‫‪il razavi@comp.iust.ac.ir‬‬
‫@‪i‬‬ ‫‪i‬‬ ‫‪i‬‬ ‫– ﺑﻘﻴﻪ ﮔﺮه ﻫﺎ ﺑﻪ ‪ k ≥ 0‬ﻣﺠﻤﻮﻋﻪ ﻣﺠﺰا ﻣﺎﻧﻨﺪ ‪ ... ،T2 ،T1‬و ‪Tk‬ﺗﻘﺴﻴﻢ‬
‫‪1386‬‬ ‫ﻣﻲ ﺷﻮﻧﺪ ﺑﻪ ﮔﻮﻧﻪ اي ﻛﻪ ﻫﺮﻳﻚ از اﻳﻦ ﻣﺠﻤﻮﻋﻪ ﻫﺎ ﺧﻮد ﻳﻚ درﺧﺖ‬
‫ﻣﻲ ﺑﺎﺷﻨﺪ‪ ... ،T2 ،T1) .‬و ‪ Tk‬را زﻳﺮدرﺧﺖ ﻫﺎي رﻳﺸﻪ ﻣﻲ ﮔﻮﻳﻴﻢ‪(.‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٢‬‬

‫ﻣﺜﺎل‬ ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬

‫‪BOOK‬‬
‫• ﻣﺴﻴﺮ‪ :‬دﻧﺒﺎﻟﻪ اي از ﮔﺮه ﻫﺎ ﻣﺎﻧﻨﺪ ‪ n1, n2, …, nk‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ‬
‫ﮔﺮه ‪ ni+1‬ﻚ‬
‫ﻳﻚ‬ ‫ﮔﺮه ‪ ni‬ﻪ‬
‫ﺑﻪ ﮔ ه‬ ‫ﺑﻪ ازاي ﻫﻫﺮ ‪ 1 ≤ i < k‬از ﮔ ه‬
‫دﻧﺒﺎﻟﻪ ﻪ‬
‫اﻳﻦ دﻧ ﺎﻟﻪ‬
‫ددر ا ﻦ‬
‫ﺷﺎﺧﻪ و ﺟﻮد دارد‪.‬‬
‫‪C1‬‬ ‫‪C2‬‬ ‫‪C3‬‬

‫• ﻃﻮل ﻣﻣﺴﻴﺮ‪ :‬ﺑ اﺑ‬

‫ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺗﻌﺪاد ﺷﺎﺧﻪ ﻫﺎي ﻣﻮﺟﻮد ددر آن ﻣﻣﺴﻴﺮ‬
‫‪S1.1‬‬ ‫‪S1.2‬‬ ‫‪S2.1‬‬ ‫‪S2.2‬‬ ‫‪S2.1‬‬ ‫‪S3.1‬‬ ‫‪S3.2‬‬ ‫)ﻳﺎ ﺗﻌﺪاد ﮔﺮه ﻫﺎي ﻣﻮﺟﻮد در ﻣﺴﻴﺮ ﻣﻨﻬﺎي ﻳﻚ(‪.‬‬

‫‪SS1.1.1‬‬ ‫‪SS1.1.2‬‬ ‫‪SS2.2.1 SS2.2.2 SS2.2.3‬‬ ‫‪SS3.2.1 SS3.2.2‬‬ ‫• ﻣﺴﻴﺮ ﺑﺪﻳﻬ‬

‫ﺑﺪﻳﻬﻲ‪ :‬ﻣﺴﻴﺮي اﺳﺖ ﻛﻪ ﻃﻮل آن ﺑﺮاﺑﺮ ﺻﻔﺮ ﻣﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫– ﺑﻨﺎﺑﺮاﻳﻦ از ﻫﺮ ﻛﺮه ﺑﻪ ﺧﻮد آن ﮔﺮه ﻳﻚ ﻣﺴﻴﺮ ﺑﺪﻳﻬﻲ وﺟﻮد دارد‪.‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٣‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۴‬‬
 ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬ ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬
‫• ﺟﺪ )‪ (ancestor‬و ﻧﺴﻞ )‪ :(descendant‬اﮔﺮ در درﺧﺖ ﻣﺴﻴﺮي از ﮔﺮه‬ ‫• درﺟﻪ ﮔﺮه‪ :‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺗﻌﺪاد ﻓﺮزﻧﺪان آن ﮔﺮه‪.‬‬
‫ﻧﺴﻞ ‪a‬‬
‫ﺻﻮرت ‪ a‬ارا ﺟﺪ ‪ b‬و ‪ b‬ارا ﻧ ﻞ‬
‫ﺑﺎﺷﺪ‪ ،‬ددر اﻳﻦ ﺻ ت‬ ‫ﮔﺮه ‪ b‬ﺟ د‬
‫وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‬ ‫‪ a‬ﺑﻪ ﮔ ه‬
‫ﻣﻲ ﮔﻮﻳﻴﻢ‪.‬‬ ‫• درﺟﻪ درﺧﺖ‪ :‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺣﺪاﻛﺜﺮ درﺟﻪ ﮔﺮه ﻫﺎي ﻣﻮﺟﻮد در آن درﺧﺖ‪.‬‬

‫• ﭘﺪر )‪ (parent‬و ﻓﺮزﻧﺪ )‪ :(child‬اﮔﺮ در درﺧﺖ ﻣﺴﻴﺮي ﺑﻪ ﻃﻮل ﻳﻚ از‬ ‫ﺑﺎﺷﺪ )ﮔﮔﺮه ااي‬
‫ﺻﻔﺮ ﺎﺷ‬
‫ﺑﺮاﺑﺮ ﺎﺑﺎ ﻔ‬
‫ﺧﺎرﺟﻲ(‪ :‬ﮔﮔﺮه ااي ﻛﻛﻪ درﺟﻪ آآن ا‬ ‫• ﮔﮔﺮه گ‬
‫ﺑﺮگ )ﮔﮔﺮه ﺧﺎ‬
‫ﮔﺮه ‪ a‬ﺑﻪ ﮔﺮه ‪ b‬وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬در اﻳﻦ ﺻﻮرت ‪ a‬را ﭘﺪر ‪ b‬و ‪ b‬را‬ ‫ﻛﻪ ﺗﻌﺪاد ﻓﺮزﻧﺪاﻧﺶ ﺑﺮاﺑﺮ ﺑﺎ ﺻﻔﺮ ﺑﺎﺷﺪ(‪.‬‬
‫ﻓﺮزﻧﺪ ‪ a‬ﻣﻲ ﮔﮔﻮﻳﻴﻢ‪.‬‬
‫ﻓ زﻧﺪ‬

‫ﺻﻔﺮ ﺎﺷﺪ‬
‫ﺑﺎﺷﺪ‬ ‫ﺑﺰرﮔﺘﺮ از ﻔ‬
‫ﺟﻪ آن ﺰ ﮔﺘ‬
‫ﮔﺮه اي ﻛﻪ ددرﺟﻪ‬
‫داﺧﻠﻲ(‪ :‬ﮔ ه‬
‫ﮔﺮه داﺧﻠ‬
‫ﻏﻴﺮﺑﺮگ )ﮔ ه‬
‫ﮔﺮه ﻏ گ‬‫• ﮔه‬
‫• ﮔﺮه ﻫﺎي ‪) sibling‬ﻫﻤﺰاد‪ ،‬ﻫﻢ ﻧﻴﺎ(‪ :‬ﮔﺮه ﻫﺎﻳﻲ ﻛﻪ ﭘﺪر آﻧﻬﺎ ﻳﻜﺴﺎن ﺑﺎﺷﺪ‪.‬‬ ‫)ﮔﺮه اي ﻛﻪ ﺣﺪاﻗﻞ ﻳﻚ ﻓﺮزﻧﺪ داﺷﺘﻪ ﺑﺎﺷﺪ(‪.‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶‬‬

‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬ ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬

‫‪level 0‬‬
‫ﮔﺮه‪.‬‬
‫رﻳﺸﻪ ﺗﺎ آن ﮔ ه‬
‫ﻃﻮل ﻣﺴﻴﺮ از ﻳﺸﻪ‬
‫اﺳﺖ ﺑﺎ ﻃ ل‬
‫ﺑﺮاﺑﺮ ا ﺖ‬
‫ﮔﺮه‪ :‬ﺑ اﺑ‬
‫ﻋﻤﻖ( ﮔ ه‬
‫ﺳﻄﺢ )ﻋ ﻖ‬
‫ﻄﺢ‬ ‫•‬

‫‪level 1‬‬
‫• درﺧﺖ ‪-k‬ﺗﺎﻳﻲ‪ :‬درﺧﺘﻲ اﺳﺖ ﻛﻪ در آن درﺟﻪ ﻫﺮ ﮔﺮه ﺣﺪاﻛﺜﺮ‬
‫ﺑﺮاﺑﺮ ﺎﺑﺎ ‪ k‬ﺎﺷ‬
‫ﺑﺎﺷﺪ‪.‬‬ ‫ا‬
‫‪level 2‬‬
‫ارﺗﻔﺎع ﮔﺮه‪ :‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺣﺪاﻛﺜﺮ ﻃﻮل ﻳﻚ ﻣﺴﻴﺮ از آن ﮔﺮه ﺗﺎ‬ ‫•‬ ‫• ﻗﻀﻴﻪ‪ :‬در ﻫﺮ درﺧﺖ ‪-k‬ﺗﺎﻳﻲ دارﻳﻢ‪:‬‬
‫ﻳﻜﻲ از ﺑﺮگ ﻫﺎي اوﻻد‪.‬‬
‫‪n0 = (k – 1) nk + (k – 2) nk-1 + … + 2n3 + n2 + 1‬‬
‫‪B = n – 1 = n0 + n1 + … + nk - 1‬‬
‫‪B = 0 × n0 + 1 × n1 + 2 × n2 … + k × nk‬‬
‫ارﺗﻔﺎع درﺧﺖ‪ :‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ارﺗﻔﺎع رﻳﺸﻪ )ﺣﺪاﻛﺜﺮ ﻃﻮل ﻳﻚ‬ ‫•‬ ‫‪n0 = (k – 1) nk + (k – 2) nk-1 + … + 2n3 + n2 + 1‬‬
‫ﻣﺴﻴﺮ از رﻳﺸﻪ ﺗﺎ ﻳﻜﻲ از ﺑﺮگ ﻫﺎي درﺧﺖ(‬
‫ﻣﺴﺘﻘﻞ از ﺗﻌﺪاد ﮔ ه‬
‫ﮔﺮه‬ ‫ﺑﺮگ ﻫﺎ ﻣ ﺘﻘﻞ‬ ‫درﺧﺖ ‪-k‬ﺗﺎﻳ‬
‫ﺗﺎﻳﻲ ﺗﻌﺪاد ﺑ گ‬ ‫ﻧﺘﻴﺠﻪ‪ :‬ددر ﻫﻫﺮ د ﺧﺖ‬
‫ﻧﺘ ﺠﻪ‬
‫ﻫﺎي ﺗﻚ ﻓﺮزﻧﺪي ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٨‬‬
 ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬ ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬
‫• درﺧﺖ ‪-k‬ﺗﺎﻳﻲ ﻛﺎﻣﻞ‪ :‬درﺧﺘﻲ اﺳﺖ ﻛﻪ در آن درﺟﻪ ﻫﺮ ﮔﺮه ﻳﺎ‬ ‫• درﺧﺖ ﻣﺘﻮازن‪ :‬درﺧﺘﻲ اﺳﺖ ﻛﻪ در آن اﺧﺘﻼف ﺳﻄﺢ ﺑﺮگ ﻫﺎ‬
‫ﺑﺎﺷﺪ‪.‬‬
‫ﺻﻔﺮ ﺎﺷ‬ ‫ﺑﺮاﺑﺮ ﺎﺑﺎ ‪ k‬و ﺎﻳﺎ ا‬
‫ﺑﺮاﺑﺮ ﺎﺑﺎ ﻔ‬ ‫ا‬ ‫ﺑﺎﺷﺪ‪.‬‬
‫ﻳﻚ ﺎﺷ‬
‫ﺑﺮاﺑﺮ ﺎﺑﺎ ﻚ‬
‫ﺣﺪﻛﺜﺮ ا‬
‫ﻛ‬
‫• ﻗﻀﻴﻪ‪ :‬در ﻫﺮ درﺧﺖ ‪-k‬ﺗﺎﻳﻲ ﻛﺎﻣﻞ دارﻳﻢ‪:‬‬
‫‪n0 = (k – 1) nk + 1‬‬
‫‪B = n – 1 = n0 + nk - 1‬‬
‫‪B = 0 × n0 + k × nk‬‬
‫‪n0 = (k – 1) nk + 1‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٩‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪١٠‬‬

‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬ ‫ﺗﻌﺎرﻳﻒ ﭘﺎﻳﻪ اي‬

‫• درﺧﺖ ﻛﺎﻣﻼً ﻣﺘﻮازن‪ :‬درﺧﺘﻲ اﺳﺖ ﻛﻪ در آن اﺧﺘﻼف ﺳﻄﺢ‬ ‫• درﺧﺖ ﭘﺮ‪ :‬درﺧﺘﻲ اﺳﺖ ﻛﻪ ﻫﻢ ﻛﺎﻣﻞ ﺑﺎﺷﺪ و ﻫﻢ ﻛﺎﻣﻼً ﻣﺘﻮازن‪.‬‬
‫ﺑﺎﺷﺪ‪.‬‬
‫ﺻﻔﺮ ﺎﺷ‬
‫ﺑﺮاﺑﺮ ﺎﺑﺎ ﻔ‬
‫دﻗﻴﻘﺎ ا‬
‫ﻫﺎ ﻗ ﻘﺎً‬
‫ﺑﺮگ ﺎ‬
‫گ‬

‫• ﺗﻌﺪاد ﻛﻞ ﮔﺮه ﻫﺎ در ﻳﻚ درﺧﺖ ﭘﺮ ﺑﺎ درﺟﻪ ‪ d‬و ارﺗﻔﺎع ‪ h‬ﺑﺮاﺑﺮ‬

‫‪h‬‬
‫‪d h +1 − 1‬‬ ‫اﺳﺖ ﺑﺎ‪:‬‬
‫= ‪n = ∑ d = d + d +L+ d‬‬
‫‪i‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪h‬‬

‫‪i =0‬‬ ‫‪d −1‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١٢‬‬
 ‫روش ﻫﺎي ﭘﻴﻤﺎﻳﺶ درﺧﺖ‬ ‫ ﭘﻴﻤﺎﻳﺶ ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬:‫ﻣﺜﺎل‬
a
r

b c d e

T1 f g i j l

T1 T2
L Tk T4
h k

Preorder (T): r, Pre (T1), Pre (T2), …, Pre (Tk) T2 T3

Inorder (T): In (T1), r, In (T2), …, In (Tk) Preorder: a b c f g h d i k j e l

T1 T2 T3 T4
Postorder (T): Post (T1), Post (T2), …, Post (Tk), r

DS course- N. Razavi - ٢٠٠٧ ١٣ DS course- N. Razavi ٢٠٠٧ - ١۴

‫ ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎن ﺗﺮﺗﻴﺐ‬:‫ﻣﺜﺎل‬ ‫ ﭘﻴﻤﺎﻳﺶ ﭘﺲ ﺗﺮﺗﻴﺐ‬:‫ﻣﺜﺎل‬

a a

b c d e b c d e

T1 f g i j l T1 f g i j l

T4 T4
h k h k

T2 T3 T2 T3

Inorder: b a f c h g k i d j l e Postorder: b f h g c k i j d l e a
T1 T2 T3 T4 T1 T2 T3 T4

DS course- N. Razavi ٢٠٠٧ - ١۵ DS course- N. Razavi ٢٠٠٧ - ١۶

 (TREE ADT) ‫اﻧﺘﺰاﻋﻲ درﺧﺖ‬
‫ﻧﻮع داده اﻧﺘﺰاﻋ‬ ‫ﻋﻤﻮﻣﻲ ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬
‫ﭘﻴﻤﺎﻳﺶ درﺧﺖ ﻋﻤﻮﻣ‬
‫داده ااي‬ ‫• اﻧ ا‬
‫اﻧﻮاع ا‬
procedure PRE-ORDER (n: node);
• T: TREE
var
• n: node
‫• ﻋﻤﻠﻴﺎت درﺧﺖ‬ c: node;
• MAKENULL (T) begin
• ROOT (T) print (LABEL (n, T));
• PARENT (n, T) c := LEFT-MOST-CHILD (n, T); T ( n ) ∈ Θ( n )
• LABEL (n, T) while ( c <> NULL ) do begin
• LEFT-MOST-CHILD (n, T) PRE-ORDER (c);
c := RIGHT-SIBLING (c, T)
• RIGHT-SIBLING (n, T)
endd
• CREATEk (r, T1, T2, …, Tk) end;
DS course- N. Razavi ٢٠٠٧ - ١٧ DS course- N. Razavi ٢٠٠٧ - ١٨

‫ﻋﻤﻮﻣﻲ ﺑﻪ ﺻﻮرت ﻣﻴﺎن ﺗﺮﺗﻴﺐ‬

‫ﭘﻴﻤﺎﻳﺶ درﺧﺖ ﻋﻤﻮﻣ‬ ‫ﻋﻤﻮﻣﻲ ﺑﻪ ﺻﻮرت ﭘﭘﺲ ﺗﺮﺗﻴﺐ‬
‫ﭘﻴﻤﺎﻳﺶ درﺧﺖ ﻋﻤﻮﻣ‬
procedure IN-ORDER (n: node); procedure POST-ORDER (n: node);
var
c: node;; var
c: node;
begin
c := LEFT-MOST-CHILD (n, T);
if ( c <> NULL ) then begin begin
IN-ORDER (c);
print (LABEL (n, T)); c := LEFT-MOST-CHILD (n, T);
c := RIGHT-SIBLING (c, T) T ( n ) ∈ Θ( n ) while ( c <> NULL ) do begin T ( n ) ∈ Θ( n )
while ( c <> NULL ) do begin
IN-ORDER (c); POST-ORDER (c);
c := RIGHT-SIBLING (c, T) c := RIGHT-SIBLING (c, T)
end
else end;
print
i t (LABEL
A (n, T));
)) i (LABEL (n, T))
print
end;
end;
DS course- N. Razavi ٢٠٠٧ - ١٩ DS course- N. Razavi ٢٠٠٧ - ٢٠
 ‫ﺳﻄﺢ )‪(level order‬‬
‫ﺗﻤﺮﻳﻦ‪ :‬ﭘﻴﺎﻳﺶ ﺑﻪ ﺗﺮﺗﻴﺐ ﻄ‬ ‫ﻋﻤﻮﻣﻲ )روش ﺑﺪ(‬
‫ﭘﻴﺎده ﺳﺎزي درﺧﺖ ﻋﻤﻮﻣ‬
‫• روﻳﻪ اي ﺑﺮاي ﭘﻴﻤﺎﻳﺶ ﻳﻚ درﺧﺖ ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﻄﺢ ﺑﻨﻮﻳﺴﻴﺪ‪) .‬راﻫﻨﻤﺎﻳ‬
‫راﻫﻨﻤﺎﻳﻲ‪:‬‬ ‫ﮔﺮه ﻫﺎ‪:‬‬ ‫• ﭘ ﺎده‬
‫ﭘﻴﺎده ﺳﺎزي ﮔ ه‬
‫;)‪procedure LEVEL-ORDER (n: node‬‬
‫از ﺻﻒ اﺳﺘﻔﺎده ﻧﻤﺎﻳﻴﺪ(‪.‬‬ ‫– ﻳﻚ ﻓﻴﻠﺪ ﺑﺮاي ذﺧﻴﺮه اﻃﻼﻋﺎت )ﺑﺮﭼﺴﺐ(‬
‫‪var‬‬ ‫آدرس ﻓ زﻧﺪان‬
‫ﻓﺮزﻧﺪان‬ ‫ذﺧﻴﺮه آد‬
‫ﺑﺮاي ذﺧ ه‬
‫اﺷﺎره ﮔﮔﺮ اي‬ ‫– ‪ k‬ﻓ ﻠﺪ‬
‫ﻓﻴﻠﺪ اﺷﺎ ه‬
‫;‪c: node‬‬
‫;‪Q: QUEUE‬‬ ‫‪label‬‬ ‫‪ k‬ﻓﻴﻠﺪ اﺷﺎره ﮔﺮ‬
‫‪begin‬‬
‫;)‪MAKENULL (Q‬‬ ‫‪Child Child Child‬‬ ‫…‬ ‫‪Child‬‬
‫‪ENQUEUE‬‬
‫‪Q‬‬ ‫;)‪(n, Q‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪k‬‬
‫‪while not EMPTY (Q) do begin‬‬
‫;)‪n := DEQUEUE (Q‬‬ ‫• ﻋﻴﺐ اﻳﻦ روش ﭘﻴﺎده ﺳﺎزي‬
‫;) )‪print ( LABEL (n, T‬‬ ‫ﻓﺮزﻧﺪان‪nk :‬‬
‫اﺷﺎره ﮔﮔﺮ ﺑﻪ ﻓ زﻧﺪان‬ ‫– ﺗﻌﺪاد ﻛﻞ ﻓ ﻠﺪﻫﺎي‬
‫ﻓﻴﻠﺪﻫﺎي اﺷﺎ ه‬
‫;)‪c := LEFT-MOST-CHILD (n, T‬‬ ‫– ﺗﻌﺪاد ﻓﻴﻠﺪﻫﺎي اﺷﺎره ﮔﺮ ﻏﻴﺮ ‪n – 1 :nil‬‬
‫‪while ( c <> NULL ) do begin‬‬
‫;)‪ENQUEUE (c, Q‬‬ ‫– ﺑﻨﺎﺑﺮاﻳﻦ ﺗﻌﺪاد ﻓﻴﻠﺪﻫﺎي اﺷﺎره ﮔﺮ ‪ nil‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪:‬‬
‫)‪c := RIGHT-SIBLING (c, T‬‬ ‫‪nk – (n – 1) = n (k – 1) + 1‬‬
‫‪end‬‬
‫;‪end‬‬
‫‪d‬‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٢١‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٢٢‬‬

‫ﭘﭘﻴﺎده ﺳﺎزي درﺧﺖ ﻋﻤﻮﻣﻲ‪:‬‬ ‫ﻣﺜﺎل‪ :‬ﭘﭘﻴﺎده ﺳﺎزي ‪LMC-RSB‬‬

‫ﭼﭗ ﺗﺮﻳﻦ ﻓﺮزﻧﺪ‪-‬ﺑﺮادر راﺳﺖ )‪(LMC-RSB‬‬ ‫‪1‬‬
‫‪Label‬‬
‫‪f‬‬
‫‪LMC‬‬
‫‪NULL‬‬
‫‪RSB‬‬
‫‪2‬‬
‫‪g‬‬
‫• در اﻳﻦ روش‪ ،‬ﻫﺮ ﮔﺮه داراي ‪ 2‬ﻓﻴﻠﺪ آدرس ﻣﻲ ﺑﺎﺷﺪ‪:‬‬ ‫‪2‬‬ ‫‪10‬‬ ‫‪NULL‬‬

‫‪3‬‬ ‫‪c‬‬ ‫‪1‬‬ ‫‪11‬‬

‫‪T‬‬
‫– ﻳﻜﻲ ﺑﺮاي ذﺧﻴﺮه آآدرس ﭼﭗ ﺗﺮﻳﻦ ﻓﺮزﻧﺪ‬ ‫‪4‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬

‫‪a‬‬
‫‪5‬‬ ‫‪5‬‬ ‫‪a‬‬ ‫‪9‬‬ ‫‪NULL‬‬

‫ﺑﺮادرر رراﺳﺖ‬
‫ﺮﻳﻦ ﺑﺮ‬
‫ﻧﺰدﻳﻚ ﺗﺮﻳﻦ‬
‫رس ﺰ ﻳ‬
‫ذﺧﻴﺮه آدرس‬
‫ي ﻴﺮ‬ ‫ﺑﺮاي‬ ‫– ﻳﻳﻜﻲ‬
‫ﻲ ﺑﺮ‬ ‫‪6‬‬ ‫‪k‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬

‫‪7‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬

‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬
‫‪8‬‬ ‫‪e‬‬ ‫‪12‬‬ ‫‪NULL‬‬
‫‪a‬‬ ‫‪a‬‬
‫‪9‬‬ ‫‪b‬‬ ‫‪NULL‬‬ ‫‪3‬‬
‫‪f‬‬ ‫‪g‬‬ ‫‪i‬‬ ‫‪j‬‬ ‫‪l‬‬
‫‪10‬‬ ‫‪h‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬
‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪11‬‬ ‫‪d‬‬ ‫‪13‬‬ ‫‪8‬‬
‫‪12‬‬ ‫‪l‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬
‫‪LMC-RSB‬‬ ‫‪h‬‬ ‫‪k‬‬
‫‪f‬‬ ‫‪g‬‬ ‫‪i‬‬ ‫‪j‬‬ ‫‪l‬‬ ‫‪f‬‬ ‫‪g‬‬ ‫‪i‬‬ ‫‪j‬‬ ‫‪l‬‬ ‫‪13‬‬ ‫‪i‬‬ ‫‪6‬‬ ‫‪14‬‬
‫‪14‬‬ ‫‪j‬‬ ‫‪NULL‬‬ ‫‪NULL‬‬

‫‪M‬‬
‫‪h‬‬ ‫‪k‬‬ ‫‪h‬‬ ‫‪k‬‬ ‫‪MAX‬‬
‫‪cellspace‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٢٣‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٢۴‬‬
 LMC RSB ‫ﭘﻴﺎده ﺳﺎزي‬
LMC-RSB LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬
LMC-RSB
procedure MAKENULL (var T: TREE);
const
MAX = …;
NULL = 0;
0
begin
type
TREE = 0 .. MAX;
T := NULL
node = TREE;
end;;
var
cellspace : array [1..MAX] of record
label: labeltype; T (n) ∈ Θ(1)
LMC, RSB: node
end;
d

DS course- N. Razavi ٢٠٠٧ - ٢۵ DS course- N. Razavi ٢٠٠٧ - ٢۶

LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬

LMC-RSB LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬
LMC-RSB
function ROOT (T: TREE): node; function LABEL (n: node; T: TREE): labeltype;
begin begin
return (T) return (cellspace [n].
] lable)
end;; end;;

T (n) ∈ Θ(1) T (n) ∈ Θ(1)

DS course- N. Razavi ٢٠٠٧ - ٢٧ DS course- N. Razavi ٢٠٠٧ - ٢٨

 LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬
LMC-RSB LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬
LMC-RSB
function PARENT (n: node; T: TREE): node;
function LEFT-MOST-CHILD (n: node; T: TREE): node; var
c, p: node;
b i
begin
return ((cellspace
p [n]].LMC) begin
if ( n = ROOT
OO (T) ) then
th return
t (NULL)
(NULL);
end; c := LEFT_MOST_CHILD ( ROOT(T), T);
while ( c <> NULL) do begin
if (n = c ) then return ( ROOT (T) );
function RIGHT-SIBLING (n: node; T: TREE): node; p := PARENT (n, c);
if ( p <> NULL ) then return (p);
begin
i c := RIGHT-SIBLING (c, T)
end;
return ((cellspace
p [n]].RSB) return ( NULL )
end;
end;
T (n) ∈ Θ(1) T ( n ) ∈ Θ( n )
DS course- N. Razavi - ٢٠٠٧ ٢٩ DS course- N. Razavi - ٢٠٠٧ ٣٠

LMC RSB ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت‬

LMC-RSB LMC RSB ‫درﺧﺖ‬
LMC-RSB ‫ﻚ ﺧﺖ‬ ‫ﻫﺎي ﻳﻚ‬
‫ﺗﻌﺪاد ﮔﮔﺮه ﺎ‬
‫ﻣﺤﺎﺳﺒﻪ ﺗ ا‬
‫ ﺎ‬:‫ﻣﺜﺎل‬
‫ﺜﺎل‬

function CREATE2 (r: labeltype; T1, T2: TREE): TREE; function SIZE (n: node): integer;
var var
count: integer;
i
T: TREE; c: node;

begin begin
MYNEW (T); count := 1;
cellspace [T].label = r; c := LEFT-MOST-CHILD (n, T); )
while ( c <> NULL ) do begin
cellspace [T].LMC = T1; count ::= count + SIZE (c);
cellspace [T].RSB = NULL; c := RIGHT-SIBLING (c, T)
cellspace [T1].RSB = T2; end;
return ( T ) return
t (count)
end; end;
T ( n ) ∈ Θ( n )
DS course- N. Razavi - ٢٠٠٧ ٣١ DS course- N. Razavi - ٢٠٠٧ ٣٢
 ‫درﺧﺖ ‪LMC RSB‬‬
‫‪LMC-RSB‬‬ ‫ﻚ ﺧﺖ‬ ‫ارﺗﻔﺎع ﻳﻚ‬
‫ﻣﺤﺎﺳﺒﻪ ا ﺗﻔﺎ‬
‫ﻣﺜﺎل‪ :‬ﺎ‬
‫ﺜﺎل‬ ‫ﺗﻤﺮﻳﻦ‬
‫;‪function HEIGHT (n: node): integer‬‬
‫‪var‬‬
‫• ﺗﺎﺑﻌﻲ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﺗﻌﺪاد ﺑﺮگ ﻫﺎي ﻳﻚ درﺧﺖ ‪LMC-RSB‬‬
‫;‪h: integer‬‬
‫‪i‬‬ ‫ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫;‪c: node‬‬

‫‪begin‬‬
‫;‪h := 0‬‬
‫;)‪c := LEFT-MOST-CHILD (n, T‬‬ ‫)‬
‫;)‪if ( c = NULL ) then return (0‬‬
‫‪while ( c <> NULL ) do begin‬‬
‫;))‪h := MAXIMUM (h, HEIGHT (c‬‬
‫)‪c := RIGHT-SIBLING (c, T‬‬
‫;‪end‬‬
‫‪d‬‬
‫)‪return (h + 1‬‬
‫;‪end‬‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٣٣‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٣۴‬‬

‫دودوﻳﻲ )‪(Binary Tree‬‬

‫درﺧﺖ دودوﻳ‬ ‫دودوﻳﻲ‬
‫ﺧﻮاص درﺧﺖ ﻫﺎي دودوﻳ‬
‫• ﺗﻌﺮﻳﻒ‪ :‬ﻳﻚ درﺧﺖ دودوﻳﻲ ﻳﺎ ﺗﻬﻲ اﺳﺖ و ﻳﺎ ﺣﺎوي ﻣﺠﻤﻮﻋﻪ‬ ‫• ﺣﺪاﻛﺜﺮ ﺗﻌﺪاد ﮔﺮه ﻫﺎ در ﺳﻄﺢ ‪ i‬ام ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪2i :‬‬
‫درﺧﺖ دودوﻳﻲ ااﺳﺖ‪ .‬ااﻳﻦ‬
‫رﻳﺸﻪ و دو ﺧ‬‫ﺷﺎﻣﻞ ﺸ‬
‫ﻫﺎ ﺷﺎ ﻞ‬
‫ﻣﺤﺪودي ااز ﮔﮔﺮه ﺎ‬ ‫‪0‬‬ ‫‪20‬‬

‫ﻲ ﺷﻮﻧﺪ‪.‬‬
‫درﺧﺖ ﻫﺎ‪ ،‬زﻳﺮدرﺧﺖ ﻫﺎي ﭼﭗ و راﺳﺖ ﻧﺎﻣﻴﺪه ﻣﻲ‬ ‫‪1‬‬ ‫‪21‬‬

‫‪2‬‬ ‫‪22‬‬

‫‪0‬‬ ‫‪23‬‬
‫• ﺗﻔﺎوت ﻫﺎي درﺧﺖ دودوﻳﻲ ﺑﺎ درﺧﺖ ﻋﻤﻮﻣﻲ‪:‬‬
‫• ﺣﺪاﻛﺜﺮ ﺗﻌﺪاد ﮔﺮه ﻫﺎ در ﻳﻚ درﺧﺖ دودوﻳﻲ ﺑﺎ ارﺗﻔﺎع ‪ h‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪2h + 1 - 1 :‬‬
‫ﺗﻬﻲ ﺑﺎﺷﺪ‪.‬‬
‫دودوﻳﻲ ﻣﻣﻲ ﺗﻮاﻧﺪ ﺗﻬ‬ ‫– د ﺧﺖ‬
‫درﺧﺖ دودوﻳ‬ ‫‪h‬‬
‫‪2 h +1 − 1‬‬
‫= ‪n = ∑ 2i = 20 + 21 + L + 2 h‬‬ ‫‪= 2 h +1 − 1‬‬
‫– در درﺧﺖ دودوﻳﻲ ﺗﺮﺗﻴﺐ ﻓﺮزﻧﺪان اﻫﻤﻴﺖ دارد‪.‬‬ ‫‪i =0‬‬ ‫‪2 −1‬‬
‫‪Tl‬‬ ‫‪Tr‬‬
‫• راﺑﻄﻪ ﺑﻴﻦ ﺗﻌﺪاد ﺑﺮگ ﻫﺎ و ﺗﻌﺪاد ﮔﺮه ﻫﺎي دو ﻓﺮزﻧﺪي‪:‬‬
‫‪n0 = n2 + 1‬‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٣۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٣۶‬‬
 ‫دودوﻳﻲ ﺑﻪ وﺳﻴﻠﻪ آراﻳﻪ‬
‫ﻧﻤﺎﻳﺶ درﺧﺖ دودوﻳ‬ ‫دودوﻳﻲ ﺑﻪ وﺳﻴﻠﻪ آراﻳﻪ‬
‫ﻧﻤﺎﻳﺶ درﺧﺖ دودوﻳ‬
‫‪1‬‬
‫‪1‬‬ ‫‪a‬‬
‫‪2‬‬ ‫‪3‬‬
‫‪2‬‬ ‫‪b‬‬ ‫‪c3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬

‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪f‬‬ ‫‪g‬‬ ‫‪h‬‬

‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬
‫‪4‬‬ ‫‪d‬‬ ‫‪e5‬‬ ‫‪f‬‬ ‫‪7‬‬

‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬

‫‪8‬‬ ‫‪g‬‬ ‫‪h‬‬ ‫‪11‬‬

‫دارد‪.‬‬‫ﻗﺮار ا‬ ‫• رﻳﺸﻪ در ﺧﺎ‬

‫ﺧﺎﻧﻪ ‪ 1‬ﻗ ا‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬
‫‪1‬‬ ‫‪a‬‬ ‫‪a1‬‬
‫ﮔﺮه درر ﺧﺎﻧﻪ ‪ i‬امم ﺑﺑﺎﺷﺪ‪ ،‬آﻧﮕﺎه‪:‬‬
‫• اﮔﺮﺮ ﻳﻳﻚ ﺮ‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬
‫‪2‬‬ ‫‪b‬‬ ‫‪b3‬‬
‫– ﭘﺪر آن ﮔﺮه در ﺧﺎﻧﻪ ⎦‪(i > 1) ⎣i / 2‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬

‫‪c‬‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪5‬‬

‫ﭼﭗ آن ددر ﺧﺎﻧﻪ ‪(2i ≤ n) 2i‬‬ ‫– ﻓ زﻧﺪ‬
‫ﻓﺮزﻧﺪ ﭼ‬ ‫‪4‬‬ ‫‪c‬‬ ‫‪7‬‬

‫– ﻓﺮزﻧﺪ راﺳﺖ آن در ﺧﺎﻧﻪ ‪(2i + 1 ≤ n) 2i + 1‬‬ ‫‪8‬‬ ‫‪d‬‬ ‫‪d‬‬ ‫‪15‬‬

‫درﺧﺖ ﻣﻮرب ﭼﭗ‬
‫ﺧﺖ‬ ‫درﺧﺖ ﻣﻮرب ا ﺖ‬
‫راﺳﺖ‬ ‫ﺧﺖ‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٣٧‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٣٨‬‬

‫آراﻳﻪ‬
‫وﺳﻴﻠﻪ آ ا‬
‫ﻠ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ‬
‫ﺳﺎزي درﺧﺖ‬
‫ﭘﻴﺎده ﺎز‬
‫ﻣﻌﺎﻳﺐ ﺎ‬
‫ﺎ‬ ‫ﻴﻠﻪ اﺷﺎره ﮔﺮ‬
‫دودوﻳﻲ ﺑﻪ ووﺳﻴﻠﻪ‬
‫ﺳﺎزي درﺧﺖ دودوﻳ‬
‫ﭘﻴﺎده ﺎزي‬
‫• اﻳﻦ روش ﻓﻘﻂ ﺑﺮاي درﺧﺖ ﻫﺎي دودوﻳﻲ ﭘﺮ و ﺗﻘﺮﻳﺒﺎً ﭘﺮ ﻣﻨﺎﺳﺐ‬ ‫‪type‬‬
‫ارﺗﻔﺎع ‪ h‬ﺑﻪ‬
‫درﺧﺖ ﻣﻮرب ﺑﻪ ا ﻔﺎ‬ ‫ﻳﻚ ﺧ‬ ‫ﺣﺎﻟﺖ‪ ،‬ﻚ‬‫ااﺳﺖ‪ .‬در ﺑﺪﺗﺮﻳﻦ ﺎﻟ‬ ‫;‪TREE = ^nodetype‬‬
‫ﻦ ﺗﻌﺪاد ﻓﻘﻂ ‪ h + 1‬ﺧﺎﻧﻪ‬ ‫‪ 2h+1-1‬ﺧﺎﻧﻪ ﻧﻴﺎزز ر‬
‫دارد ﻛﻪ ازز اﻳﻦ‬
‫;‪node = TREE‬‬
‫اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد و ﺑﻘﻴﻪ ﺧﺎل ﻣﻲ ﻣﺎﻧﻨﺪ‪.‬‬ ‫‪left‬‬ ‫‪label‬‬ ‫‪right‬‬
‫‪nodetype‬‬
‫‪yp = record‬‬
‫;‪label: labeltype‬‬
‫• در اﻳﻦ روش‪ ،‬درج و ﺣﺬف ﮔﺮه ﻫﺎ ﻧﻴﺎز ﺑﻪ ﺟﺎﺑﺠﺎﻳ‬
‫ﺟﺎﺑﺠﺎﻳﻲ ﺑﻘﻴﻪ ﮔﺮه ﻫﺎ‬ ‫‪nodetype‬‬

‫دارد ﻛﻪ ﺑﺎﻋﺚ ﻛﻨﺪي ﻋﻤﻞ درج و ﺣﺬف ﻣﻲ ﮔﺮدد‪.‬‬ ‫‪left, right: node‬‬
‫;‪end‬‬
‫‪d‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٣٩‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۴٠‬‬
 ‫دودوﻳﻲ‬
‫روش ﻫﺎي ﭘﻴﻤﺎﻳﺶ درﺧﺖ دودوﻳ‬ ‫دودوﻳﻲ ﺑﻪ روش ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬
‫ﭘﻴﺎﻳﺶ درﺧﺖ دودوﻳ‬
r procedure PRE-ORDER (n: node);
b i
begin
if ( n <> nil ) then begin
Tl Tr write (n^.label);
PRE-ORDER (n^.left);
Preorder (T): r, Pre (Tl), Pre (Tr)
PRE-ORDER (n^.right)
Inorder (T): In (Tl), r, In (Tr) end
Postorder (T): Post (Tl), Post (Tr), r
end;
DS course- N. Razavi - ٢٠٠٧ ۴١ DS course- N. Razavi ٢٠٠٧ - ۴٢

‫دودوﻳﻲ ﺑﻪ روش ﻣﻴﺎن ﺗﺮﺗﻴﺐ‬

‫ﭘﻴﺎﻳﺶ درﺧﺖ دودوﻳ‬ ‫دودوﻳﻲ ﺑﻪ روش ﭘﺲ ﺗﺮﺗﻴﺐ‬
‫ﭘﻴﺎﻳﺶ درﺧﺖ دودوﻳ‬
procedure IN-ORDER (n: node); procedure POST-ORDER (n: node);
b i
begin b i
begin
if ( n <> nil ) then begin if ( n <> nil ) then begin
IN-ORDER (n^.left); POST-ORDER (n^.left);
write (n^.label); POST-ORDER (n^.right);
IN-ORDER (n^.right) write (n^.label)
end end
end; end;
DS course- N. Razavi ٢٠٠٧ - ۴٣ DS course- N. Razavi - ٢٠٠٧ ۴۴
 ‫ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎن ﺗﺮﺗﻴﺐ درﺧﺖ دودوﻳﻲ ﺑﻪ ﺻﻮرت‬
‫دودوﻳﻲ‬
‫ ﭘﻴﻤﺎﻳﺶ درﺧﺖ دودوﻳ‬:‫ﻣﺜﺎل‬ ‫ﭘﺸﺘﻪ‬
‫ﻛﻤﻚ ﺸﺘ‬
‫ﺑﺎزﮔﺸﺘﻲ ﺑﻪ ﻛ ﻚ‬
‫ﻏﻏﻴﺮ ﺎزﮔﺸﺘ‬
procedure NR-INORDER (n: node);
var
a S: STACK;
done: boolean;
b c begin
MAKENULL (S);
d e f done := false;
repeat
while ( n <> nil ) do begin
g h PUSH (n, S);
n ::= n^.left
end;
if not EMPTY (S) then begin
Preorder (T): a, b, d, g, e, h, c, f n := TOP (S); POP (S);
write (n^.label);
n := n^.right
Inorder (T): g, d, b, e, h, a, c, f end else
done := true;
until done
Postorder (T): g, d, h, e, b, f, c, a end;
T ( n ) ∈ Θ( n )
DS course- N. Razavi ٢٠٠٧ - ۴۵ DS course- N. Razavi ٢٠٠٧ - ۴۶

(level order) ‫ﺳﻄﺢ‬

‫ ﭘﻴﺎﻳﺶ ﺑﻪ ﺗﺮﺗﻴﺐ ﻄ‬:‫ﺗﻤﺮﻳﻦ‬ ‫ﻫﺎي آآن‬
‫ﭘﻴﻤﺎﻳﺶ ﺎ‬
‫ﻚ ﺎﺶ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ ﻛﻛﻤﻚ‬
‫ رﺳﻢ درﺧﺖ‬:‫ﻣﺴﺄﻟﻪ‬
‫ﺄﻟ‬
.‫ﺗﺮﺗﻴﺐ ﺳﻄﺢ ﺑﻨﻮﻳﺴﻴﺪ‬
‫دودوﻳﻲ ﺑﻪ ﺗ ﺗﻴﺐ‬
‫درﺧﺖ دودوﻳ‬
‫ﺑﺮاي ﭘﻴﻤﺎﻳﺶ ﻳﻚ د ﺧﺖ‬ ‫• وﻳﻪ‬
‫روﻳﻪ اي ﺑ اي‬
procedure LEVEL-ORDER (n: node); Pre: a, b, c, d, e, f, g, h
a
var
Q: QUEUE; In: b, c, a, e, d, g, f, h
begin
MAKENULL (Q); b, c d, e, f, g, h
ENQUEUE (n, Q); b, c e, d, g, f, h
while not EMPTY (Q) do begin
n := DEQUEUE (Q);
write ( n^.label );
if ( n^.left <> nil ) then ENQUEUE (n^.left, Q);
if ( n
n^.right
right <> nil ) then ENQUEUE (nn^.right
right, Q)
end;

DS course- N. Razavi ٢٠٠٧ - ۴٧ DS course- N. Razavi ٢٠٠٧ - ۴٨

 ‫ﻫﺎي آآن‬
‫ﭘﻴﻤﺎﻳﺶ ﺎ‬
‫ﻚ ﺎﺶ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ ﻛﻛﻤﻚ‬
‫ﻣﺴﺄﻟﻪ‪ :‬رﺳﻢ درﺧﺖ‬
‫ﺄﻟ‬ ‫ﻫﺎي آآن‬
‫ﭘﻴﻤﺎﻳﺶ ﺎ‬
‫ﻚ ﺎﺶ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ ﻛﻛﻤﻚ‬
‫ﻣﺴﺄﻟﻪ‪ :‬رﺳﻢ درﺧﺖ‬
‫ﺄﻟ‬

‫‪Pre: b, c‬‬ ‫‪Pre: d, e, f, g, h‬‬

‫‪a‬‬ ‫‪a‬‬

‫‪In:‬‬ ‫‪b, c‬‬ ‫‪In:‬‬ ‫‪e, d, g, f, h‬‬

‫‪b‬‬
‫‪b, c‬‬ ‫‪d, e, f, g, h‬‬ ‫‪d, e, f, g, h‬‬
‫‪b, c‬‬ ‫‪e, d, g, f, h‬‬ ‫‪c‬‬ ‫‪e, d, g, f, h‬‬
‫‪b‬‬ ‫‪d‬‬

‫‪c‬‬ ‫‪e‬‬

‫‪f, g, h‬‬
‫‪g, f, h‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۴٩‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵٠‬‬

‫ﻫﺎي آآن‬
‫ﭘﻴﻤﺎﻳﺶ ﺎ‬
‫ﻚ ﺎﺶ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ ﻛﻛﻤﻚ‬
‫ﻣﺴﺄﻟﻪ‪ :‬رﺳﻢ درﺧﺖ‬
‫ﺄﻟ‬ ‫ﻫﺎي آآن‬
‫ﭘﻴﻤﺎﻳﺶ ﺎ‬
‫ﻚ ﺎﺶ‬ ‫ﺧﺖ دودوﻳﻲ ﺑﻪ ﻛﻛﻤﻚ‬
‫ﻣﺴﺄﻟﻪ‪ :‬رﺳﻢ درﺧﺖ‬
‫ﺄﻟ‬

‫‪Pre: f, g, h‬‬ ‫‪Pre: a, b, c, d, e, f, g, h‬‬

‫‪a‬‬ ‫‪a‬‬

‫‪In:‬‬ ‫‪g, f, h‬‬ ‫‪In:‬‬ ‫‪b, c, a, e, d, g, f, h‬‬

‫‪b‬‬ ‫‪d‬‬ ‫‪b‬‬ ‫‪d‬‬

‫‪c‬‬ ‫‪e‬‬ ‫‪Post: c, b, e, g, h, f, d, a‬‬ ‫‪c‬‬ ‫‪e‬‬

‫‪f‬‬
‫‪f, g, h‬‬
‫‪g f,‬‬
‫‪g,‬‬ ‫‪f h‬‬ ‫‪g‬‬ ‫‪h‬‬
‫‪f‬‬ ‫ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎ داﺷﺘﻦ ﭘﻴﻤﺎﻳﺶ ‪ Inorder‬و ﺣﺪاﻗﻞ ﻳﻜﻲ از ﭘﻴﻤﺎﻳﺶ ﻫﺎي دﻳﮕﺮ درﺧﺖ دودوﻳﻲ ﻗﺎﺑﻞ ﺗﺮﺳﻴﻢ اﺳﺖ‪.‬‬
‫اﻣﺎ ﺑﺎ ﺑﺎ داﺷﺘﻦ ﭘﻴﻤﺎﻳﺶ ‪ Preorder‬و ‪ Postorder‬درﺧﺖ دودوﻳﻲ ﺑﻪ ﺻﻮرت ﻳﻜﺘﺎ ﻗﺎﺑﻞ ﺗﺮﺳﻴﻢ ﻧﻴﺴﺖ‪ .‬ﭼﺮا؟‬
‫‪g‬‬ ‫‪h‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۵١‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵٢‬‬
 ‫دودوﻳﻲ‬
‫ﻛﭙﻲ ﻛﺮدن ﻳﻚ درﺧﺖ دودوﻳ‬
‫ﻣﺜﺎل‪ :‬ﻛﭙ‬ ‫ﺗﻤﺮﻳﻦ‬
‫;‪function COPY (n: node): TREE‬‬ ‫‪ .1‬ﺗﺎﺑﻌﻲ ﺑﻪ ﺻﻮرت زﻳﺮ ﺑﻪ ﻣﻨﻈﻮر ﺑﺮرﺳﻲ ﻧﻤﻮدن ﺗﺴﺎوي دو درﺧﺖ‬
‫‪var‬‬
‫;‪T: TREE‬‬ ‫دودوﻳﻲ ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫‪function EQUAL‬‬ ‫‪TREE (n1,‬‬
‫‪QUAL-T‬‬ ‫;‪1 n2: node): boolean‬‬
‫‪begin‬‬
‫;)‪if n = nil then return (nil‬‬
‫;)‪new (T‬‬ ‫‪ .2‬ﺗﺎﺑﻌﻲ ﺑﻪ ﺻﻮرت زﻳﺮ ﺑﻨﻮﻳﺴﻴﺪ ﺑﻪ ﻃﻮري ﻛﻪ ﺑﺮاي ﻫﺮ ﮔﺮه در‬
‫;‪T^.label := n^.label‬‬
‫;)‪T^.left := COPY (n^.left‬‬ ‫راﺳﺖ آن ﮔﮔﺮه ارا ﺎﺑﺎ‬
‫درﺧﺖ ﭼﭗ و ا ﺖ‬
‫ﺟﺎي ددو ززﻳﺮ د ﺧﺖ‬
‫دودوﻳﻲ‪ ،‬ﺎ‬‫درﺧﺖ د د‬
‫د ﺧﺖ‬
‫;)‪T^.right := COPY (n^.right‬‬ ‫ﻫﻢ ﺗﻌﻮﻳﺾ ﻧﻤﺎﻳﺪ‪.‬‬
‫)‪return (T‬‬
‫;‪end‬‬ ‫;‪function SWAP-TREE (n: node): TREE‬‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۵٣‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵۴‬‬

‫ﺗﻤﺮﻳﻦ‬ ‫دودوﻳﻲ‬
‫وﻳﻲ‬ ‫ﻧﺨﻲ و‬
‫درﺧﺖ ﻲ‬
‫ر‬
‫‪ .3‬روﻳﻪ اي ﺑﺮاي ارزﺷﻴﺎﺑﻲ ﻳﻚ ﻓﺮﻣﻮل ﮔﺰاره اي ﺑﻨﻮﻳﺴﻴﺪ‪) .‬راﻫﻨﻤﺎﻳﻲ‪ :‬روﻳﻪ‬ ‫• اﻧﮕﻴﺰه‪ :‬اﺳﺘﻔﺎده ﻫﻮﺷﻤﻨﺪ از ﻓﻴﻠﺪﻫﺎي اﺷﺎره ﮔﺮ ‪nil‬‬
‫‪ postorder‬ارا اﺻﻼح ﻧ ﺎﻳ ﺪ‬
‫ﻧﻤﺎﻳﻴﺪ‪.‬‬ ‫– در ﻳﻚ درﺧﺖ دودوﻳﻲ ﺑﺎ ‪ n‬ﮔﺮه‪ ،‬ﻛﻼً ‪ 2n‬ﻓﻴﻠﺪ اﺷﺎره ﮔﺮ وﺟﻮد دراد ﺑﻪ ﻃﻮري ﻛﻪ‬
‫‪ n – 1‬ﻓﻴﻠﺪ ﻏﻴﺮ ‪ nil‬و ‪ n + 1‬ﻓﻴﻠﺪ داراي ﻣﻘﺪار ‪ nil‬ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫‪( x1 ∧ ¬x2 ) ∨ (¬x1 ∧ x3 ) ∨ ¬x3‬‬
‫– ﻫﺮ ﻓﻴﻠﺪ ‪ nil‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﮔﺮه ﺑﻌﺪي )در ﻳﻚ ﭘﻴﻤﺎﻳﺶ ﺧﺎص( اﺷﺎره ﻛﻨﺪ‪.‬‬
‫‪T‬‬ ‫∨‬
‫‪T‬‬
‫‪x1‬‬ ‫‪True‬‬ ‫‪T‬‬ ‫∨‬ ‫¬‬ ‫‪F‬‬ ‫‪A‬‬
‫‪x2‬‬ ‫‪False‬‬
‫‪x3‬‬ ‫‪True‬‬ ‫‪T‬‬ ‫∧‬ ‫∧‬ ‫‪F‬‬ ‫‪x3 T‬‬ ‫‪B‬‬ ‫‪C‬‬

‫‪x1‬‬ ‫¬‬ ‫¬‬ ‫‪x3‬‬ ‫‪D‬‬ ‫‪E‬‬ ‫‪F‬‬ ‫‪G‬‬

‫‪T‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬
‫‪x2‬‬ ‫‪x1‬‬ ‫‪H‬‬ ‫‪I‬‬
‫‪F‬‬ ‫‪T‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۵۶‬‬
 ‫دودوﻳﻲ‬
‫وﻳﻲ‬ ‫ﻧﺨﻲ و‬
‫درﺧﺖ ﻲ‬
‫زي ر‬
‫ﭘﻴﺎده ﺳﺎزي‬
‫ﭘﻴ‬ ‫ﭘﭘﻴﺎده ﺳﺎزي درﺧﺖ ﻧﺨﻲ دودوﻳﻲ‬
T
header
leftThread left label right rightThread f f

nodetype
type f A f

TREE = ^nodetype;
yp
node = ^nodetype;
nodetype = record f B f f C f

leftThread: boolean;
left: node;
f D f t E t t F t t G t
label: labeltype;
right: node;
rightThread: boolean t H t t I t
end;
DS course- N. Razavi ٢٠٠٧ - ۵٧ DS course- N. Razavi ٢٠٠٧ - ۵٨

‫دودوﻳﻲ‬
‫ﻧﺨﻲ دودوﻳ‬
‫ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎن ﺗﺮﺗﻴﺐ درﺧﺖ ﻧﺨ‬ ‫دودوﻳﻲ‬
‫ﻧﺨﻲ دودوﻳ‬
‫ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎن ﺗﺮﺗﻴﺐ درﺧﺖ ﻧﺨ‬
function INORDER-SUCC (n: node): node; function INORDER-THREAD (T: TREE): node;
var var
t: node; n: node;
n
T
A t begin
begin
B C n := T;
t := n^.
^ right; repeat
if not n^.rightThread then D E F G
n := INORDER-SUCC (n);
hil nott t^.
while ^ leftThread
l ftTh d dod H I t
if ( n <> T ) then
t := t^.left; write (n^.label);
return (t) untilil n = T
end; end;
DS course- N. Razavi - ٢٠٠٧ ۵٩ DS course- N. Razavi - ٢٠٠٧ ۶٠
 ‫ﻣﺜﺎل‪ :‬ﭘﭘﻴﻤﺎﻳﺶ درﺧﺖ ﻧﺨﻲ دودوﻳﻲ‬ ‫دودوﻳﻲ‬
‫وﻳﻲ‬ ‫درﺧﺖ و‬
‫ﻋﻤﻮﻣﻲ ﺑﺑﻪ ر‬
‫درﺧﺖ ﻮ ﻲ‬
‫ﻳﻞ ر‬
‫ﺗﺒﺪﻳﻞ‬
‫ﺒ‬
‫‪(11) n‬‬ ‫‪T‬‬ ‫‪(1) n‬‬
‫ﻞ ‪LMC-RSB‬‬
‫ﻲ ﺑﺑﻪ ﺷﻜﻞ‬
‫ﻋﻤﻮﻣﻲ‬
‫درﺧﺖ ﻮ‬
‫ﻳﻞ ر‬
‫ﺗﺒﺪﻳﻞ‬
‫ﺒ‬ ‫‪.١‬‬
‫‪f‬‬ ‫‪f‬‬

‫‪(7) n‬‬
‫‪A‬‬ ‫‪A‬‬
‫‪f‬‬ ‫‪A‬‬ ‫‪f‬‬

‫‪(5) n‬‬ ‫‪(9) n‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬

‫‪f‬‬ ‫‪f‬‬ ‫‪f‬‬ ‫‪f‬‬

‫‪B‬‬ ‫‪C‬‬
‫ي ﺳﺎﻋﺖ‬
‫ﻋﻘﺮﺑﻪ ﻫﺎي‬
‫ش ﺮﺑ‬ ‫ﮔﺮدش‬
‫ﺟﻬﺖ ﺮ‬
‫درﺟﻪ درر ﺟﻬ‬ ‫ن اﺗﺼﺎﻻت ‪ RSB‬ﺑﺑﻪ ز‬
‫اﻧﺪازه ‪ 45‬رﺟ‬ ‫ﭼﺮﺧﺎﻧﺪن‬
‫ﭼﺮ‬ ‫‪.٢‬‬
‫‪(3) n‬‬

‫‪A‬‬ ‫‪A‬‬
‫‪f‬‬ ‫‪D‬‬ ‫‪f‬‬ ‫‪t‬‬ ‫‪E‬‬ ‫‪t‬‬ ‫‪t‬‬ ‫‪F‬‬ ‫‪t‬‬ ‫‪t‬‬ ‫‪G‬‬ ‫‪t‬‬

‫‪(10) n‬‬ ‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪B‬‬

‫‪((6)) n‬‬ ‫‪((8)) n‬‬
‫‪t‬‬ ‫‪H‬‬ ‫‪t‬‬ ‫‪t‬‬ ‫‪I‬‬ ‫‪t‬‬
‫‪C‬‬

‫‪(2) n‬‬ ‫‪(4) n‬‬ ‫‪D‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶١‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۶٢‬‬

‫ﺗﺒﺪﻳﻞ ﺟﻨﮕﻞ ﺑﻪ درﺧﺖ دودوﻳﻲ‬

‫ﻲ‬
‫ﺟﻨﮕﻞ )‪(forest‬‬
‫‪ .١‬ﺗﺒﺪﻳﻞ ﻫﺮ درﺧﺖ در ﺟﻨﮕﻞ ﺑﻪ ﻳﻚ درﺧﺖ دودوﻳﻲ‬
‫• ﺗﻌﺮﻳﻒ‪ :‬ﺟﻨﮕﻞ ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﻣﺮﺗﺐ از ‪ k ≥ 0‬درﺧﺖ ﻣﺠﺰا اﺳﺖ‪.‬‬ ‫‪A‬‬ ‫‪E‬‬ ‫‪G‬‬

‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪F‬‬ ‫‪H‬‬ ‫‪I‬‬

‫‪A‬‬ ‫‪E‬‬ ‫‪G‬‬

‫‪A‬‬ ‫‪E‬‬ ‫‪G‬‬

‫‪B‬‬ ‫‪C‬‬ ‫‪D‬‬ ‫‪F‬‬ ‫‪H‬‬ ‫‪I‬‬

‫‪B‬‬ ‫‪F‬‬ ‫‪H‬‬

‫‪C‬‬ ‫‪I‬‬

‫‪D‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶٣‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶۴‬‬
 ‫ﺗﺒﺪﻳﻞ ﺟﻨﮕﻞ ﺑﻪ درﺧﺖ دودوﻳﻲ‬
‫ﻲ‬ ‫ﺗﺒﺪﻳﻞ ﺟﻨﮕﻞ ﺑﻪ درﺧﺖ دودوﻳﻲ‬
‫ﻲ‬
‫‪ .٢‬ﻗﺮار دادن ﻫﺮ ﻳﻚ از درﺧﺖ ﻫﺎي دودوﻳﻲ ﺑﻪ ﻋﻨﻮان زﻳﺮدرﺧﺖ‬ ‫‪ .٢‬ﻗﺮار دادن ﻫﺮ ﻳﻚ از درﺧﺖ ﻫﺎي دودوﻳﻲ ﺑﻪ ﻋﻨﻮان زﻳﺮدرﺧﺖ‬
‫راﺳﺖ رﻳﺸﻪ درﺧﺖ ﻗﺒﻠﻲ‬ ‫راﺳﺖ رﻳﺸﻪ درﺧﺖ ﻗﺒﻠﻲ‬

‫‪A‬‬ ‫‪E‬‬ ‫‪G‬‬ ‫‪A‬‬ ‫‪E‬‬

‫‪F‬‬ ‫‪H‬‬ ‫‪F‬‬ ‫‪G‬‬

‫‪B‬‬ ‫‪B‬‬

‫‪C‬‬ ‫‪I‬‬ ‫‪C‬‬

‫‪H‬‬
‫‪D‬‬ ‫‪D‬‬
‫‪I‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶۶‬‬

‫ﺗﺒﺪﻳﻞ ﺟﻨﮕﻞ ﺑﻪ درﺧﺖ دودوﻳﻲ‬

‫ﻲ‬
‫ﭘﻴﻤﺎﻳﺶ ﺟﻨﮕﻞ ‪ F‬ﺑﻪ روش ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬
‫‪ .٢‬ﻗﺮار دادن ﻫﺮ ﻳﻚ از درﺧﺖ ﻫﺎي دودوﻳﻲ ﺑﻪ ﻋﻨﻮان زﻳﺮدرﺧﺖ‬
‫راﺳﺖ رﻳﺸﻪ درﺧﺖ ﻗﺒﻠﻲ‬ ‫اﮔﺮ ‪ F‬ﺗﻬﻲ اﺳﺖ‪ ،‬ﺑﺮﻣﻲ ﮔﺮدﻳﻢ‪.‬‬ ‫‪.١‬‬
‫‪A‬‬ ‫ﻣﻼﻗﺎت رﻳﺸﻪ اوﻟﻴﻦ درﺧﺖ در ﺟﻨﮕﻞ ‪F‬‬ ‫‪.٢‬‬
‫‪٢‬‬
‫ت‬
‫ﺻﻮرت‬ ‫درﺧﺖ ددر ﺟﻨﮕﻞ ‪ F‬ﻪ‬
‫ﺑﻪ‬ ‫اوﻟﻴﻦ د ﺧﺖ‬
‫زﻳﺮدرﺧﺖ ﻫﺎي ا ﻟ ﻦ‬
‫ﭘﻴﻤﺎﻳﺶ ز د ﺧﺖ‬
‫ﺎﺶ‬ ‫‪.٣‬‬
‫‪٣‬‬
‫‪B‬‬ ‫‪E‬‬
‫ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬
‫‪C‬‬ ‫‪F‬‬ ‫‪G‬‬ ‫ﭘﻴﻤﺎﻳﺶ ﺑﻘﻴﻪ درﺧﺖ ﻫﺎي ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬ ‫‪.۴‬‬

‫‪D‬‬ ‫‪H‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﭘﻴﻤﺎﻳﺶ ﭘﻴﺶ ﺗﺮﺗﻴﺐ ﺟﻨﮕﻞ و ﭘﻴﻤﺎﻳﺶ ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬ ‫•‬
‫‪I‬‬ ‫درﺧﺖ دودوﻳﻲ ﻣﺘﻨﺎﻇﺮ ﺑﺎ آن‪ ،‬ﻳﻜﺴﺎن اﺳﺖ‪.‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶٧‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪۶٨‬‬
 ‫ﭘﻴﻤﺎﻳﺶ ﺟﻨﮕﻞ ‪ F‬ﺑﻪ روش ﻣﻴﺎن ﺗﺮﺗﻴﺐ‬ ‫ﭘﻴﻤﺎﻳﺶ ﺟﻨﮕﻞ ‪ F‬ﺑﻪ روش ﭘﺲ ﺗﺮﺗﻴﺐ‬
‫اﮔﺮ ‪ F‬ﺗﻬﻲ اﺳﺖ‪ ،‬ﺑﺮﻣﻲ ﮔﺮدﻳﻢ‪.‬‬ ‫‪.١‬‬ ‫اﮔﺮ ‪ F‬ﺗﻬﻲ اﺳﺖ‪ ،‬ﺑﺮﻣﻲ ﮔﺮدﻳﻢ‪.‬‬ ‫‪.١‬‬
‫ﭘﻴﻤﺎﻳﺶ زﻳﺮدرﺧﺖ ﻫﺎي اوﻟﻴﻦ درﺧﺖ در ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺻﻮرت‬ ‫‪.٢‬‬
‫‪٢‬‬ ‫ﭘﻴﻤﺎﻳﺶ زﻳﺮدرﺧﺖ ﻫﺎي اوﻟﻴﻦ درﺧﺖ در ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺻﻮرت‬ ‫‪.٢‬‬
‫‪٢‬‬
‫ﺗﺮﺗﻴﺐ‬
‫ﻴﺐ‬ ‫ن ﺮ‬‫ﻣﻴﺎن‬
‫ﻴ‬ ‫ﺗﺮﺗﻴﺐ‬
‫ﻴﺐ‬ ‫ﭘﺲ ﺮ‬
‫ﻣﻼﻗﺎت رﻳﺸﻪ اوﻟﻴﻦ درﺧﺖ در ﺟﻨﮕﻞ ‪F‬‬ ‫‪.٣‬‬ ‫ﭘﻴﻤﺎﻳﺶ ﺑﻘﻴﻪ درﺧﺖ ﻫﺎي ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺻﻮرت ﭘﺲ ﺗﺮﺗﻴﺐ‬ ‫‪.٣‬‬
‫ﭘﻴﻤﺎﻳﺶ ﺑﻘﻴﻪ درﺧﺖ ﻫﺎي ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺻﻮرت ﻣﻴﺎن ﺗﺮﺗﻴﺐ‬ ‫‪.۴‬‬ ‫ﻣﻼﻗﺎت رﻳﺸﻪ اوﻟﻴﻦ درﺧﺖ در ﺟﻨﮕﻞ ‪F‬‬ ‫‪.۴‬‬

‫ﻧﻜﺘﻪ‪ :‬ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎن ﺗﺮﺗﻴﺐ ﺟﻨﮕﻞ و ﭘﻴﻤﺎﻳﺶ ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬ ‫•‬ ‫ﻧﻜﺘﻪ‪ :‬ﭘﻴﻤﺎﻳﺶ ﭘﺲ ﺗﺮﺗﻴﺐ ﺟﻨﮕﻞ و ﭘﻴﻤﺎﻳﺶ ﭘﻴﺶ ﺗﺮﺗﻴﺐ‬ ‫•‬
‫درﺧﺖ دودوﻳﻲ ﻣﺘﻨﺎﻇﺮ ﺑﺎ آن‪ ،‬ﻳﻜﺴﺎن اﺳﺖ‪.‬‬ ‫درﺧﺖ دودوﻳﻲ ﻣﺘﻨﺎﻇﺮ ﺑﺎ آن‪ ،‬ﻳﻜﺴﺎن ﻧﻴﺴﺖ‪.‬‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪۶٩‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧٠‬‬

‫ﻳﻚ ﻛﺎﺑﺮد درﺧﺖ‪ :‬ﻧﻤﺎﻳﺶ زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا‬

‫ﭘﻴﻤﺎﻳﺶ ﺟﻨﮕﻞ ‪ F‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﻄﺢ‬
‫)‪(disjoint subsets‬‬
‫ﻣﻼﻗﺎت رﻳﺸﻪ درﺧﺘﺎن از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪.١‬‬ ‫}‪S = {1, 2, …, n‬‬
‫ﻣﻼﻗﺎت ﮔﺮه ﻫﺎ ي ﺳﻄﺢ اول از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪.٢‬‬
‫‪٢‬‬ ‫ﺑﺮاي ‪:(n = 10‬‬‫ﻣﺠﺰا ) ا‬
‫ﻫﺎي ا‬ ‫ﻣﺜﺎل ااز زﻳﺮﻣﺠﻤﻮﻋﻪ ﺎ‬
‫ﻳﻚ ﺎل‬‫• ﻚ‬
‫ﮔﺮه ﻫﺎ ي ﺳﻄﺢ دوم از ﭼﭗ ﺑﻪ اﺳﺖ‬
‫راﺳﺖ‬ ‫ﻣﻼﻗﺎت ﮔ ه‬ ‫‪.٣‬‬
‫‪٣‬‬ ‫}}‪S1 = {{1,, 7,, 8,, 9‬‬
‫‪...‬‬ ‫‪.۴‬‬ ‫}‪S2 = {2, 5, 10‬‬
‫}‪S3 = {3, 4, 6‬‬
‫• در زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا دارﻳﻢ‪:‬‬
‫ﻧﻜﺘﻪ‪ :‬ﭘﻴﻤﺎﻳﺶ ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﻄﺢ ﺟﻨﮕﻞ و ﭘﻴﻤﺎﻳﺶ ﺑﻪ ﺗﺮﺗﻴﺐ‬ ‫•‬
‫ﻳﻜﺴﺎن ﻧﻴﺴﺖ‪.‬‬
‫ﻣﺘﻨﺎﻇﺮ ﺑﺎ آن‪ ،‬ﻳﻜ ﺎن‬
‫دودوﻳﻲ ﻣﺘﻨﺎﻇ‬
‫درﺧﺖ دودوﻳ‬
‫ﺳﻄﺢ د ﺧﺖ‬ ‫‪• Si ⊆ S‬‬
‫)‪• Si Sj = ø (i ≠ j‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧١‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٧٢‬‬
 ‫ﻋﻤﻠﻴﺎت زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا‪:‬‬
‫ﻧﻤﺎﻳﺶ زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا‬
‫)‪UNION (i, j‬‬
‫• در اﻳﻦ ﻋﻤﻞ ﺗﻨﻬﺎ ﻛﺎﻓﻴﺴﺖ ﻛﻪ رﻳﺸﻪ ﻳﻚ درﺧﺖ را ﻓﺮزﻧﺪ رﻳﺸﻪ‬
‫ﻗﺮار دﻫﻴﻢ‪.‬‬
‫دﻳﮕﺮ ﻗ ا‬
‫درﺧﺖ ﮕ‬
‫ﺧ‬
‫‪1‬‬ ‫‪5‬‬ ‫‪3‬‬
‫• ﻣﺜﺎل‪ :‬ﻧﻤﺎﻳﺶ ﻫﺎي ﻣﻤﻜﻦ ﺑﺮاي ‪:S1 S2‬‬
‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪2‬‬ ‫‪10‬‬ ‫‪4‬‬ ‫‪6‬‬
‫‪1‬‬ ‫‪5‬‬

‫‪S1‬‬ ‫‪S2‬‬ ‫‪S3‬‬

‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪5‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪10‬‬

‫‪2‬‬ ‫‪10‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٧٣‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٧۴‬‬

‫ﻋﻤﻠﻴﺎت زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا‪:‬‬

‫ﻫﺎي ﺰا‬
‫ﻣﺠﺰا‬ ‫داده ززﻳﺮﻣﺠﻤﻮﻋﻪ ﺎ‬
‫ﺳﺎﺧﺘﻤﺎن ا‬
‫ﺳﺎزي ﺎﺧﺘ ﺎ‬
‫ﭘﻴﺎده ﺎز‬
‫ﺎ‬
‫)‪FIND (i‬‬
‫• از ﮔﺮه ‪ i‬و از ﻃﺮﻳﻖ اﺷﺎره ﮔﺮﻫﺎﻳﻲ ﻛﻪ ﺑﻪ ﭘﺪر ﮔﺮه ﻫﺎ وﺟﻮد دارد‪ ،‬ﺑﻪ ﺳﻤﺖ‬ ‫‪1‬‬ ‫‪2‬‬ ‫…‬ ‫‪MAX‬‬
‫ﺑﺮﺳﻴﻢ‪.‬‬
‫درﺧﺖ ﺑ ﺳ ﻢ‬
‫رﻳﺸﻪ د ﺧﺖ‬
‫ﻛﻨﻴﻢ ﺗﺎ ﺑﻪ ﻳﺸﻪ‬
‫ﺣﺮﻛﺖ ﻣﻣﻲ ﻛﻨ ﻢ‬
‫رﻳﺸﻪ ﺣ ﻛﺖ‬
‫ﻳﺸﻪ‬ ‫‪p‬‬
‫‪parent‬‬

‫• رﻳﺸﻪ درﺧﺖ را ﺑﻪ ﻋﻨﻮان ﻧﺎم ﻣﺠﻤﻮﻋﻪ ﺣﺎوي ﻋﻨﺼﺮ ‪ i‬ﺑﺮﻣﻲ ﮔﺮداﻧﻴﻢ‪.‬‬ ‫ﻣﺜﺎل‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪10‬‬
‫‪parent‬‬ ‫‪0‬‬ ‫‪5‬‬ ‫‪0‬‬ ‫‪3‬‬ ‫‪0‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪5‬‬
‫‪5‬‬ ‫ﻣﺜﺎل‪FIND (9) :‬‬
‫• ﺜﺎل‬

‫‪1‬‬ ‫‪2‬‬ ‫‪10‬‬ ‫‪1‬‬ ‫‪5‬‬ ‫‪3‬‬

‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪7‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪2‬‬ ‫‪10‬‬ ‫‪4‬‬ ‫‪6‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٧۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧۶‬‬
 ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻠﻴﺎت زﻳﺮﻣﺠﻤﻮﻋﻪ ﻫﺎي ﻣﺠﺰا‬ ‫ﻣﺜﺎل‬
‫• ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ در اﺑﺘﺪا‬
‫‪p‬‬
‫‪procedure‬‬ ‫;)‪UNION (i, j: integer‬‬
‫;) ‪g‬‬
‫‪1≤ i ≤ n‬‬ ‫}‪Si = {i‬‬
‫‪begin‬‬
‫ﯿﻢ‪:‬‬
‫ﯽ دﻫﯿﻢ‬‫م ﻣﯽ‬
‫اﻧﺠﺎم‬
‫ﻋﻤﻠﯿﺎت زﯾﺮ ررا ﺠ‬
‫ﯿ‬ ‫دﻧﺒﺎﻟﻪ‬
‫ل ﺒ‬ ‫• ﺣﺎل‬
‫‪parent [i] := j‬‬ ‫)‪UNION (1, 2) UNION (2, 3) UNION (3, 4) … UNION (n - 1, n‬‬
‫;‪end‬‬ ‫)‪FIND (1) FIND (2) … FIND (n‬‬

‫‪n‬‬
‫;‪function FIND (i: integer): integer‬‬ ‫ﺷﻮد‪:‬‬
‫ﺣﺎﺻﻞ ﻣﯽ ﺷ‬
‫درﺧﺖ ززﯾﺮ ﺎ ﻞ‬
‫ﻧﺘﯿﺠﻪ ﺧ‬
‫• در ﻧﺘ‬
‫‪begin‬‬ ‫‪.‬‬ ‫– ﻫﺰﯾﻨﻪ ﺗﻤﺎم ﻋﻤﻠﯿﺎت اﺟﺘﻤﺎع‪O(n) :‬‬
‫‪.‬‬
‫ﯾﺎﻓﺘﻦ‪O(n2) :‬‬
‫ﻋﻤﻠﯿﺎت ﺎﻓ‬
‫ﺗﻤﺎم ﻠ ﺎ‬
‫ﻫﺮﯾﻨﻪ ﺎ‬
‫– ﻫ ﻨ‬
‫‪while parent [i] > 0 do‬‬ ‫‪.‬‬

‫;]‪i := parent [i‬‬ ‫‪2‬‬

‫)‪return (i‬‬ ‫‪1‬‬

‫;‪end‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٧٧‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧٨‬‬

‫ﺑﻬﺒﻮد ﻋﻤﻠﻴﺎت ﻳﺎﻓﺘﻦ و اﺟﺘﻤﺎع‬ ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻞ اﺟﺘﻤﺎع‬

‫;)‪procedure WEIGHTED-UNION (i, j: integer‬‬
‫• ﺗﻌﺮﻳﻒ )ﻗﺎﻧﻮن وزﻧﻲ ﺑﺮاي اﺟﺘﻤﺎع ‪ i‬و ‪ :(j‬اﮔﺮ ﺗﻌﺪاد ﮔﺮه ﻫﺎ در‬ ‫‪var‬‬
‫درﺧﺘﻲ ﺎﺑﺎ ﺎﺑﺎ رﻳﺸﻪ ‪j‬‬
‫ﻫﺎ در ﺧ‬ ‫درﺧﺘﻲ ﺎﺑﺎ رﻳﺸﻪ ‪ ،i‬ﻛﻛﻤﺘﺮ ااز ا‬
‫ﺗﻌﺪاد ﮔﮔﺮه ﺎ‬ ‫ﺧ‬ ‫;‪temp: integer‬‬
‫‪i‬‬

‫ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬‫ﺻﻮرت ‪ i‬وواﻟﺪ ‪ j‬ﻮ‬

‫ﻦ ﻮر‬‫ﺷﻮد و درر ﻏﻴﺮﺮ اﻳﻦ‬
‫ﻲ ﻮ‬‫ﺑﺎﺷﺪ‪ j ،‬وواﻟﺪ ‪ i‬ﻣﻲ‬ ‫‪begin‬‬
‫;]‪temp := parent [i] + parent [j‬‬
‫‪if parent [i] > parent [j] then begin‬‬
‫;‪parent [i] := j‬‬
‫• اﺟﺮاي دﻧﺒﺎﻟﻪ ﻋﻤﻠﻴﺎت ﻣﺜﺎل ﻗﺒﻞ‪:‬‬ ‫‪parent [j] := temp‬‬
‫‪end else begin‬‬
‫‪1‬‬ ‫;‪parent [j] := i‬‬
‫‪parent [i] := temp‬‬
‫‪end‬‬‫‪d‬‬
‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫…‬ ‫‪n‬‬
‫;‪end‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٧٩‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٨٠‬‬
 WEIGHTED-U
UNION ‫اﻟﮕﻮرﻳﺘﻢ‬
‫ﻋﻤﻠﻜﺮد اﻟﮕ ﺘ‬
‫ ﻠﻜ‬:‫ﻣﺜﺎل‬
‫ﺜﺎل‬ WEIGHTED-U
UNION ‫اﻟﮕﻮرﻳﺘﻢ‬
‫ﻋﻤﻠﻜﺮد اﻟﮕ ﺘ‬
‫ ﻠﻜ‬:‫ﻣﺜﺎل‬
‫ﺜﺎل‬

• 1 ≤ i ≤ n = 8, parent [i] = - count [i] = - 1 • UNION (1, 2), UNION (3, 4), UNION (5, 6), UNION (7, 8)

• UNION (1, 2), UNION (3, 4), UNION (5, 6), UNION (7, 8),
UNION (1, 3), UNION (5, 7), UNION (1, 5) [-2] [-2] [-2] [-2]
1 3 5 7

2 4 6 8
[ 1]
[-1] [ 1]
[-1] [ 1]
[-1] [ 1]
[-1] [ 1]
[-1] [ 1]
[-1] [ 1]
[-1] [ 1]
[-1]
1 2 3 4 5 6 7 8

DS course- N. Razavi - ٢٠٠٧ ٨١ DS course- N. Razavi ٢٠٠٧ - ٨٢

WEIGHTED-U
UNION ‫اﻟﮕﻮرﻳﺘﻢ‬
‫ﻋﻤﻠﻜﺮد اﻟﮕ ﺘ‬
‫ ﻠﻜ‬:‫ﻣﺜﺎل‬
‫ﺜﺎل‬ WEIGHTED-U
UNION ‫اﻟﮕﻮرﻳﺘﻢ‬
‫ﻋﻤﻠﻜﺮد اﻟﮕ ﺘ‬
‫ ﻠﻜ‬:‫ﻣﺜﺎل‬
‫ﺜﺎل‬

• UNION (1, 3), UNION (5, 7) • UNION (1, 5)

[-8]
[[-4]
4] [[-4]
4] 1
1 5
2 3 5
2 3 6 7
4 6 7
4 8
8

DS course- N. Razavi - ٢٠٠٧ ٨٣ DS course- N. Razavi ٢٠٠٧ - ٨۴

 ‫ﻗﺎﻧﻮن ﺗﺨﺮﻳﺐ‬ COLLAPSING-F
FIND ‫ﭘﻴﺎده ﺳﺎزي ﻋﻤﻞ‬
function COLLAPSING-FIND (i: integer): integer;
‫ ﺗﺎ رﻳﺸﻪ اش‬i ‫ ﮔﺮه اي روي ﻣﺴﻴﺮ‬j ‫ اﮔﺮ‬:‫• ﺗﻌﺮﻳﻒ ﻗﺎﻧﻮن ﺗﺨﺮﻳﺐ‬ var
‫ ارا‬parentt [j] ‫ در ااﻳﻦ ﺻﻮرت‬،parentt [i] ≠ roott (i) ‫ﺑﺎﺷﺪ و‬
‫ﺎﺷ‬ r, s: integer;

.‫ﻢ داد‬
‫ﺧﻮاﻫﻴﻢ‬ ‫ ﺮ‬root (i) ‫ﺑﺮاﺑﺮﺮ‬
‫ﻗﺮارر ﻮ‬ ‫ﺮ‬ begin
r := i;
while parent [r] > 0 do
r := parent [r];
while i <> r do begin
s := parent [i];
pparent [i] := r;
i := s
end;
return (r)
end;

DS course- N. Razavi ٢٠٠٧ - ٨۵ DS course- N. Razavi - ٢٠٠٧ ٨۶

‫ و‬WEIGHTED-UNION ‫ﻋﻤﻠﻴﺎت‬
‫ﻴ‬ ‫ﺗﺤﻠﻴﻞ‬
‫ﻴ‬
‫ﻣﺜﺎل‬
COLLAPSING-FIND
• FIND (8), FIND (8), FIND (8), FIND (8), FIND (8), ‫ ﻛﻪ ﻫﺮ ﻛﺪام ﻳﻚ ﮔﺮه‬،‫• ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ ﺑﺎ ﺟﻨﮕﻠﻲ از درﺧﺖ ﻫﺎ‬
FIND (8),
(8) FIND (8),
(8) FIND (8) ‫ﺑﺮاي ا ش‬
‫ﭘﺮدازش‬ ‫زﻣﺎن ﻻﻻزم ا‬ ‫ اﻛ‬T (f, u) .‫ﺷﺮوع ﻛﻛﻨﻴﻢ‬
‫ﺣﺪاﻛﺜﺮ ﺎ‬ ‫دارد ﺷ‬
‫ا‬
u ≥ n/2 ‫ اﮔﺮﺮ‬.‫ﻞ اﺟﺘﻤﺎعع اﺳﺖ‬
‫ ﻋﻤﻞ‬u ‫ﻦ و‬ ‫ ﻋﻤﻞ‬f ‫ﻲ ازز‬
‫ﻞ ﻳﺎﻓﺘﻦ‬ ‫ﺗﺮﻛﻴﺒﻲ‬‫ﺮ‬
[-8]
:‫ اﺳﺘﻔﺎده ﺷﻮد‬FIND ‫• ﺗﻌﺪاد ﺣﺮﻛﺖ ﻫﺎ اﮔﺮ از‬ :k2 ‫ و‬k1 ‫ آﻧﮕﺎه ﺑﻪ ازاي ﻣﻘﺎدﻳﺮ ﻣﺜﺒﺖ‬،‫ﺑﺎﺷﺪ‬
1
3 × 8 = 24
2 3 5 :‫ اﺳﺘﻔﺎده ﺷﻮد‬COLLAPSING-FIND ‫• اﮔﺮ از‬
k1 (n + f α(f + n, n)) ≤ T(f, u) ≤ k2 (n + f α(f + n, n))
4 6
3 + 3 + 7 = 13
7

DS course- N. Razavi ٢٠٠٧ - ٨٧ DS course- N. Razavi - ٢٠٠٧ ٨٨

 ‫ﺗﻌﺮﻳﻒ ﺗﻮاﺑﻊ آﻛﺮﻣﺎن و )‪α (p, q‬‬ ‫ﺷﻤﺎرﺷﻲ‬
‫‪ 3‬ﻣﺴﺄﻟﻪ ﺷﻤﺎرﺷ‬
‫‪A (1, j) = 2j,‬‬ ‫‪j≥1‬‬ ‫• ﺷﻤﺎرش ﺗﻌﺪاد درﺧﺖ ﻫﺎي دودوﻳﻲ ﻣﺠﺰا ﺑﺎ اﻋﺪاد ‪ 1‬ﺗﺎ ‪n‬‬
‫‪A (i, 1) = A (i – 1,‬‬
‫)‪1 2‬‬ ‫‪i≥2‬‬ ‫• ﺷﻤﺎرش ﺗﻌﺪاد ﺟﺎﻳﮕﺸﺖ ﻫﺎي ﭘﺸﺘﻪ اي اﻋﺪاد ‪ 1‬ﺗﺎ ‪n‬‬
‫))‪A (i, j) = A (i – 1,, A (i, j – 1‬‬
‫))‬ ‫‪i, j ≥ 2‬‬ ‫ﺿﺮب ‪ n + 1‬ﺎﺗ‬
‫ﻣﺎﺗﺮﻳﺲ‬ ‫ﺑﺮاي ﺿ‬
‫ﻣﻤﻜﻦ اي‬
‫روش ﻫﺎي ﻜﻦ‬
‫ﺗﻌﺪاد ش‬ ‫• ﺷ ﺎش‬
‫ﺷﻤﺎرش ﺗ ﺪاد‬

‫‪α(p, q) = min {z ≥ 1 | A (z, floor (p / q)) > log2q }, p ≥ q ≥ 1‬‬

‫⎞ ‪1 ⎛ 2n‬‬
‫= )‪T ( n‬‬ ‫) ‪⎜⎜ ⎟⎟ = O(4 n / n1.5‬‬
‫⎠ ‪n +1⎝ n‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٨٩‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٩٠‬‬

‫درﺧﺖ ﻋﺒﺎرت )‪(Expression Tree‬‬ ‫درﺧﺖ ﻋﺒﺎرت )‪(Expression Tree‬‬

‫• ﺑﻬﺘﺮﻳﻦ ﻣﺪل ﺑﺮاي ﻳﻚ ﻋﺒﺎرت رﻳﺎﺿ‬
‫رﻳﺎﺿﻲ اﺳﺘﻔﺎده از درﺧﺖ ﻣﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫• ﺗﻌﺮﻳﻒ ﻓﺮم ﻋﺒﺎرت ﻛﺎﻣﻼً ﭘﺮاﻧﺘﺰي‬ ‫• ﻣﺜﺎل‪:‬‬
‫~‬
‫•‬ ‫)‪E ::= a | (α E) | (E β E‬‬ ‫))‪(~ (a + (b / c)) / (d ^ e‬‬
‫‪+‬‬
‫•‬ ‫‪a ::‬‬
‫‪::= variable‬‬
‫•‬ ‫)… ‪α ::= unary operator (~, sin, cos,‬‬ ‫‪a‬‬ ‫‪/‬‬

‫•‬ ‫)… ‪β ::= binary operator (^, ×, /, +, -,‬‬ ‫‪/‬‬ ‫^‬

‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬

‫• ﻣﺜﺎل‪:‬‬ ‫درﺧﺖ‬
‫ﻴﺐ ر‬
‫ﺗﺮﺗﻴﺐ‬
‫ﻴﺐ و ﭘﺲ ﺮ‬‫ﺗﺮﺗﻴﺐ‬‫ن ﺮ‬‫ﻣﻴﺎن‬
‫ﺗﺮﺗﻴﺐ‪ ،‬ﻴ‬
‫ي ﭘﻴﺶ ﺮ ﻴﺐ‬ ‫ﻳﺶ ﻫﺎي‬
‫ﭘﻴﻤﺎﻳﺶ‬‫• ﻧﻜﺘﻪ‪ :‬ﭘﻴ‬
‫))‪(~ (a + (b / c)) / (d ^ e‬‬ ‫ﻋﺒﺎرت ﺑﻪ ﺗﺮﺗﻴﺐ ﻣﻌﺎدل ﻓﺮﻣﻬﺎي ﭘﻴﺸﻮﻧﺪي‪ ،‬ﻣﻴﺎﻧﻮﻧﺪي و ﭘﺴﻮﻧﺪي ﻋﺒﺎرت‬
‫ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪٩١‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪٩٢‬‬
‫ﻋﺒﺎرت‬
‫درﺧﺖ ﺒ ر‬
‫ﺰي ﺑﺑﻪ ر‬
‫ﭘﺮاﻧﺘﺰي‬
‫ﻋﺒﺎرت ﻛﺎﻣﻼً ﭘﺮ‬
‫ﻳﻞ ﺒ ر‬
‫ﺗﺒﺪﻳﻞ‬
‫ﺒ‬ ‫درﺧﺖ ﺎ ت‬
‫ﻋﺒﺎرت‬ ‫ﭘﺮاﻧﺘﺰي ﺑﻪ ﺧﺖ‬
‫ﻛﺎﻣﻼ اﻧﺘﺰ‬
ً‫ت ﻛﺎ ﻼ‬
‫ﻋﺒﺎرت‬
‫ﺗﺒﺪﻳﻞ ﺎ‬
‫اﻟﮕﻮرﻳﺘﻢ ﺗ ﻞ‬
‫اﻟﮕ ﺘ‬
a E.T. a
function EXP-TREE (i, j: integer): TREE;
α α var
T: TREE;
α E1 E.T.
k: integer;
T1 T1 begin
if (i = j) then begin
β new (T);
i, j
T^.
^ label
l b l := A [i];
]
A … a …
E1 β E2 E.T. T^.left := nil;
T^.
^ right
i h := nil
il
T1 T2 end
DS course- N. Razavi - ٢٠٠٧ ٩٣ DS course- N. Razavi - ٢٠٠٧ ٩۴

‫درﺧﺖ ﺎ ت‬
‫ﻋﺒﺎرت‬ ‫ﭘﺮاﻧﺘﺰي ﺑﻪ ﺧﺖ‬
‫ﻛﺎﻣﻼ اﻧﺘﺰ‬
ً‫ت ﻛﺎ ﻼ‬
‫ﻋﺒﺎرت‬
‫ﺗﺒﺪﻳﻞ ﺎ‬
‫اﻟﮕﻮرﻳﺘﻢ ﺗ ﻞ‬
‫اﻟﮕ ﺘ‬ ‫درﺧﺖ ﺎ ت‬
‫ﻋﺒﺎرت‬ ‫ﭘﺮاﻧﺘﺰي ﺑﻪ ﺧﺖ‬
‫ﻛﺎﻣﻼ اﻧﺘﺰ‬
ً‫ت ﻛﺎ ﻼ‬
‫ﻋﺒﺎرت‬
‫ﺗﺒﺪﻳﻞ ﺎ‬
‫اﻟﮕﻮرﻳﺘﻢ ﺗ ﻞ‬
‫اﻟﮕ ﺘ‬

else if (A [i + 1] is a unary operator) then else begin

g
begin new (T);
new (T); k := MATCH (i + 1);
T^.label := A [i + 1]; T^.label := A [k + 1];
T^.
^ left
l f := EXP-T
TREE (i + 1,
1 k);
)
T^.left := nil;
T^.right := EXP-TREE (k + 2, j – 1)
T^.right := EXP-TREE (i + 2, j – 1)
end;
end return (T)
end;;
i i+1 i+2 j-1 j i i+1 k k+1 k+2 j-1 j
A … ( α E ) … A … ( E β E ) …

DS course- N. Razavi ٢٠٠٧ - ٩۵ DS course- N. Razavi ٢٠٠٧ - ٩۶

 MATCH (i) ‫ﭘﻴﺎده ﺳﺎزي ﺗﺎﺑﻊ‬ ‫ﺗﻤﺮﻳﻦ‬
function MATCH (i: integer): integer;
var
‫• اﻟﮕﻮرﻳﺘﻤﻲ ﺑﺮاي اﻳﺠﺎد درﺧﺖ ﻋﺒﺎرت از روي ﻓﺮم ﭘﺴﻮﻧﺪي‬
c, j: integer;
i .‫ﺑﻨﻮﻳﺴﻴﺪ‬
begin
c ::= 0;
j := i;
repeat
if A [j] = ‘(‘ then
th c := c + 1;1
if A [j] = ‘)‘ then c := c - 1;
j ::= j + 1;
until c = 0;
return (j – 1)
end;
d

DS course- N. Razavi ٢٠٠٧ - ٩٧ DS course- N. Razavi - ٢٠٠٧ ٩٨

‫ﻛﺎﻣﻼ ﭘﺮاﻧﺘﺰي‬
ً‫ﺗﺒﺪﻳﻞ درﺧﺖ ﻋﺒﺎرت ﺑﻪ ﻓﺮم ﻛﺎﻣﻼ‬ ‫ﻛﺎﻣﻼ ﭘﺮاﻧﺘﺰي‬
ً‫ﺗﺒﺪﻳﻞ درﺧﺖ ﻋﺒﺎرت ﺑﻪ ﻓﺮم ﻛﺎﻣﻼ‬
procedure PRINT-INFIX (T: TREE); if (T^.label is a binary operator) then begin
b i
begin write ((‘(‘);
( );
if (T^..label is a unary operator) then begin PRINT-INFIX (T^.left);
write (T^.label);
write (‘(‘);
PRINT-IINFIX (T^..right);
write (T^.label); write (‘)’)
PRINT-INFIX (T^.right); endd else
l
write (‘)’) write (T^.label)
end end;

DS course- N. Razavi ٢٠٠٧ - ٩٩ DS course- N. Razavi ٢٠٠٧ - ١٠٠

 ‫ﻃﺮح اول ﺑﺮاي ﻛﺪ ﮔﺬاري‪:‬‬
‫اﻟﮕﻮرﻳﺘﻢ ﻓﺸﺮده ﺳﺎزي ﻫﺎﻓﻤﻦ‬ ‫ﻛﺪ ﺑﺎﻳﻨﺮي ﺑﺎ ﻃﻮل ﺛﺛﺎﺑﺖ‬
‫• در اﻳﻦ روش اﮔﺮ ‪ n‬ﻛﺎراﻛﺘﺮ ﻣﺨﺘﻠﻒ داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪ ،‬ﺑﻪ ﻫﺮ ﻛﺪام ﻳﻚ ﻛﺪ ﺑﺎﻳﻨﺮي ﺑﺎ ﻃﻮل‬
‫• ﻣﺴﺄﻟﻪ‪:‬‬ ‫ﺛﺎﺑﺖ زﻳﺮ ﻧﺴﺒﺖ ﻣﻲ دﻫﻴﻢ‪:‬‬
‫– ورودي‪ :‬ﺗﻌﺪادي ﻛﺎراﻛﺘﺮ و اﺣﺘﻤﺎل وﻗﻮع ﻫﺮ ﻳﻚ از ﻛﺎراﻛﺘﺮﻫﺎ‬
‫زي ﺣﺪاﻗﻞ‬
‫ﻞ‬ ‫ﻓﺸﺮده ﺳﺎزي‬
‫ﺮﻳﺐ ﺮ‬‫ﻮري ﻛﻪ ﺿﺮﻳﺐ‬
‫ﻛﺎراﻛﺘﺮﻫﺎ ﺑﺑﻪ ﻃﻮري‬
‫ي ر ﺮ‬ ‫– ﺧﺮوﺟﻲ‬
‫ﺮوﺟﻲ‪ :‬ﻛﺪﻫﺎي‬ ‫ﻛﺎراﻛﺘﺮ‬ ‫ﻓﺮاواﻧﻲ‬ ‫ﻛﺪ ﺑﺎﻳﻨﺮي ﺑﺎ ﻃﻮل ‪3‬‬
‫= ﻃﻮل ﻛﺪ‬ ‫‪⎣lg n⎦ + 1‬‬
‫ﺷﻮد‪.‬‬ ‫‪a‬‬ ‫‪5‬‬ ‫‪000‬‬
‫اﻧﺪازه ﻓﺎﻳﻞ ﻓﺸﺮده ﺷﺪه‬
‫= ﺿﺮﻳﺐ ﻓﺸﺮده ﺳﺎزي‬ ‫‪b‬‬ ‫‪3‬‬ ‫‪001‬‬ ‫• ﻣﺤﺎﺳﺒﻪ اﻧﺪازه ﻓﺎﻳﻞ ﻛﺪ ﺷﺪه )ﺑﺮ ﺣﺴﺐ ﺑﻴﺖ(‪:‬‬
‫اﻧﺪازه ﻓﺎﻳﻞ اﺻﻠﻲ‬ ‫‪c‬‬ ‫‪6‬‬ ‫‪010‬‬
‫‪d‬‬ ‫‪1‬‬ ‫‪011‬‬
‫اﻧﺪازه ﻓﺎﻳﻞ ﻛﺪ ﺷﺪه =‬
‫ﻛﺎراﻛﺘﺮ‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪f‬‬ ‫‪g‬‬
‫• ﻣﺜﺎل‪:‬‬ ‫‪e‬‬ ‫‪8‬‬ ‫‪100‬‬ ‫‪3 × (5 + 3 + 6 + 1 + 8 + 4 + 2 ) = 87 bits‬‬
‫‪f‬‬ ‫‪2‬‬ ‫‪101‬‬
‫ﻓﺮاواﻧﻲ‬ ‫‪5‬‬ ‫‪3‬‬ ‫‪6‬‬ ‫‪1‬‬ ‫‪8‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫ﻛﻠﻤﻪ ﻛﺪ )‪(Code word‬‬
‫‪g‬‬ ‫‪4‬‬ ‫‪110‬‬
‫)‪(C d book‬‬
‫‪(Code‬‬ ‫ﻛﺘﺎب ﻛﻛﺪ )‪b k‬‬
‫ﻛﺎ‬
‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪١٠١‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١٠٢‬‬

‫ح دوم ﺑﺮاي ﻛﺪ ﮔﺬاري‪:‬‬

‫ﻃﺮح‬
‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬
‫ﻛﺪ ﺑﺎﻳﻨﺮي ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ‬
‫• اﻧﮕﻴﺰه‪ :‬اﺳﺘﻔﺎده از ﻛﻠﻤﺎت ﻛﺪ ﺑﺎ ﻃﻮل ﻛﻤﺘﺮ ﺑﺮاي ﻛﺎراﻛﺘﺮﻫﺎﻳﻲ ﻛﻪ ﻓﺮاواﻧﻲ‬ ‫• ﻣﺮﺣﻠﻪ ‪ (2‬ﻋﻤﻠﻴﺎت زﻳﺮ را ‪ n – 1‬ﺑﺎر ﺗﻜﺮار ﻛﻦ‪:‬‬
‫دارﻧﺪ‪.‬‬
‫ﺑﻴﺸﺘﺮي دا ﻧﺪ‬
‫ﺑ ﺸﺘ ي‬ ‫وزﻧﻬﺎي ‪ w1‬و ‪w2‬‬
‫ﻛﻤﺘﺮﻳﻦ ﻧ ﺎ‬
‫داراي ﻛ ﺘ‬
‫آﻧﻬﺎ ا ا‬ ‫درﺧﺖ ‪ T1‬و ‪ T2‬ارا ﻛﻛﻪ ﺸ‬
‫رﻳﺸﻪ آﻧ ﺎ‬ ‫– ﻫﺮ ﺎﺑﺎر دو ﺧﺖ‬
‫ﻫﺴﺘﻨﺪ اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫زﻳﺮدرﺧﺘﺎن ﭼﭗ و اراﺳﺖ آآن‬
‫ﺎ‬ ‫اﻳﺠﺎد ﻛﻛﻦ ﻛﻛﻪ ‪ T1‬و ‪T2‬‬
‫ﻳﻚ درﺧﺖ دودوﻳﻲ ﺟﺪﻳﺪ ا ﺎ‬ ‫– ﻚ‬
‫• راه ﺣﻞ‪ :‬اﺳﺘﻔﺎده از روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‪:‬‬
‫ﺑﺎﺷﻨﺪ و وزن رﻳﺸﻪ آن ‪ w1 + w2‬ﺑﺎﺷﺪ‪.‬‬
‫– ﻣﺮﺣﻠﻪ ‪ (1‬ﺑﻪ ازاي ﻫﺮ ﻛﺎراﻛﺘﺮ ﻳﻚ درﺧﺖ دودوﻳ‬
‫دودوﻳﻲ ﺗﻚ ﮔﺮه اي اﻳﺠﺎد و وزن‬
‫رﻳﺸﻪ آن درﺧﺖ را ﺑﺮاﺑﺮ ﺑﺎ اﺣﺘﻤﺎل ﻛﺎراﻛﺘﺮ ﻣﺮﺑﻮﻃﻪ ﻗﺮار ﻣﻲ دﻫﻴﻢ‪.‬‬ ‫‪w1 + w2‬‬

‫‪w1‬‬ ‫‪w2‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪8‬‬
‫‪d‬‬ ‫‪f‬‬ ‫‪b‬‬ ‫‪g‬‬ ‫‪a‬‬ ‫‪c‬‬ ‫‪e‬‬
‫‪T1‬‬ ‫‪T2‬‬

‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪١٠٣‬‬ ‫‪DS course- N. Razavi - ٢٠٠٧‬‬ ‫‪١٠۴‬‬
‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬ ‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬

3 3 4 5 6 8 4 5 6 6 8
b g a c e g a c e
1 2 3 3

d f b
1 2
d f

DS course- N. Razavi ٢٠٠٧ - ١٠۵ DS course- N. Razavi - ٢٠٠٧ ١٠۶

‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬ ‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬

6 6 8 9 8 9 12

c e e
3 3 4 5 4 5 6 6
b g a g a c
1 2 3 3

d f b
1 2
d f

DS course- N. Razavi ٢٠٠٧ - ١٠٧ DS course- N. Razavi ٢٠٠٧ - ١٠٨

 ‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬ ‫روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬

‫‪29‬‬

‫‪12‬‬ ‫‪17‬‬ ‫‪12‬‬ ‫‪17‬‬

‫‪6‬‬ ‫‪6‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪6‬‬ ‫‪6‬‬ ‫‪8‬‬ ‫‪9‬‬

‫‪c‬‬ ‫‪e‬‬ ‫‪c‬‬ ‫‪e‬‬
‫‪3‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪3‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫‪b‬‬ ‫‪g‬‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪g‬‬ ‫‪a‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪2‬‬
‫‪d‬‬ ‫‪f‬‬ ‫‪d‬‬ ‫‪f‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١٠٩‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١٠‬‬

‫ﮔﺬاري ﻫﺎﻓﻤﻦ‬
‫ﻦ‬ ‫روش ﻛﺪ ري‬ ‫ﻳﻚ ﻗﻀﻴﻪ ﻣﺮﺗﺒﻂ‬
‫• ﻣﺮﺣﻠﻪ ‪ (3‬ﺗﻮﻟﻴﺪ ﻛﺪ ﻛﺎراﻛﺘﺮﻫﺎ‪:‬‬
‫ﺑﺮﭼﺴﺐ ‪) 1‬و ﺎﻳﺎ ﻋﻜ‬
‫ﺑﺮﻋﻜﺲ(‬ ‫راﺳﺖ ﭼ‬
‫ﺑﻪ ﺷﺎﺧﻪ ﻫﺎي ا ﺖ‬ ‫ﺑﺮﭼﺴﺐ ‪ 0‬و ﻪ‬‫ﭼﭗ ﭼ‬ ‫ﺑﻪ ﺷﺎﺧﻪ ﻫﺎي ﭼ‬ ‫ﻧﻬﺎﻳﻲ‪ ،‬ﻪ‬ ‫– ددر د ﺧﺖ‬
‫درﺧﺖ ﻧﻬﺎ‬
‫ﻣﻲ دﻫﻴﻢ‪.‬‬ ‫• ﻗﻀﻴﻪ‪ :‬ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﺎ ‪ n‬ﮔﺮه ﺑﺮگ‪ ،‬داراي ‪n – 1‬‬
‫ﻣﻮﺟﻮد‬
‫ي ﻮﺟﻮ‬‫ﺐ ﻫﺎي‬‫ﺑﺮﭼﺴﺐ‬
‫ﭘﻴﻤﻮده و ﺑﺮﭼ‬
‫ﻛﺎراﻛﺘﺮﺮ ررا ﭘﻴ ﻮ‬
‫ن ر‬ ‫ﻣﺮﺑﻮط ﺑﺑﻪ آن‬
‫ﺑﺮگ ﺮﺑﻮ‬
‫رﻳﺸﻪ ﺗﺎ ﺑﺮ‬
‫ﻴﺮ ازز رﻳ‬
‫ﻛﺎراﻛﺘﺮ‪ ،‬ﻣﺴﻴﺮ‬
‫ي ﻫﺮﺮ ر ﺮ‬ ‫– ﺑﺑﻪ زازاي‬
‫در ﻣﺴﻴﺮ را ﺑﻪ ﻋﻨﻮان ﻛﺪ آن ﻛﺎراﻛﺘﺮ در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮﻳﻢ‪.‬‬ ‫ﺑﺎﺷﺪ‪.‬‬
‫داﺧﻠﻲ ﻣﻲ ﺎﺷ‬
‫ﮔﮔﺮه اﺧﻠ‬
‫‪29‬‬
‫‪0‬‬ ‫‪1‬‬ ‫ﻛﺎراﻛﺘﺮ‬
‫ﻛﺎ اﻛ‬ ‫ﻫﺎﻓﻤﻦ‬
‫ﻛﻛﺪ ﺎﻓ‬

‫‪0‬‬
‫‪12‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪17‬‬
‫‪1‬‬
‫‪a‬‬ ‫‪111‬‬ ‫• اﺛﺒﺎت‪ :‬از ﻃﺮﻳﻖ اﺳﺘﻘﺮا روي ‪n‬‬
‫‪b‬‬ ‫‪001‬‬
‫‪6‬‬ ‫‪6‬‬ ‫‪8‬‬ ‫‪9‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪c‬‬ ‫‪01‬‬
‫‪c‬‬ ‫‪e‬‬
‫‪3‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪d‬‬ ‫‪0000‬‬
‫‪0‬‬ ‫‪1‬‬
‫‪b‬‬ ‫‪g‬‬ ‫‪a‬‬ ‫‪e‬‬ ‫‪10‬‬
‫‪1‬‬ ‫‪2‬‬
‫‪76‬‬ ‫‪f‬‬ ‫‪0001‬‬
‫‪d‬‬ ‫‪f‬‬ ‫ﺿﺮﻳﺐ ﻓﺸﺮده ﺳﺎزي =‬
‫‪87‬‬ ‫‪g‬‬ ‫‪110‬‬
‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١١‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١٢‬‬
 ‫‪ 2‬ﻧﻜﺘﻪ در ﻣﻮرد روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ‬ ‫رﻣﺰﮔﺸﺎﻳﻲ(‬
‫دﻳﻜﻮد ﻛﺮدن )رﻣﺰﮔﺸﺎﻳ‬
‫• روش ﻛﺪ ﮔﺬاري ﻫﺎﻓﻤﻦ ﺑﻬﻴﻨﻪ ﻣﻲ ﺑﺎﺷﺪ‪ ،‬ﻳﻌﻨﻲ ﺑﺎ اﻳﻦ روش‬ ‫‪0001111000010‬‬
‫ﺷﻮد‪.‬‬
‫ﺣﺪاﻗﻞ ﻣﻲ ﺷ‬
‫ﺳﺎزي اﻗﻞ‬‫ﻓﺸﺮده ﺎ‬
‫ﺿﺮﻳﺐ ﻓﺸ‬
‫ﺿ‬ ‫‪29‬‬

‫‪12‬‬ ‫‪17‬‬
‫• ﻛﺪﻫﺎي ﺑﻪ دﺳﺖ آﻣﺪه ﺧﺎﺻﻴﺖ ﭘﻴﺸﻮﻧﺪي دارﻧﺪ‪ ،‬ﻳﻌﻨﻲ در ﻛﺘﺎب‬
‫‪6‬‬ ‫‪6‬‬ ‫‪8‬‬ ‫‪9‬‬
‫ﻛﺪ ﻫﻴﭻ ﻛﻠﻤﻪ ﻛﺪي ﭘﻴﺸﻮﻧﺪ ﻛﻠﻤﻪ ﻛﺪ دﻳﮕﺮي ﻧﻤﻲ ﺑﺎﺷﺪ‪.‬‬ ‫‪c‬‬ ‫‪e‬‬
‫‪3‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬
‫ﺳﺎدﮔﻲ ﻗﺎﺑﻞ‬
‫ﻛﺮدن ﺑﺎ ﻳﻚ ﺑﺎﺑﺎر ﭘﻮﻳﺶ ﻓﺎﻳﻞ ﻛﺪ ﺷﺪه ﺑﻪ ﺳﺎدﮔ‬ ‫– ددر ﻧﺘ ﺠﻪ‬
‫ﻧﺘﻴﺠﻪ دﻳﻜﻮد ﻛ دن‬
‫‪b‬‬ ‫‪g‬‬ ‫‪a‬‬
‫اﻧﺠﺎم ﻣﻲ ﺑﺎﺷﺪ‪.‬‬ ‫‪1‬‬ ‫‪2‬‬

‫– ﻣﺜﺎل‪ :‬رﺷﺘﻪ ‪ 0001111000010‬را دﻳﻜﻮد ﻧﻤﺎﻳﻴﺪ‪.‬‬ ‫‪d‬‬ ‫‪f‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١٣‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١۴‬‬

‫ﭘﻴﺎده ﺳﺎزي اﻟﮕﻮرﻳﺘﻢ ﻫﺎﻓﻤﻦ‬ ‫ﺗﻤﺮﻳﻦ‬

‫‪root‬‬ ‫‪weight‬‬ ‫‪symbol‬‬ ‫‪prob‬‬ ‫‪leaf‬‬ ‫‪left‬‬ ‫‪right‬‬ ‫‪parent‬‬

‫• اﻟﮕﻮرﻳﺘﻢ ﻓﺸﺮده ﺳﺎزي ﻫﺎﻓﻤﻦ را ﭘﻴﺎده ﺳﺎزي ﻧﻤﺎﻳﻴﺪ‪.‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪2‬‬ ‫‪2‬‬
‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫‪n‬‬ ‫‪n‬‬ ‫‪2n-1‬‬

‫‪FOREST‬‬ ‫‪ALPHABET‬‬ ‫‪TREE‬‬

‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١۵‬‬ ‫‪DS course- N. Razavi ٢٠٠٧ -‬‬ ‫‪١١۶‬‬