Uploaded by tiptop.boy88

Heap

advertisement
‫‪HEAP‬‬
‫‪1‬‬
‫ﺑﺎ ﺳﻼم و ﻋﺮض ﭘﻮزش ﺑﺮاي ﺗﺎﺧﻴﺮ در ارﺳﺎل ﻓﺎﻳﻞ ذﻛﺮ ﭼﻨﺪ ﻧﻜﺘﻪ را ﺑﺮاي داوﻃﻠﺒﻴﻦ ﻣﺤﺘﺮم ﻻزم ﻣﻲ داﻧﻢ‪:‬‬
‫‪ -1‬در اﻳﻦ ﻣﺠﻤﻮﻋﻪ ﻛﻪ ﻳﻜﻲ از ﻓﺼﻠﻬﺎي آن )ﻓﺼﻞ ‪ (heap‬در اداﻣﻪ ﺗﻘﺪﻳﻢ ﻣﻲ ﮔﺮدد ‪ .‬ﺳﻌﻲ ﺑﺮآن ﺷﺪه اﺳﺖ ﻛﻪ از ﺗﺠﺮﺑﻴﺎت ﺗﺪرﻳﺲ در ﻛﻼﺳﻬﺎي‬
‫ﻣﺨﺘﻠﻒ اﺳﺘﻔﺎده ﺷﻮد و ﺗﺎ ﺟﺎي ﻣﻤﻜﻦ ﺗﻤﺎم ﺳﻠﻴﻘﻪ ﻫﺎ را ﭘﻮﺷﺶ دﻫﺪ‬
‫‪ -2‬در ﺳﻮاﻻت اﻧﺘﻬﺎي ﻓﺼﻞ از ﻣﺠﻤﻮﻋﻪ ﺳﻮاﻻت ﻛﻨﻜﻮر ‪ ،‬داﻧﺸﮕﺎه ﻣﻌﺘﺒﺮ ‪ ، MIT‬ﻛﺘﺎب ‪ CLRS‬و ﺳﺎﻳﺘﻬﺎي ﻣﻌﺘﺒﺮ ﻛﻪ ﺳﻮاﻻت ﻛﻨﻜﻮر از آن ﻃﺮح ﻣﻲ‬
‫ﺷﻮد اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ﺑﻄﻮر ﻣﺜﺎل در دو ﺳﺎل ﮔﺬﺷﺘﻪ ﺳﻮاﻻت ﻣﺮﺑﻮط ﺑﻪ ﻓﺼﻞ ‪ hash‬از آدرس زﻳﺮ ﻛﭙﻲ ﺷﺪه اﺳﺖ ﺧﻮدﺗﺎن ﻣﺸﺎﻫﺪه و ﻗﻀﺎوت‬
‫ﻛﻨﻴﺪ‬
‫ﻛﻨﻜﻮر ‪:93‬‬
‫‪http://math.stackexchange.com/questions/915009/hashing-with-chaining-collision‬‬
‫ﻛﻨﻜﻮر ‪http://math.stackexchange.com/questions/1145022/hash-with-chaining-problems?rq=1 :94‬‬
‫ﻣﺠﻤﻮﻋﻪ اي ﻛﻪ در ﺷﻬﺮﻳﻮر ‪ 1394‬آﻣﺎده ﻣﻲ ﺷﻮد ﺑﻪ ﮔﻮﻧﻪ اي اﺳﺖ ﻛﻪ در ﻛﻤﺘﺮﻳﻦ زﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﻣﻄﺎ ﻟﺐ ﻛﻨﻜﻮر و ﻣﺮﺗﺒﻂ ﺑﺎ ﻛﺘﺎب ‪ CLRS‬و ﻫﻤﻴﻨﻄﻮر‬
‫ﺳﻮاﻻت ﻛﺘﺎب ‪ 600‬ﻣﺴﺌﻠﻪ را ﺑﺎ ﺑﻴﺎﻧﻲ ﺳﺎده ﺗﺮ در اﺧﺘﻴﺎر داوﻃﻠﺒﺎن ﻗﺮار دﻫﺪ اﻣﻴﺪ وارم ﻛﻪ اﻳﻨﻄﻮر ﺑﺎﺷﺪ‬
‫ﺧﻮاﻫﺸﻤﻨﺪ اﺳﺖ ﺑﺎ ﻣﻄﺎﻟﻌﻪ ﻓﺼﻞ ﺣﺎﺿﺮ ﻧﻈﺮات و ﭘﻴﺸﻨﻬﺎدات ﺧﻮد را ﺑﻪ آدرس ‪ mh_tourani@yahoo.com‬ارﺳﺎل ﻓﺮﻣﺎﻳﻴﺪ‪.‬‬
‫ﺑﺎ اﺣﺘﺮام‬
‫ﻣﺤﺴﻦ ﻃﻮراﻧﻲ‬
‫‪2‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪HEAP‬‬
‫ﭘﻴﺸﻨﻴﺎز ﻓﺼﻞ‪ :‬ﻣﺮﺗﺒﻪ زﻣﺎﻧﻲ‪ ،‬ﺗﻮاﺑﻊ ﺑﺎزﮔﺸﺘﻲ‪ ،‬درﺧﺘﻬﺎي دودوﻳﻲ‬
‫‪ : max tree‬درﺧﺖ دودوﻳﻲ ﻛﻪ در آن ﻣﻘﺪار ﻛﻠﻴﺪ در ﻫﺮ ﮔﺮه ﺑﺰرگﺗﺮ ﻳﺎ ﻣﺴﺎوي ﺑﺎ ﻓﺮزﻧﺪاﻧﺶ ﺑﻮده و رﻳﺸﻪ درﺧﺖ ﺑﺰرگﺗﺮﻳﻦ ﻣﻘﺪار ﻛﻠﻴﺪ را دارد‪.‬‬
‫‪ : min tree‬درﺧﺘﻲ دودوﻳﻲ ﻛﻪ در آن ﻣﻘﺪار ﻛﻠﻴﺪ در ﻫﺮ ﮔﺮه ﻛﻮﭼﻚﺗﺮ ﻳﺎ ﻣﺴﺎوي ﺑﺎ ﻓﺮزﻧﺪاﻧﺶ ﺑﻮده و رﻳﺸﻪ درﺧﺖ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻣﻘﺪار ﻛﻠﻴﺪ را دارد‪.‬‬
‫ﻧﺎم ﺳﺎﺧﺘﺎر‬
‫ﻣﻮارد اﺳﺘﻔﺎده‬
‫‪) HEAP‬ﻫﺮم‪ ،‬ﻛﻮﻣﻪ‪ ،‬آراﻳﻪ ﻧﻴﻤﻪ ﻣﺮﺗﺐ‪(...،‬‬
‫ﺻﻒ اوﻟﻮﻳﺖ‪ ،‬ﻣﺮﺗﺐﺳﺎزي‪ ،‬ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ‬
‫ﺳﺎﺧﺘﻤﺎن دادهآي از ﻧﻮع آراﻳﻪ اﺳﺖ ﻛﻪ ﺑﻪ ﺻﻮرت ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﻧﻤﺎﻳﺶ داده ﺷﺪه و ﺑﺮ دو ﻧﻮع اﺳﺖ‪ max heap :‬و ‪ ، min heap‬در ﺻﻮرﺗﻲ ﻛﻪ‬
‫ﻧﻮعِ ‪ heap‬ﻣﺸﺨﺺ ﻧﺒﺎﺷﺪ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض آن را ‪ max heap‬در ﻧﻈﺮ ﻣﻲﮔﻴﺮﻳﻢ‪ ،‬ﻋﻠﺖ اﻳﻦ اﻣﺮ ﻣﺮﺑﻮط ﺑﻪ ﻳﻜـﻲ از ﻛﺎرﺑﺮدﻫـﺎي درﺧـﺖ )ﺻـﻒ اوﻟﻮﻳـﺖ(‬
‫ﻣﻲﺑﺎﺷﺪ ﻛﻪ در ﻣﺒﺤﺚ ﻣﺮﺑﻮﻃﻪ ﺑﻪ آن ﺧﻮاﻫﻴﻢ ﭘﺮداﺧﺖ‪،‬در اداﻣﻪ ﺑﻪ ﺑﺮرﺳﻲ و ﺗﺤﻠﻴﻞ ﻫﺮﻳﻚ از اﻳﻦ دو ﻧﻮع ﻣﻲﭘﺮدازﻳﻢ‪:‬‬
‫ﻣﺜﺎل‬
‫ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر‬
‫ﻧﺎم ﺳﺎﺧﺘﺎر‬
‫‪max heap‬‬
‫درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﻛﻪ وﻳﮋﮔﻲ درﺧﺖ‬
‫‪ max tree‬را داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫‪HEAP‬‬
‫‪min heap‬‬
‫ﻧﻤﺎﻳﺶ درﺧﺖ‬
‫‪3‬‬
‫درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﻛﻪ وﻳﮋﮔﻲ درﺧﺖ‬
‫‪ min tree‬را داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫‪Heap‬‬
‫درﺧﺖ ‪ heap‬ﻫﻤﻮاره ﺑﻪ ﻳﻜﻲ از دو ﺷﻜﻞِ »درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ« ﻳﺎ »آراﻳﻪ« ﻧﻤﺎﻳﺶ داده ﻣﻲﺷﻮد‪ ،‬اﻳﻦ ﻧﻤﺎﻳﺶ ﺑﺮاي ﻳﻚ ‪ heap‬ﺑـﺎ ‪ 10‬ﮔـﺮه ﺑـﻪ ﺷـﻜﻞ زﻳـﺮ‬
‫ﺧﻮاﻫﺪ ﺑﻮد ‪:‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ در ﺷﻜﻞ ﻣﻲﺑﻴﻨﻴﺪ ﺷﻤﺎره اﻧﺪﻳﺲ ‪ 1‬ﻣﺘﻌﻠﻖ ﺑﻪ رﻳﺸﻪ ﺑﻮده ﻫﻤﭽﻨﻴﻦ ﺑﺎ داﺷﺘﻦ ﺷﻤﺎره اﻧﺪﻳﺲِ ‪ i‬ﺑﺮاي ﻫـﺮ ﮔـﺮه ﺑـﻪ ﺳـﺎدﮔﻲ ﻣـﻲﺗـﻮاﻧﻴﻢ ﺷـﻤﺎره‬
‫اﻧﺪﻳﺲﻫﺎي ﮔﺮه ﭘﺪر )واﻟﺪ(‪ ،‬ﻓﺮزﻧﺪ ﭼﭗ و ﻓﺮزﻧﺪ راﺳﺖ را ﺑﺮاي آن ﮔﺮه ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﻢ‪.‬‬
‫‪LEFT  i  Right  i ‬‬
‫‪return 2i  1‬‬
‫‪parent  i ‬‬
‫‪i‬‬
‫‪return   return 2i‬‬
‫‪2‬‬
‫‪maxheap‬‬
‫‪minheap‬‬
‫وﻳﮋﮔﻲﻫﺎي ‪ Length‬و ‪ heap  size‬در ﻧﻤﺎﻳﺶ آراﻳﻪ‬
‫‪ :A.Length‬ﺗﻌﺪاد ﻋﻨﺎﺻﺮ در آراﻳﻪ ‪ A‬را ﻧﺸﺎن ﻣﻲدﻫﺪ‪.‬‬
‫‪ : :A.heap _ size‬ﺗﻌﺪاد ﻋﻨﺎﺻﺮي از ‪ heap‬ﻛﻪ در آراﻳﻪ ‪ A‬ذﺧﻴﺮه ﺷﺪه اﺳﺖ و ﺑﻪ ﻋﻨﻮان ﻋﻨﺎﺻﺮ ﻣﻌﺘﺒﺮ ﻣﺤﺴﻮب ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫‪0  A.heap _ size  A.Length‬‬
‫دﻗﺖ ﻛﻨﻴﺪ‪ :‬ﺻﺮفﻧﻈﺮ از اﻳﻦ ﻛﻪ ﭼﻪ ﻋﻨﺎﺻﺮي در آراﻳﻪ ‪ A 1...Length ‬ﻗـﺮار دارﻧـﺪ ﻓﻘـﻂ و ﻓﻘـﻂ ﻋﻨﺎﺻـﺮي از ‪ heap‬ﻣﻌﺘﺒـﺮ ﺧﻮاﻫﻨـﺪ ﺑـﻮد ﻛـﻪ در ﺑـﺎزة‬
‫‪ A 1..heap _ size ‬ﻗﺮار دارﻧﺪ‪ .‬ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪،‬‬
‫‪4‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﺑﺎ اﻳﻦ ﻛﻪ ‪ A.length  9‬اﺳﺖ اﻣﺎ از آن ﺟﺎ ﻛﻪ ‪ A  heap _ size  6‬اﺳﺖ ﻓﻘﻂ ﺷﺶ ﻋﻀﻮ از آراﻳﻪ ﺑﻪ ﻋﻨﻮان ﻋﻨﺎﺻﺮي از ‪ heap‬ﻣﻌﺘﺒﺮ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻋﻤﻖ ﮔﺮه در درﺧﺖ‬
‫‪Heap‬‬
‫ﻋﻤﻖ ﻫﺮ ﮔﺮه دﻟﺨﻮاه ﺑﺎ ﺷﻤﺎرة ‪ i‬در ﻳﻚ درﺧﺖ ‪ Heap‬ﻣﺎﻧﻨﺪ ﻫﺮ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﺮاﺑﺮ ﺑﺎ ‪ lg i ‬اﺳﺖ‪.‬‬
‫ﻋﻤﻖ درﺧﺖ‬
‫‪Heap‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ ﻣﻲداﻧﻴﻢ ﻋﻤﻖ ﻫﺮ درﺧﺖ ﺑﺮاﺑﺮ ﺑﺎ ﻋﻤﻖِ ﭘﺎﻳﻴﻦﺗﺮﻳﻦ ﺑﺮگ‪ ‬آن اﺳﺖ در درﺧﺖ ‪ heap‬ﻣﺎﻧﻨﺪ‪ ‬ﻫﺮ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ‪ ،‬آﺧﺮﻳﻦ ﮔﺮه ﺑﺎ ﺷﻤﺎرة ‪ n‬ﺑﻪ‬
‫ﻋﻨﻮان ﻳﻜﻲ از ﭘﺎﻳﻴﻦﺗﺮﻳﻦ ﺑﺮگﻫﺎ ﺷﻨﺎﺧﺘﻪ ﻣﻲﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﻋﻤﻖ اﻳﻦ ﮔﺮه ﻫﻤﺎن ﻋﻤﻖ درﺧﺖ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪  lg n ‬ﻋﻤﻖ درﺧﺖ ‪heap‬‬
‫ارﺗﻔﺎع ﮔﺮه در درﺧﺖ‬
‫‪Heap‬‬
‫‪n‬‬
‫‪‬‬
‫ارﺗﻔﺎع ﻫﺮ ﮔﺮه دﻟﺨﻮاه ﺑﺎ ﺷﻤﺎرة ‪ i‬در ﻳﻚ درﺧﺖ ‪ Heap‬ﺑﺎ ‪ n‬ﻛﻠﻴﺪ ﻣﺎﻧﻨﺪ ﻫﺮ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﺮاﺑﺮ ﺑﺎ ‪ lg ‬اﺳﺖ‪.‬‬
‫‪ i‬‬
‫ارﺗﻔﺎع درﺧﺖ‬
‫‪Heap‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ ﻣﻲداﻧﻴﻢ ارﺗﻔﺎع ﻫﺮ درﺧﺖ ﺑﺮاﺑﺮ ﺑﺎ ارﺗﻔﺎع ﮔﺮه رﻳﺸﻪ ‪  i  1‬اﺳﺖ‬
‫‪ n‬‬
‫‪  lg    lg n ‬ارﺗﻔﺎع درﺧﺖ ‪heap‬‬
‫‪ 1‬‬
‫راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ ارﺗﻔﺎع درﺧﺖ‬
‫‪Heap‬‬
‫در درﺧﺖ ‪ heap‬ﻣﺎﻧﻨﺪ‪ ‬ﻫﺮ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ‪ ،‬ﺑﻴﺶﺗﺮﻳﻦ ارﺗﻔﺎع زﻣﺎﻧﻲ اﺗﻔﺎق ﻣﻲاﻓﺘﺪ ﻛﻪ در آن ﺳﻄﺢ آﺧﺮ دﻗﻴﻘﺎً ﻧﻴﻤﻪ ﭘﺮ ﺑﺎﺷﺪ‪ ،‬ﭼـﺮا ﻛـﻪ در اﻳـﻦ ﺻـﻮرت‬
‫ﺗﻌﺪاد ﺑﻴﺶﺗﺮي ﮔﺮه در ﻳﻚ زﻳﺮ درﺧﺖ ﻗﺮار ﮔﺮﻓﺘﻪاﻧﺪ ﺑﻪ ﺷﻜﻞ زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫اﮔﺮ ‪ H  n ‬راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ ﻣﺮﺑﻮط ﺑﻪ ارﺗﻔﺎع درﺧﺖ ‪ Heap‬ﺑﺎ ‪ n‬ﮔﺮه ﺑﺎﺷﺪ آﻧﮕﺎه ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺷﻜﻞ ﻓﻮق رواﺑﻂ زﻳﺮ ﺑﺮاي آن ﺑﺮﻗﺮار اﺳﺖ‪:‬‬
‫‪‬‬
‫‪  2n  ‬‬
‫‪H  n   H      1  H  n   O  lg n ‬‬
‫‪‬‬
‫‪ 3 ‬‬
‫‪ H  n     lg n ‬‬
‫‪‬‬
‫‪H n  H   n    1  H n   lg n‬‬
‫‪   ‬‬
‫‪ ‬‬
‫‪  ‬‬
‫‪3‬‬
‫‪‬‬
‫‪HEAP‬‬
‫ﺣﺪاﻛﺜﺮ ﮔﺮه ﺑﻪ ارﺗﻔﺎع‬
‫‪5‬‬
‫‪h‬‬
‫‪ n ‬‬
‫‪ ‬ﮔﺮه ﺑﻪ ارﺗﻔﺎع ‪h‬‬
‫در ﻫﺮ درﺧﺖ ‪ Heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﺣﺪاﻛﺜﺮ ‪‬‬
‫‪ 2h 1 ‬‬
‫وﺟﻮد دارد‪ clrs, 6.3  3 .‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ ﻣﻲداﻧﻴﺪ درﺧﺖ دودوﻳﻲ ﭘﺮ ﺣﺎﻟﺖ ﺧﺎﺻﻲ از درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ )ﻣﺎﻧﻨﺪ‪ ( Heap :‬اﺳﺖ ﻛﻪ در آن ﺳﻄﺢ آﺧﺮ ﻧﻴﺰ ﻣﺎﻧﻨﺪ ﺳﻄﻮحِ ﻣﺎﻗﺒﻞ ﻛﺎﻣﻼً ﭘﺮ‬
‫اﺳﺖ در اﻳﻦ وﺿﻌﻴﺖ ﺑﺮاي ﻫﺮ ارﺗﻔﺎﻋﻲ از درﺧﺖ ﺣﺪاﻛﺜﺮ ﮔﺮه را ﺧﻮاﻫﻴﻢ داﺷﺖ‪ ،‬ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺑﺮاي ﻳﻚ درﺧﺖ دودوﻳﻲ ﭘﺮ ﺑـﺎ ‪ n  15‬ﮔـﺮه ﺗﻮﺟـﻪ ﻛﻨﻴـﺪ ﺗـﺎ‬
‫درﺳﺘﻲ ﻋﺒﺎرت ﺑﺎﻻ ﻣﺸﺨﺺ ﺷﻮد‪:‬‬
‫ﺑﺮرﺳﻲ ‪heap‬‬
‫آراﻳﺔ ‪ n‬ﺧﺎﻧﻪايِ ‪ A‬را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ ﻛﻪ ﺑﺮاي ذﺧﻴﺮهﺳﺎزي ﻋﻨﺎﺻﺮ ﻳﻚ درﺧﺖ دودوﻳﻲِ ﻛﺎﻣﻞ ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﮔﺮﻓﺘﻪ اﺳﺖ‪ ،‬ﺑﺮاي ﺑﺮرﺳﻲ اﻳﻦ ﻣﻮﺿـﻮع ﻛـﻪ‬
‫آﻳﺎ اﻳﻦ درﺧﺖ دودوﻳﻲ ﻳﻚ درﺧﺖ ‪ Heap‬اﺳﺖ ﻳﺎ ﺧﻴﺮ‪ ،‬اﺑﺘﺪا ﺑﻪ وﺿﻌﻴﺖ ﮔﺮهﻫﺎ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲﭘﺮدازﻳﻢ‪:‬‬
‫ﺑﻮدنِ ﻳﻚ درﺧﺖ دودوﻳﻲ‬
‫‪ n‬‬
‫‪‬‬
‫ﮔﺮه ﻫﺎي ﺑﺮگ ‪ :‬ﻋﻨﺎﺻﺮ زﻳﺮ آراﻳﻪ ‪ A     1,..., n ‬ﻫﻤﮕﻲ ﺑﺮگ ﺑﻮده و ﻫﺮﻛﺪام ﻳﻚ ‪ heap‬ﺑﺎ ﻳﻚ ﻋﻨﺼﺮ ﻫﺴﺘﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﻧﻴﺎزي ﺑﻪ ﻛﻨﺘﺮل ﻧﺪارﻧﺪ‪.‬‬
‫‪ 2 ‬‬
‫‪‬‬
‫‪‬‬
‫‪ n ‬‬
‫ﮔﺮه ﻫﺎي ﻏﻴﺮ ﺑﺮگ ‪ :‬ﻋﻨﺎﺻﺮ زﻳﺮ آراﻳﻪ ‪ A 1,...,   ‬ﻫﻤﮕﻲ ﻏﻴﺮ ﺑﺮگ ﺑﻮده و ﻫﺮﻳﻚ از آﻧﻬﺎ ﺑﺎﻳﺪ ﺑﺎ ﻓﺮزﻧﺪاﻧﺶ ﻣﻘﺎﻳﺴﻪ ﺷﻮد‬
‫‪ 2 ‬‬
‫‪‬‬
‫‪n ‬‬
‫اﻟﮕﻮرﻳﺘﻢ ﻛﺎرا‪ :‬ﻳﻚ اﻟﮕﻮرﻳﺘﻢ ﻛﺎرا ﺣﺪاﻛﺜﺮ ﺑﺎ ‪ 2   ‬ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﻫﻤﻪ ﻋﻨﺎﺻﺮ ﻏﻴﺮﺑﺮگ در زﻣﺎن ‪ O  n ‬ﻣﻲﺗﻮاﻧﺪ ﺗﺸﺨﻴﺺ دﻫـﺪ ﻛـﻪ آﻳـﺎ ﻳـﻚ درﺧـﺖ‬
‫‪2‬‬
‫دودوﻳﻲِ ﻛﺎﻣﻞ ﺑﺎ ‪ n‬ﮔﺮه‪ ،‬ﻳﻚ درﺧﺖ ‪ heap‬اﺳﺖ ﻳﺎ ﺧﻴﺮ‪.‬‬
‫‪ K‬اﻣﻴﻦ ﺑﺰرگﺗﺮ در ‪max - heap‬‬
‫در ﺻﻮرﺗﻴﻜﻪ ﻳﻚ ‪ max  heap‬ﺣﺎويِ ‪ n‬ﻛﻠﻴﺪ ﻣﺘﻤﺎﻳﺰ ‪ x n ,..., x 2 , x1‬ﺑﺎﺷﺪ آﻧﮕﺎه ﻣﻮﻗﻌﻴﺖﻫﺎي ﻣﺠﺎز ﺑﺮاي ﻗﺮارﮔﻴـﺮيِ اوﻟـﻴﻦ ﺑـﺰرگﺗـﺮﻳﻦ ﺗـﺎ ‪ K‬اُﻣـﻴﻦ‬
‫ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ ﺑﻪ ﺷﺮح زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫اوﻟﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫دوﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫ﺳﻮﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫ﭼﻬﺎرﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫‪‬‬
‫‪ K‬اُﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫ﺳﻄﻮح ﻣﺠﺎز‬
‫اول‬
‫دوم‬
‫دوم ﺗﺎ ﺳﻮم‬
‫دوم ﺗﺎ ﭼﻬﺎرم‬
‫‪A  2,..., 7 ‬‬
‫‪‬‬
‫‪‬‬
‫دوم ﺗﺎ ‪ K‬ام‬
‫ﺧﺎﻧﻪﻫﺎي ﻣﺠﺎز‬
‫‪) A 1‬رﻳﺸﻪ(‬
‫‪A  2,3‬‬
‫‪A  2,..., 7 ‬‬
‫‪A  2,.., 2  1‬‬
‫‪‬‬
‫‪‬‬
‫‪k‬‬
‫ﺑﺮاي درك ﺑﻬﺘﺮ ‪ ،‬ﻧﺤﻮه ﻗﺮار ﮔﻴﺮي ‪ K‬اُﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ را از ﺣﺪاﻗﻞ اﻧﺪﻳﺲ ﺗﺎ ﺣﺪاﻛﺜﺮ اﻧﺪﻳﺲ ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ‪:‬‬
‫‪6‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫در ﺻﻮرﺗﻲ ﻛﻪ دوﻣﻴﻦ ﺑﺰرگﺗـﺮﻳﻦ ﺗـﺎ ‪ K  1‬اُﻣـﻴﻦ ﺑـﺰرگﺗـﺮﻳﻦ در زﻳـﺮ‬
‫درﺧﺖ راﺳﺖ از رﻳﺸﻪ ﻗﺮار ﮔﻴﺮﻧﺪ آﻧﮕﺎه ‪ K‬اُﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ ﻣﻲﺗﻮاﻧﺪ‬
‫در ﺧﺎﻧﻪ ﺷﻤﺎره ‪ 2‬از ﺳﻄﻮح دوم ﻗﺮار ﮔﻴﺮد‪).‬اﻟﺒﺘﻪ اﻳﻦ ﺑﻪ ﺷﺮﻃﻲ اﺳﺖ ﻛﻪ‬
‫ﺑﻪ ﺗﻌﺪاد ﻧﺎﻣﺤﺪود ﮔﺮه داﺷﺘﻪ ﺑﺎﺷﻴﻢ(‬
‫درﺻﻮرﺗﻴﻜﻪ از ﺳﻄﺢ اول ﺗﺎ ﺳﻄﺢ ‪ k‬اُم در ﻫﺮ ﺳﻄﺢ ﻳﻚ ﻣﺎﻛﺰﻳﻤﻢ ﻗﺮار‬
‫دﻫﻴﻢ آﻧﮕﺎه ﻣﺎﻛﺰﻳﻤﻢ ‪ k‬اُم در آﺧﺮﻳﻦ ﮔﺮه ﺳﻄﺢ ‪ k‬اُم ﻳﻌﻨﻲ اﻧﺪﻳﺲِ‬
‫‪ 2k  1‬ﻗﺮار ﺧﻮاﻫﺪ ﮔﺮﻓﺖ‪.‬‬
‫‪ K‬اُﻣﻴﻦ ﻛﻮﭼﻚﺗﺮ در ‪min - heap‬‬
‫ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﻣﻲ ﺗﻮاﻧﻴﻢ وﺿﻌﻴﺖ ‪ K‬اُﻣﻴﻦ ﻛﻮﭼﻜﺘﺮ را در در ﺧﺖ ‪ min  heap‬ﻣﺎﻧﻨﺪ در ﺧﺖ ‪ max  heap‬داﺷﺘﻪ ﺑﺎﺷﻴﻢ ‪.‬‬
‫ﺟﺴﺘﺠﻮ در‬
‫‪Heap‬‬
‫از آن ﺟﺎ ﻛﻪ در ﻫﻴﭽﻴﻚ از اﻫﺪاف و ﻛﺎرﺑﺮدﻫﺎي ﻃﺮاﺣﻲ ﺳﺎﺧﺘﺎر ‪ Heap‬ﻧﻴﺎزي ﺑﻪ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﻧﻴﺴﺖ ﺑﻨﺎﺑﺮاﻳﻦ اﻳﻦ درﺧـﺖ ﺑـﺮاي ﻋﻤـﻞ ﺟـﺴﺘﺠﻮ ﻣﻨﺎﺳـﺐ‬
‫ﻧﻴﺴﺖ ﺑﺎ اﻳﻦ ﺣﺎل ﺗﺤﻠﻴﻞ زﻣﺎن ﺟﺴﺘﺠﻮ در اﻳﻦ ﺳﺎﺧﺘﺎر ﺑﺮاي ﺑﺎزﻳﺎﺑﻲ دادهﻫﺎي ﻣﺨﺘﻠﻒ ﺣﺎﺋﺰ اﻫﻤﻴﺖ اﺳﺖ‪.‬‬
‫ﺟﺴﺘﺠﻮي ﻛﻠﻴﺪ دﻟﺨﻮاه‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ ﻛﻪ آراﻳﺔ ﻧﻤﺎﻳﺶ دﻫﻨﺪة ﻳﻚ درﺧﺖ ‪ Heap‬اﻟﺰاﻣﺎً ﻣﺮﺗﺐ ﻧﻴﺴﺖ ﺑﻨﺎﺑﺮاﻳﻦ اﻣﻜﺎن ﺟﺴﺘﺠﻮي دودوﻳﻲ در آن وﺟﻮد ﻧﺪاﺷﺘﻪ و ﺗﻨﻬﺎ ﻣـﻲﺗـﻮاﻧﻴﻢ ﺑـﻪ‬
‫روش ﺟﺴﺘﺠﻮي ﺧﻄﻲ اﻛﺘﻔﺎ ﻛﻨﻴﻢ‪ .‬زﻣﺎن اﺟﺮا‪O  n  :‬‬
‫ﺟﺴﺘﺠﻮي ﻣﻲﻧﻴﻤﻢ و ﻣﺎﻛﺰﻳﻤﻢ‬
‫‪: max Heap‬‬
‫ﺟﺴﺘﺠﻮي ﻣﺎﻛﺰﻳﻤﻢ‪ :‬اﻳﻦ ﻛﻠﻴﺪ در رﻳﺸﻪ درﺧﺖ ﻗﺮار داﺷﺖ و در زﻣﺎن ‪ O 1‬ﺑﺎزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪ n ‬‬
‫‪‬‬
‫‪n‬‬
‫ﺟﺴﺘﺠﻮي ﻣﻲﻧﻴﻤﻢ‪ :‬اﻳﻦ ﻛﻠﻴﺪ در ﻳﻜﻲ از ﺑﺮگﻫﺎي درﺧﺖ واﻗﻊ در زﻳﺮ آراﻳﻪ ‪ A   2   1,..., n ‬ﻛﻪ ﺗﻌﺪاد آنﻫﺎ ‪ 2 ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪‬‬
‫ﻣﻘﺎﻳﺴﻪ در زﻣﺎن ‪ O  n ‬ﺑﺎزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪: min Heap‬‬
‫ﺟﺴﺘﺠﻮي ﻣﻲﻧﻴﻤﻢ‪ :‬اﻳﻦ ﻛﻠﻴﺪ در رﻳﺸﻪ درﺧﺖ ﻗﺮار داﺷﺘﻪ و در زﻣﺎن ‪ O 1‬ﺑﺎزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪n ‬‬
‫اﺳﺖ ﻗـﺮار داﺷـﻪ و ﺑـﺎ ‪ 2   1‬‬
‫‪ ‬‬
‫‪ n ‬‬
‫‪‬‬
‫‪n ‬‬
‫‪n‬‬
‫ﺟﺴﺘﺠﻮي ﻣﺎﻛﺰﻳﻤﻢ‪ :‬اﻳﻦ ﻛﻠﻴﺪ در ﻳﻜﻲ از ﺑﺮگﻫﺎي درﺧﺖ واﻗﻊ در زﻳﺮ آراﻳﻪ ‪ A   2   1,..., n ‬ﻛﻪ ﺗﻌﺪاد آنﻫﺎ ‪  2 ‬اﺳﺖ ﻗﺮار داﺷـﺘﻪ و ﺑـﺎ ‪ 2   1‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪‬‬
‫ﻣﻘﺎﻳﺴﻪ در زﻣﺎن ‪ O  n ‬ﺑﺎزﻳﺎﺑﻲ ﻣﻲﺷﻮد‪.‬‬
‫ﻧﺘﻴﺠﻪ‪:‬‬
‫‪max Heap‬‬
‫‪min Heap‬‬
‫ﺣﻔﻆ وﻳﮋﮔﻲ‬
‫‪On‬‬
‫‪On ‬‬
‫‪On‬‬
‫‪O 1‬‬
‫‪O 1‬‬
‫‪On‬‬
‫‪Heap‬‬
‫روال ‪ ، MAX  HEAPIFY‬ﺑﺮاي ﺣﻔﻆ وﻳﮋﮔﻲ ‪ max heap‬ﺑﻪﻛﺎر ﻣﻲرود‪ .‬ورودي آن آراﻳﻪي ‪ A‬و اﻧﺪﻳﺲ ‪ i‬در آراﻳﻪ اﺳﺖ‪ .‬زﻣـﺎﻧﻲﻛـﻪ اﻳـﻦ روال را‪،‬‬
‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﻛﻨﻴﻢ ﻓﺮض ﻣﻲﺷﻮد ﻛﻪ درﺧﺖﻫﺎي دودوﻳﻲ ﻣﺸﺘﻖ ﺷﺪه از ‪ LEFT i ‬و ‪ ، RIGHT i ‬ﺧﻮد ﺑـﻪ ﺗﻨﻬـﺎﻳﻲ ﻳـﻚ ‪ max heap‬ﻫـﺴﺘﻨﺪ‪ .‬وﻟـﻲ‬
‫‪HEAP‬‬
‫ﻋﻨﺼﺮ ‪ A i ‬ﻣﻤﻜﻦ اﺳﺖ ﻛﻮﭼﻚﺗﺮ از ﻓﺮزﻧﺪاﻧﺶ ﺑﺎﺷﺪ‪ .‬در ﻧﺘﻴﺠﻪ وﻳﮋﮔﻲ ‪max heap‬‬
‫از ﺑﻴﻦ ﻣﻲرود‪ .‬وﻇﻴﻔﻪ روال ‪MAX  HEAPIFY‬‬
‫ﻣﻘﺪار ﻣﻮﺟﻮد در ‪ A i ‬را ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﺣﺮﻛﺖ دﻫﺪ ﺗﺎ درﺧﺖ ﻣﺸﺘﻖ ﺷﺪه از ‪ i‬ﺑﻪ ﻳﻚ ‪ max heap‬ﺗﺒﺪﻳﻞ ﺷﻮد‪.‬‬
‫‪‬‬
‫‪7‬‬
‫آن اﺳﺖ ﻛـﻪ‬
‫‪MAX - HEAPIFY  A ,i ‬‬
‫‪1‬‬
‫‪l  LEFT  i ‬‬
‫‪2 r  RIGHT  i ‬‬
‫‪if l  A.heap  size and A  l   A  i‬‬
‫‪3‬‬
‫‪Largest  l‬‬
‫‪4‬‬
‫‪else Largest  i‬‬
‫‪5‬‬
‫‪if r  A.heap  size and A  r   A  Largest ‬‬
‫‪6‬‬
‫‪Largest  r‬‬
‫‪if Largest  i‬‬
‫‪exchange A i  with A  Largest ‬‬
‫‪MAX - HEAPIFY  A , Largest ‬‬
‫‪7‬‬
‫‪8‬‬
‫‪9‬‬
‫‪10‬‬
‫در ﻫﺮ ﺑﺎر اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ در ﺧﻄﻮط ‪ 1‬ﺗﺎ ‪ 7‬ﮔﺮه ‪ i‬ﺑﺎ ﻓﺮزﻧﺪاﻧﺶ ﻣﻘﺎﻳﺴﻪ ﺷﺪه و اﻧﺪﻳﺲِ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨـﺼﺮ در ﻣﺘﻐﻴـﺮ ‪ L arg est‬ﻗـﺮار ﻣـﻲﮔﻴـﺮد در اﻳـﻦ‬
‫وﺿﻌﻴﺖ ﻫﻨﮕﺎم رﺳﻴﺪن ﺑﻪ دﺳﺘﻮر ‪ if‬در ﺧﻂ ‪ 8‬دو ﺣﺎﻟﺖ اﺗﻔﺎق ﻣﻲاﻓﺘﺪ‪:‬‬
‫ﺣﺎﻟﺖ اول‪ L arg est  i  :‬‬
‫اﮔﺮ ‪ L arg est  i‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﮔﺮه ‪ i‬از ﻓﺮزﻧﺪاﻧﺶ ﺑﺰرگﺗﺮ ﻳﺎ ﻣﺴﺎوي اﺳﺖ ﺑﻨﺎﺑﺮاﻳﻦ زﻳﺮ درﺧﺖ ﻣـﺸﺘﻖ ﺷـﺪه از ﮔـﺮه ‪ i‬ﻳـﻚ ‪ max Heap‬اﺳـﺖ ﭘـﺲ‬
‫اﻟﮕﻮرﻳﺘﻢ ﺑﻪ ﭘﺎﻳﺎن ﻣﻲرﺳﺪ‪.‬‬
‫ﺣﺎﻟﺖ دوم‪ L arg est  i  :‬‬
‫اﮔﺮ ‪  L arg est  i ‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻳﻜﻲ از ﻓﺮزﻧﺪانِ ﮔﺮه ‪ i‬ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ اﺳﺖ ﺑﻨﺎﺑﺮاﻳﻦ ﮔﺮه ‪ i‬ﺑﺎ آن ﻓﺮزﻧﺪ ﺟﺎﺑﺠﺎ ﺷﺪه )ﺧـﻂ ‪ ( 9‬و اﻟﮕـﻮرﻳﺘﻢ ﺑـﻪ ﺻـﻮرت‬
‫ﺑﺎزﮔﺸﺘﻲ روي اﻧﺪﻳﺲِ ﺟﺪﻳﺪ‪ i ‬دوﺑﺎره ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﺷﻮد‪) .‬ﺧﻂ ‪ ، ( 10‬اﻳﻦ وﺿﻌﻴﺖ ﺣﺪاﻛﺜﺮ ﺗﺎ رﺳﻴﺪن ﮔﺮه ﻣﻮرد ﻧﻈﺮ ﺑﻪ ﻳﻜﻲ از ﺑﺮﮔﻬﺎ ﻣﻤﻜﻦ اﺳﺖ اداﻣﻪ ﭘﻴﺪا‬
‫ﻛﻨﺪ‪.‬‬
‫‪8‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﺗﺤﻠﻴﻞ اﻟﮕﻮرﻳﺘﻢ ‪MAX  HEAPIFY‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ ﺗﺎﺑﻊ ‪ T  n ‬زﻣﺎن اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ ‪ MAX  HEAPIFY‬روي زﻳﺮ درﺧﺘﻲ ﺑﻪ اﻧﺪازة ‪ n‬ﺑﺎﺷﺪ ﻛﻪ از ﮔﺮه ‪ i‬ﻣﺸﺘﻖ ﺷﺪه اﺳﺖ‪ .‬آﻧﮕﺎه ﺗﺤﻠﻴﻞ‬
‫و ﺑﺮرﺳﻲ اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﺮح زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫ﺳﻄﺮ ‪ 1‬ﺗﺎ ‪: 7‬‬
‫در زﻣﺎن ﺛﺎﺑﺘﻲ ﻣﻌﺎدل ﺑﺎ ‪ ،  1‬ﮔﺮه ‪ i‬ﺑﺎ ﻓﺮزﻧﺪاﻧﺶ ﻣﻘﺎﻳﺴﻪ ﺷﺪه )ﻣﻘﺎﻳﺴﻪ ‪ A i ‬ﺑﺎ ‪ ( A  2i  1  , A  2i ‬و اﻧﺪﻳﺲ ﺑﺰرگﺗﺮﻳﻦ‬
‫ﻋﻨﺼﺮ در ﻣﺘﻐﻴﺮ ‪ L arg est‬ﻗﺮار ﻣﻲﮔﻴﺮد‪.‬‬
‫‪T  n    1‬‬
‫ﺳﻄﺮِ ‪: 8‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ ‪ L arg est  i‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﮔﺮه ‪ i‬ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ‪ ،‬ﺑﺎﺷﺪ آﻧﮕﺎه اﻟﮕﻮرﻳﺘﻢ ﭘﺎﻳﺎن ﻣﻲﻳﺎﺑﺪ‪:‬‬
‫ﺳﻄﺮِ ‪ 9‬ﺗﺎ ‪: 10‬‬
‫درﺻﻮرﺗﻲ ﻛﻪ ‪ L arg est  i‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻳﻜﻲ از دو ﻓﺮزﻧﺪ‪ ‬ﮔﺮه ‪ i‬ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ ﺑﺎﺷﺪ آﻧﮕﺎه ﮔﺮه ‪ i‬ﺑﻪ زﻳﺮ درﺧﺖ‪ ‬ﻣﺮﺑﻮط ﺑـﻪ‬
‫‪ 2n ‬‬
‫آن ﻓﺮزﻧﺪ ﻛﻪ ﺣﺪاﻛﺜﺮ ‪  ‬ﮔﺮه دارد ﻣﻨﺘﻘﻞ ﺷﺪه و اﻟﮕﻮرﻳﺘﻢ ‪ MAX  HEAPIFY‬ﺑﻪ ﻃﻮر ﺑﺎزﮔﺸﺘﻲ ﺑﺮاي ﻣﻮﻗﻌﻴﺖ‪ ‬ﺟﺪﻳـﺪ‪‬‬
‫‪ 3 ‬‬
‫ﮔﺮه ‪ i‬ﻣﺠﺪداً ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪  2n  ‬‬
‫‪T  n   T       1‬‬
‫‪ 3 ‬‬
‫ﻧﺘﻴﺠﻪﮔﻴﺮي‪:‬‬
‫‪  2n  ‬‬
‫‪ 1  T  n   T       1‬‬
‫‪‬‬
‫‪ 3 ‬‬
‫‪‬‬
‫‪‬‬
‫‪L arg est i‬‬
‫‪L arg est i‬‬
‫زﻣﺎن اﺟﺮاي‬
‫‪MAX - HEAPIFY‬‬
‫ﻫﻨﮕﺎﻣﻲﻛﻪ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑﺮاي ﻳﻚ ﮔﺮه دﻟﺨﻮاه اﺟﺮا ﻣﻲﺷﻮد‪ ،‬ﺣﺪاﻛﺜﺮ ﻣﺴﻴﺮي از ﮔﺮه ﻣﻮردﻧﻈﺮ ﺗﺎ ﻳﻚ ﺑﺮگ را ﻃﻲ ﻣﻲﻛﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ زﻣﺎن اﺟﺮا ‪ O  h ‬ﺧﻮاﻫـﺪ‬
‫ﺑﻮد ﻛﻪ ‪ h‬در آن ارﺗﻔﺎع ﮔﺮه اﺳﺖ‪ .‬در ﻋﻴﻦ ﺣﺎل ﺑﻴﺶﺗﺮﻳﻦ ارﺗﻔﺎع ﻣﺮﺑﻮط ﺑﻪ ﮔﺮه رﻳﺸﻪ ﺑﻮده ﻛﻪ ﻫﻤﺎن ارﺗﻔﺎع درﺧﺖ اﺳـﺖ ﺑﻨـﺎﺑﺮاﻳﻦ زﻣـﺎن اﺟـﺮاي اﻟﮕـﻮرﻳﺘﻢ‬
‫ﺣﺪاﻛﺜﺮ ‪ lg n‬ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪‬‬
‫‪ i 1‬‬
‫‪‬‬
‫‪MAX  HEAPIFY  A,i   O  h   O  lg n  ‬‬
‫‪‬‬
‫‪ h :i‬‬
‫اﻟﮕﻮرﻳﺘﻢ ‪ HEAPIFY‬در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ‬
‫ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ زﻣﺎﻧﻲ اﺗﻔﺎق ﻣﻲاﻓﺘﺪ ﻛﻪ اﻟﮕﻮرﻳﺘﻢ ﺑﺮاي ﮔﺮه رﻳﺸﻪ اﺟﺮا ﺷﺪه و ﻣﺴﻴﺮي را از اﻳﻦ ﮔﺮه ﺗﺎ ﻳﻜﻲ از ﺑﺮگﻫﺎ ﻃﻲ ﻛﻨﺪ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ در ﺷﻜﻞ ﻓﻮق ﻣﻲﺑﻴﻨﻴﺪ ﺑﺮگﻫﺎي درﺧﺖ‪ ،‬ﺣﺪاﻗﻞ در ﻋﻤﻖ ‪ log3 n‬و ﺣﺪاﻛﺜﺮ در ﻋﻤﻖ ‪ log n3‬ﻗﺮار دارﻧـﺪ‪ .‬ﺑﻨـﺎﺑﺮاﻳﻦ در ﺻـﻮرﺗﻲ ﻛـﻪ ‪T  n ‬‬
‫‪2‬‬
‫راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ زﻣﺎن اﻟﮕﻮرﻳﺘﻢ در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﺑﺎﺷﺪ آﻧﮕﺎه ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫‪ T  n   O  log n ‬‬
‫‪‬‬
‫‪ CLRS,6.2  6‬‬
‫‪ T  n     log n ‬‬
‫‪‬‬
‫‪ 2n ‬‬
‫‪T  n   T  3    1‬‬
‫‪ ‬‬
‫‪‬‬
‫‪‬‬
‫‪T  n   T   n     1‬‬
‫‪ ‬‬
‫‪3‬‬
‫‪‬‬
‫ﺗﻌﺪاد ‪ heap‬ﺑﺎ ‪ n‬ﻛﻠﻴﺪ ﻣﺘﻤﺎﻳﺰ‬
‫در ﻫﺮ درﺧﺖ ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﻣﺘﻤﺎﻳﺰ‪ ،‬ﺻﺮفﻧﻈﺮ از ﺷﻜﻞ ﻳﺎ ﺗﻮﭘﻮﻟﻮژيِ درﺧﺖ ﻛﻪ ﺑﻪ دﻟﻴﻞ ﻛﺎﻣﻞ ﺑﻮدن ﻫﻤﻮاره ﺛﺎﺑﺖ اﺳﺖ‪ ،‬ﻧﺤﻮه ﭼﻴﺪﻣﺎن ﻋﻨﺎﺻﺮ در درﺧﺖ‬
‫ﻣﻲﺗﻮاﻧﺪ درﺧﺘﺎن ﻣﺘﻔﺎوﺗﻲ اﻳﺠﺎد ﻛﻨﺪ‪ .‬ﺑﻪ ﻃﻮر ﻣﺜﺎل‪ heap ،‬ﻫﺎ ﻣﺘﻔﺎوﺗﻲ ﻛﻪ ﻣﻲﺗﻮان ﺑﺎ ﻛﻠﻴﺪﻫﺎي ‪ 3 ، 2 ، 1‬و ‪ 4‬ﺑﺎ وﻳﮋﮔﻲ ‪ min heap‬اﻳﺠﺎد ﻛﺮد ﺑـﻪ ﺷـﺮح‬
‫زﻳﺮ ﻫﺴﺘﻨﺪ‪:‬‬
‫‪HEAP‬‬
‫‪9‬‬
‫ﻗﺎﻋﺪه ﻛﻠﻲ‪:‬‬
‫ﺑﺎ ﺷﺮوع از رﻳﺸﺔ درﺧﺖ‪ ،‬ﺑﻌﺪ از ﻛﻨﺎر ﮔﺬاﺷﺘﻦِ ﻳﻚ ﻋﻨﺼﺮ ﺑﺮاي آن )ﻣﻴﻨﻴﻤﻢ در ‪ min heap‬ﻳﺎ ﻣﺎﻛﺰﻳﻤﻢ در ‪ (maxheap‬ﻛﺎﻓﻲ اﺳـﺖ ﺣـﺎﻻت ﻣﺨﺘﻠـﻒ ﺗﻮزﻳـﻊِ‬
‫ﺑﻘﻴﻪ ﻋﻨﺎﺻﺮ را در دو زﻳﺮ درﺧﺖ‪ ‬ﭼﭗ و راﺳﺖ در ﺻﻮرت وﺟﻮد ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﻢ‪:‬‬
‫‪x  y x  y‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ x   y ‬‬
‫!‪ x  y ‬‬
‫!‪x!y‬‬
‫‪ ‬ﺗﻌﺪاد ﺣﺎﻻت ﺗﻮزﻳﻊ‬
‫در اداﻣﻪ اﻳﻦ ﻋﻤﻞ را ﺑﺮاي ﺗﻤﺎم زﻳﺮ درﺧﺘﺎن ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ و درﻧﻬﺎﻳﺖ‪ ،‬ﻫﻤﻪ ﺣﺎﻻت‪ ‬ﺑﻪ دﺳﺖ آﻣﺪه را ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻗﺎﻧﻮن ﺷﻤﺎرش )اﺻـﻞ ﺿـﺮب( درﻫـﻢ ﺿـﺮب‬
‫ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﻣﺜﺎل ﻛﻠﻴﺪﻫﺎي ‪ 10 ،...، 2 ، 1‬را ﻣﻲﺧﻮاﻫﻴﻢ در درﺧﺖ زﻳﺮ ﻃﻮري ﻗﺮار دﻫﻴﻢ ﻛﻪ ﻣﻘﺪار ﻛﻠﻴﺪ ﻫﺮ ﮔﺮه از ﻓﺮزﻧﺪاﻧﺶ ﺑﺰرگﺗﺮ ﺑﺎﺷﺪ‪ ،‬ﭼﻪ ﺗﻌﺪاد درﺧﺖ ﺑﺎ‬
‫وﻳﮋﮔﻲ ﻓﻮق ﻣﻲﺗﻮان اﻳﺠﺎد ﻛﺮد؟‬
‫‪2016 (1‬‬
‫‪126 (2‬‬
‫‪345 (3‬‬
‫‪4096 (4‬‬
‫ﺣﻞ ‪ :‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫!‪9‬‬
‫اﺑﺘﺪا ﺑﻌﺪ از ﻛﻨﺎرﮔﺬاﺷﺘﻦ ﻛﻠﻴﺪ ﻣﺎﻛﺰﻳﻤﻢ )ﻋﺪد ‪ ( 10‬ﺑﺮاي رﻳﺸﺔ درﺧﺖ‪ ، max heap ‬ﺑﻘﻴﻪ ﻛﻠﻴﺪﻫﺎ ) ‪ 2‬ﺗﺎ ‪ ( 9‬را ﺑﻪ‬
‫!‪5!4‬‬
‫راﺳﺖ ﺗﻮزﻳﻊ ﻣﻲﻛﻨﻴﻢ ﺳﭙﺲ اﻳﻦ ﻋﻤﻠﻴﺎت را ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﺑﺮاي دو زﻳﺮ درﺧﺖ ﭼﭗ و راﺳﺖ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‬
‫ﺣﺎﻟﺖ در دو زﻳﺮ درﺧـﺖ ﭼـﭗ و‬
‫‪ 9!   4!   2!  3!  ! ‬‬
‫‪  ‬ﺗﻌﺪاد ﻛﻞ ﺣﺎﻻت‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪  2016‬‬
‫‪ 5!4!   1!3!   1!1!  0!3!  1!1! ‬‬
‫راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ ﺑﺮاي ﺗﻌﺪاد ‪ heap‬در درﺧﺖ‪ ‬ﭘﺮ‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ آن ﻛﻪ در ﻫﺮ درﺧﺖ‪ ‬ﭘﺮ ﺑﺎ ‪ n  2k  1‬ﮔﺮه‪ ،‬ﺗﻌﺪاد ﮔﺮهﻫﺎ ﺑﻪ ﻃﻮر ﻣﺴﺎوي ﺑﻴﻦ زﻳﺮ درﺧﺘﺎن ﺗﻮزﻳﻊ ﻣﻲﺷﻮد‪ .‬درﺻﻮرﺗﻲ ﻛﻪ ‪ T  n ‬راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ‬
‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﺗﻌﺪاد درﺧﺖ ‪ heap‬ﺑﻪ ﺻﻮرت‪ ‬ﭘﺮ ﺑﺎﺷﺪ‪.‬‬
‫!‪ n  1‬‬
‫‪ n  ‬‬
‫‪ n  ‬‬
‫‪‬‬
‫‪ T n  T      T     ‬‬
‫‪2‬‬
‫‪2‬‬
‫‪    ‬‬
‫! ‪     n  ! n ‬‬
‫‪‬‬
‫‪ 2   2 ‬‬
‫درﻧﻬﺎﻳﺖ راﺑﻄﻪ ﺑﺎزﮔﺸﺘﻲ ‪ T  n ‬ﺑﻪ ﺻﻮرت زﻳﺮ ﻗﺎﺑﻞ دﺳﺘﻴﺎﺑﻲ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪10‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ n  1‬‬
‫‪n ‬‬
‫‪T  n     n   T 2    ‬‬
‫‪ 2  2‬‬
‫‪ ‬‬
‫ﺳﺎﺧﺖ‪ heap ‬ﺑﻪ روش درﺟﺎ ) ﺗﺒﺪﻳﻞ آراﻳﻪ ﺑﺎ ‪ n‬ﻛﻠﻴﺪ ﺑﻪ ﻳﻚ ‪(heap‬‬
‫ﻓﺮض ﻛﻨﻴﺪ ﻣﻲﺧﻮاﻫﻴﻢ آراﻳﻪ ‪ A 1...n ‬را ﺑﻪ ﻳﻚ ‪ heap‬ﺗﺒﺪﻳﻞ ﻛﻨﻴﻢ )درﺟﺎ(‪ .‬اﺑﺘﺪا ﺑﻪ وﺿﻌﻴﺖ‪ ‬ﮔﺮهﻫﺎ دﻗﺖ ﻣﻲﻛﻨﻴﻢ‪:‬‬
‫‪ n ‬‬
‫‪‬‬
‫ﮔﺮهﻫﺎي ﺑﺮگ‪ :‬زﻳﺮ آراﻳﻪ ‪ . A     1...n ‬ﻫﻤﮕﻲ ﺑﺮگ ﺑﻮده و ﻫﺮﻛﺪام ﻳﻚ ‪ heap‬ﺑﺎ ﻳﻚ ﻋﻨﺼﺮ ﻫﺴﺘﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﻧﻴﺎزي ﺑﻪ ﺗﺒﺪﻳﻞ ﻧﺪارﻧﺪ‪.‬‬
‫‪ 2 ‬‬
‫‪‬‬
‫‪  n ‬‬
‫ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ‪ :‬زﻳﺮ آراﻳﻪ ‪ A 1...   ‬ﻫﻤﮕﻲ ﻏﻴﺮﺑﺮگ ﻫﺴﺘﻨﺪ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﻫﺮﻳﻚ از آنﻫﺎ ﺑﺎﻳﺪ ﺑﺎ اﻟﮕﻮرﻳﺘﻢ ‪ MAX  HEAPIFY‬ﻛﻨﺘﺮل ﺷﻮد ﺗـﺎ در‬
‫‪  2 ‬‬
‫ﺻﻮرت ﻧﻴﺎز ﺑﻪ زﻳﺮ درﺧﺘﻲ ﻣﻨﺎﺳﺐ ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﻣﻨﺘﻘﻞ ﺷﻮد اﻳﻦ ﻛﺎر ﻫﻤﺎنﻃﻮر ﻛﻪ ﺧﻮاﻫﻴﻢ دﻳﺪ ﺑﺎﻳﺪ از اﻧﺘﻬﺎ ﺑﻪ اﺑﺘﺪا و از ﭘﺎﻳﻴﻦ ﺑﻪ ﺑﺎﻻ اﻧﺠﺎم ﺷﻮد‪.‬‬
‫اﻟﮕﻮرﻳﺘﻢ ﺳﺎﺧﺖ درﺧﺖ‬
‫‪BUILD - MAX - HEAP  A ‬‬
‫‪A .heap size  A .length‬‬
‫‪for i   A .length / 2  downto 1‬‬
‫‪MAX - HEAPIFY  A ,i ‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ آراﻳﻪ ‪ A 1...n ‬ﺑﻪ ﻳﻚ ‪ heap‬ﻛﻪ در آن ‪ n  A.length‬اﺳﺖ ﺑﺎﻳـﺪ از ﺗـﺎﺑﻊ ‪ MAX  HEAPIFY‬ﻣﺘﻮاﻟﻴـﺎً ﺑـﺮاي ﮔـﺮهﻫـﺎي ﻏﻴﺮﺑـﺮگ‬
‫اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪) .‬از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮﺑﺮگ ﺗﺎ رﻳﺸﻪ از اﻧﺘﻬﺎ ﺑﻪ اﺑﺘﺪا و از ﭘﺎﻳﻴﻦ ﺑﻪ ﺑﺎﻻ (‬
‫ﻳﺎدآوري‪ :‬ﺑﺮاي اﺟﺮاي درﺳﺖ‪ ‬ﺗﺎﺑﻊ ‪ Max  HEAPIFY‬ﺷﺮط ﻻزم آن اﺳﺖ ﻛﻪ دو زﻳﺮ درﺧﺖ ﻣﺸﺘﻖ ﺷﺪه از ﮔﺮهﻫﺎي ﺣﺘﻤﺎً ‪ heap‬ﺑﺎﺷﻨﺪ در ﺷﺮوع ﻛﺎر‬
‫ﺑﺮاي ﺳﺎﺧﺘﻦ ‪ heap‬ﻓﻘﻂ ﻣﻄﻤﺌﻦ ﻫﺴﺘﻴﻢ ﻛﻪ ﮔﺮهﻫﺎي ﺑﺮگ ‪ heap‬ﻫﺴﺘﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎﻳﺪ از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮﺑﺮگ ﺷﺮوع ﻛﻨﻴﻢ ﺗﺎ ﺷﺮط اﺟﺮاي ﺗﺎﺑﻊ‬
‫‪ MAX  HEAPIFY‬رﻋﺎﻳﺖ ﺷﻮد‪.‬‬
‫ﻣﺜﺎل‪ :‬ﻣﻲ ﺧﻮاﻫﻴﻢ اﻋﺪاد ‪ 30,20,50,10,40,70,60,80,60‬را از ﭼﭗ ﺑﻪ راﺳﺖ در ﻳﻚ آراﻳﻪ ﺑﻪ ‪ maxheap‬ﺗﺒﺪﻳﻞ ﻛﻨﻴﻢ‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ آراﻳﻪ ﺑﺎﻻ ﺑﻪ ﻳﻚ ﻫﻴﭗ از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮ ﺑﺮگ )ﻛﻠﻴﺪ ‪ (10‬ﺗﺎ ﮔﺮه رﻳﺸﻪ اﻟﮕﻮرﻳﺘﻢ ‪ heapify‬را ﻓﺮﺧﻮاﻧﻲ ﻣﻲ ﻛﻨﻴﻢ‬
‫‪HEAP‬‬
‫زﻣﺎن اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ‬
‫‪11‬‬
‫‪BUILD - MAX - HEAP‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ دﻳﺪﻳﻢ ﺑﺮاي ﺗﺒﺪﻳﻞ آراﻳﻪ ‪ A 1...n ‬ﺑﻪ ﻳﻚ ‪ heap‬از ﺗﺎﺑﻊ ‪ MAX  HEAPIFY‬ﺑﺮاي ﮔـﺮهﻫـﺎي ﻏﻴﺮﺑـﺮگ در ﺳـﻄﻮح ﻣﺨﺘﻠـﻒ اﺳـﺘﻔﺎده‬
‫ﻣﻲﺷﻮد ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ آن ﻛﻪ زﻣﺎن اﺟﺮاي اﻳﻦ ﺗﺎﺑﻊ واﺑﺴﺘﻪ ﺑﻪ ارﺗﻔﺎع ﮔﺮه اﺳﺖ ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ زﻣﺎن اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ اﺑﺘﺪا ﺑﺎﻳﺪ ﭘﺎراﻣﺘﺮﻫـﺎي زﻳـﺮ را ﻣـﻮرد‬
‫ارزﻳﺎﺑﻲ ﻗﺮار دﻫﻴﻢ‪:‬‬
‫‪:O  h  ‬‬
‫‪‬‬
‫‪ n ‬‬
‫‪:‬‬
‫‪‬‬
‫‪ 2h 1  ‬‬
‫‪h‬‬
‫‪MAX  HEAPIFY‬‬
‫‪h‬‬
‫‪n heap‬‬
‫‪ n ‬‬
‫‪BUILD  MAX  HEAP‬‬
‫‪‬‬
‫‪‬‬
‫‪  Oh‬‬
‫‪h‬‬
‫‪ 2h 1 ‬‬
‫ﺣﺎل از آن ﺟﺎ ﻛﻪ ﻛﻢﺗﺮﻳﻦ ارﺗﻔﺎع ‪  h  0 ‬ﻣﺮﺑﻮط ﺑﻪ ﮔﺮهﻫﺎي ﺑﺮگ و ﺑﻴﺶﺗﺮﻳﻦ ارﺗﻔﺎع ‪  h  lg n  ‬ﻣﺮﺑﻮط ﺑﻪ ﮔﺮه رﻳﺸﻪ اﺳـﺖ‪ .‬در ﺻـﻮرﺗﻲ ﻛـﻪ ﺑـﺮاي‬
‫ﺳﺎﺧﺘﻦ ‪ heap‬از ﺗﺎﺑﻊ ‪ MAX  HEAPIFY‬در ﺗﻤﺎم ﺳﻄﻮح درﺧﺖ )ﺣﺘﻲ ﺑﺮگﻫﺎ ﻛﻪ ﻧﻴﺎزي ﻧﺪارﻧﺪ( اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ ،‬ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫‪‬‬
‫‪  On ‬‬
‫‪‬‬
‫‪‬‬
‫‪lg n ‬‬
‫‪‬‬
‫‪‬‬
‫‪h‬‬
‫‪ n ‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪O‬‬
‫‪h‬‬
‫‪O‬‬
‫‪n‬‬
‫‪‬‬
‫‪‬‬
‫‪ h 1 ‬‬
‫‪h‬‬
‫‪‬‬
‫‪‬‬
‫‪h 0  2‬‬
‫‪ h 0 2‬‬
‫‪‬‬
‫‪‬‬
‫‪ ‬زﻣﺎن ﺳﺎﺧﺘﻦ ‪heap‬‬
‫ﻧﺘﻴﺠﻪ‪ :‬اﻟﮕﻮرﻳﺘﻢ ‪ BUILD  MAXHEAP‬از ﻣﺮﺗﺒﻪ ﺧﻄﻲ ﺑﻮده و در زﻣﺎن ‪ O  n ‬آراﻳﻪ ‪ A 1...n ‬را ﺑﻪ ﺻﻮرت درﺟﺎ ﺑﻪ ﻳﻚ ‪ heap‬ﺗﺒﺪﻳﻞ ﻣﻲﻛﻨﺪ‪.‬‬
‫ﻳﺎدآوري‪ :‬ﺑﺮاي ﻣﺤﺎﺳﺒﻪ‬
‫‪h‬‬
‫‪‬‬
‫‪ 2h‬‬
‫‪h 0‬‬
‫ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﻣﺒﺤﺚ »ﻣﺸﺘﻖ ﺳﺮي ﻫﻨﺪﺳﻲ« در ﭘﻴﻮﺳﺖ ﻛﺘﺎب )ﻣﻘﺪﻣﻪ رﻳﺎﺿﻲ( دارﻳﻢ‪:‬‬
‫‪12‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪h‬‬
‫‪‬‬
‫‪ 2h  2‬‬
‫‪h 0‬‬
‫ﺣﺪاﻗﻞ و ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ در‬
‫‪1‬‬
‫‪‬‬
‫‪x‬‬
‫‪x‬‬
‫‪2 ‬‬
‫‪ h x h ‬‬
‫‪‬‬
‫‪2‬‬
‫‪h 0‬‬
‫‪1  x ‬‬
‫‪‬‬
‫‪0  x 1‬‬
‫‪‬‬
‫‪BUILD - HEAP‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ دﻳﺪﻳﻢ ﺑﺮاي ﺗﺒﺪﻳﻞ ﻫﺮ آراﻳﻪ ﺑﻪ ﻳﻚ ‪ heap‬از ﺗﺎﺑﻊ ‪ HEAPIFY‬ﺑﺮاي ﻫﺮﻳﻚ از ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ اﺳﺘﻔﺎده ﻛﺮدﻳﻢ ﺑﻨـﺎﺑﺮاﻳﻦ ﺗﻌـﺪاد ﻣﻘﺎﻳـﺴﺎت‬
‫ﻻزم ﺗﺎﺑﻌﻲ از ﺗﻌﺪاد ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﺣﺪاﻗﻞ ﻣﻘﺎﻳﺴﻪ‪:‬‬
‫زﻣﺎﻧﻲ ﻛﻪ ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ ﻓﻘﻂ ﺑﺎ دو ﻓﺮزﻧﺪش ﻣﻘﺎﻳﺴﻪ ﺷﺪه و ﺑﻪ ﻫﻴﭻوﺟﻪ ﺑﻪ زﻳﺮ درﺧﺘﺎنِ ﻣﺸﺘﻖ ﺷﺪه از آنﻫﺎ ﻣﻨﺘﻘﻞ ﻧﺸﻮد ﺣﺪاﻗﻞ ﻣﻘﺎﻳﺴﻪ را ﺧﻮاﻫﻴﻢ داﺷﺖ‬
‫اﻳﻦ وﺿﻌﻴﺖ در ﺷﺮاﻳﻄﻲ اﺗﻔﺎق ﻣﻲاﻓﺘﺪ ﻛﻪ ﻳﺎ آراﻳﻪ از اﺑﺘﺪا ‪ heap‬ﺑﺎﺷﺪ و ﻳﺎ ﺑﺮاي ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ ﻓﻘﻂ ﻳﻚ ﺟﺎﺑﻪﺟﺎﻳﻲ ﺑﺎ ﻳﻜﻲ از ﻓﺮزﻧﺪان ﻻزم ﺑﺎﺷﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ‬
‫ﺑﺎ اﻳﻦ ﻓﺮض ﻛﻪ ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ دﻗﻴﻘﺎً دو ﻓﺮزﻧﺪ دارد ﺣﺪاﻗﻞ ‪ 2‬ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﻫﺮ ﻛﺪام ﻻزم اﺳﺖ‪.‬‬
‫‪n ‬‬
‫‪  2 n‬‬
‫‪2‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪n‬‬
‫‪ ‬‬
‫‪2‬‬
‫‪2‬‬
‫ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ‪:‬‬
‫زﻣﺎﻧﻲ ﻛﻪ ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ در اﺛﺮ ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ ‪ HEAPIFY‬ﺗﺎ ﻳﻚ ﮔﺮه ﺑﺮگ ﭘﺎﻳﻴﻦ ﺑﻴﺎﻳﺪ ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ را ﺧﻮاﻫﻴﻢ داﺷﺖ اﻳﻦ وﺿﻌﻴﺖ در ﺷﺮاﻳﻄﻲ اﺗﻔﺎق‬
‫ﻣﻲاﻓﺘﺪ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﻳﻚ آراﻳﻪ ﺑﺎ وﻳﮋﮔﻲ ‪ min heap‬را ﺑﻪ ‪ max heap‬و ﻳﺎ ﺑﺎﻟﻌﻜﺲ ﺗﺒﺪﻳﻞ ﻛﻨﻴﻢ‪.‬‬
‫ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺮاي ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ در ارﺗﻔﺎع ‪ h‬ﺑﺎ اﻳﻦ ﻓﺮض ﻛﻪ در ﻫﺮ ﺳﻄﺢ دو ﻣﻘﺎﻳﺴﻪ ﻻزم دارﻳﻢ ﺣﺪاﻛﺜﺮ ‪ 2h‬ﻣﻘﺎﻳﺴﻪ ﻻزم اﺳﺖ ﺗﺎ ﺑﻪ ﻳﻚ ﮔﺮه ﺑـﺮگ ﻣﻨﺘﻘـﻞ‬
‫ﺷﻮد‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪h‬‬
‫‪ n ‬‬
‫‪ 2n‬‬
‫‪ 2h 1   2h  n ‬‬
‫‪2h‬‬
‫‪‬‬
‫‪‬‬
‫‪h 0‬‬
‫‪ L gn ‬‬
‫‪‬‬
‫‪‬‬
‫‪h 1‬‬
‫‪ n ‬‬
‫‪  h 1 ‬‬
‫‪2  ‬‬
‫‪ 2h‬‬
‫ﻳﺎدآوري‪ :‬ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از ارﺗﻔﺎع ‪ h  1‬ﺗﺎ ارﺗﻔﺎع ‪ h   Lgn ‬و ﮔﺮهﻫﺎي ﺑﺮگ ﻫﻤﮕﻲ در ارﺗﻔﺎع ‪ h  0‬ﻗﺮار دارﻧﺪ‪.‬‬
‫ﻛﺎرﺑﺮدﻫﺎي درﺧﺖ ‪Heap‬‬
‫‪ -1‬ﻣﺮﺗﺐ ﺳﺎزي آراﻳﻪﻫﺎ )‪(Heap Sort‬‬
‫‪ -2‬ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ ) ﺑﻪ ﻛﻤﻚ درﺧﺖ اﻧﺘﺨﺎﺑﻲ ﻳﺎ ‪( MinHeap‬‬
‫‪ -3‬ﺻﻒ اوﻟﻮﻳﺖ )‪(Priority Queue‬‬
‫‪h‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪h‬‬
‫‪‬‬
‫‪HEAP‬‬
‫‪13‬‬
‫‪ -1‬ﻣﺮﺗﺐ ﺳﺎزي آراﻳﻪﻫﺎ ‪ Heap Sort ‬‬
‫در ﻣﺮﺗﺐﺳﺎزي ﺑﻪ ﻛﻤﻚ ‪ ، MaxHeap‬اﻟﮕﻮرﻳﺘﻢ ﺑﻪ ﺷﺮح زﻳﺮ ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ ‪:‬‬
‫)‪Heap - Sort (A‬‬
‫)‪1. BULD - MAX - HEAP (A‬‬
‫‪2. for length  A  down to 2 do‬‬
‫‪exchanghe A  1   A  i ‬‬
‫‪3.‬‬
‫‪heap_size  A   heap_size  A   1‬‬
‫‪4.‬‬
‫‪MAX  HEAPIFY  A , 1‬‬
‫‪5.‬‬
‫ﺳﻄﺮ ‪ : 1‬اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎده از روال ‪ BUILD  MAX  HEAP‬آراﻳﻪ ورودي ‪ A 1  n ‬ﺑﻪ ﺻﻮرت درﺟﺎ ﺗﺒﺪﻳﻞ ﺑﻪ ﻳﻚ ‪ Max  Heap‬ﻣﻲﺷﻮد‪.‬‬
‫ﺳﻄﺮ‪ : 3‬ﺣﺎل از آﻧﺠﺎ ﻛﻪ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ در رﻳﺸﻪ ﻳﻌﻨﻲ ‪ A  1 ‬ﻗﺮار دارد‪ ،‬ﺑﺎ ﻳﻚ ﺟﺎﺑﻪﺟﺎﻳﻲ ﺑﺎ ‪ A  n ‬در ﻣﻜﺎن ﺻﺤﻴﺢ )ﻧﻬﺎﻳﻲ( ﺧﻮد ﻗﺮار ﻣﻲ ﮔﻴﺮد‬
‫ﺳﻄﺮ‪ : 4‬در اداﻣﻪ از اﻧﺪازه ‪ heap‬ﻳﻚ واﺣﺪ ﻛﻢ ﻣﻲ ﺷﻮد ﺗﺎ ﻧﺎﺣﻴﻪ ﻣﺮﺗﺐ ﺷﺪه)اﻧﺘﻬﺎي آراﻳﻪ( از ‪ Max  Heap‬ﺟﺪا ﺷﻮد‪.‬‬
‫ﺳﻄﺮ‪ : 5‬در ﻧﻬﺎﻳﺖ ﺑﺎﻳﺪ روال ‪ MAX  HEAPIFY‬را ﺑﺮاي رﻳﺸﻪ ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﻴﻢ ﺗﺎ ﮔﺮه ﺟﺎﻳﮕﺰﻳﻦ ﺷﺪه ‪  A  n ‬در ﻣﺤﻞ واﻗﻌﻲ ﺧﻮد ﻗﺮار ﺑﮕﻴﺮد‪.‬‬
‫ﺳﻄﺮ‪ : 2‬روال ﻣﺮﺗﺐ ﺳﺎزي اﻳﻦ روﻧﺪ)ﺳﻄﺮ ‪ 3‬ﺗﺎ ‪ (5‬را ‪ n-1‬ﻣﺮﺣﻠﻪ ﺗﺎ اﻳﻨﻜﻪ اﻧﺪازه ‪ heap‬ﺑﻪ ‪ 1‬ﺑﺮﺳﺪ ﺗﻜﺮار ﻣﻲﻛﻨﺪ‪.‬‬
‫ﻣﺜﺎل زﻳﺮ ﻋﻤﻠﻜﺮد اﻟﮕﻮرﻳﺘﻢ ﺑﺎﻻ را از ﺳﻄﺮ ‪ 2‬ﺗﺎ ‪ 5‬ﺑﺮاي ﻣﺮﺗﺐ ﺳﺎزي ﻫﻴﭗ اﻳﺠﺎد ﺷﺪه از ﻳﻚ آراﻳﻪ ﻧﺸﺎن ﻣﻲدﻫﺪ‪:‬‬
‫‪14‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﺗﺤﻠﻴﻞ زﻣﺎن اﺟﺮا‬
‫ازآﻧﺠﺎﻛﻪ ﻓﺮاﺧﻮاﻧﻲ ‪ BUILD  MAX  HEAP‬زﻣﺎن ‪ O  n ‬و ﻫﺮ ﻳﻚ از ‪ n  1‬ﺑـﺎر ﻓﺮاﺧـﻮاﻧﻲ روال ‪ MAX  HEAPIFY‬ﺑـﺮاي رﻳـﺸﻪ ﺣـﺪاﻛﺜﺮ‬
‫زﻣﺎﻧﻲ ﻣﻌﺎدل ﺑﺎ ‪ O  log n ‬را ﺻﺮف ﻣﻲﻛﻨﺪ در ﻧﺘﻴﺠﻪ زﻣﺎن ﻣﺮﺗﺐﺳﺎزي ‪ Heap‬ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺑﻮد ﺑﺎ‪:‬‬
‫‪O  n    n  1 O  log n   O  n log n ‬‬
‫ﻋﺪم ﺗﺎﺛﻴﺮ ﺗﺮﺗﻴﺐ ﻋﻨﺎﺻﺮ ورودي در‬
‫‪Heap Sort‬‬
‫از آﻧﺠﺎﻛﻪ روال ‪ BUILD  MAX  HEAP‬ﺻﺮف ﻧﻈﺮ از ﺗﺮﺗﻴﺐ ﻋﻨﺎﺻﺮ آراﻳﻪ ورودي در زﻣﺎن ‪ O  n ‬آﻧﺮا ﺗﺒـﺪﻳﻞ ﺑـﻪ ﻳـﻚ ‪ Max  Heap‬ﻣـﻲ ﻛﻨـﺪ‬
‫ﺑﻨﺎﺑﺮاﻳﻦ ﺗﺮﺗﻴﺐ ورود ﻋﻨﺎﺻﺮ )ﻣﺮﺗﺐ ﻳﺎ ﻧﺎﻣﺮﺗﺐ( ﻫﻴﭻ ﺗﺎﺛﻴﺮي در زﻣﺎن ﻣﺮﺗﺐ ﺳﺎزي ﻧﺨﻮاﻫﺪ داﺷﺖ‪.‬‬
‫ﻗﻀﻴﻪ ‪ :1‬زﻣﺎن اﺟﺮاﻳﻲ ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﻣﺮﺗﺐﺳﺎزي ‪   n lg n  ، heap‬اﺳﺖ ‪ CLRS, 6.4  4 ‬‬
‫اﺛﺒﺎت ‪ :‬ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﻗﺒﻼ دﻳﺪﻳﻢ اﺟﺮاي روال ‪ MAX  HEAPIFY‬در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ )اﺟﺮا ﺑﺮاي رﻳﺸﻪ( از رواﺑﻂ زﻳﺮ ﺗﺒﻌﻴﺖ ﻣﻲ ﻛﻨﺪ‪:‬‬
‫‪ T  n   O  log n ‬‬
‫‪‬‬
‫ﺗﻤﺮﻳﻦ‬
‫‪ CLRS,6.2  6‬‬
‫‪ T  n     log n ‬‬
‫‪‬‬
‫‪ 2n ‬‬
‫‪T  n   T  3    1‬‬
‫‪ ‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪T  n   T  n     1‬‬
‫‪ ‬‬
‫‪‬‬
‫‪3‬‬
‫ﺣﺎل از آﻧﺠﺎﻛﻪ در اﻟﮕﻮرﻳﺘﻢ ﻣﺮﺗﺐ ﺳﺎزي ‪ n-1‬ﻓﺮاﺧﻮاﻧﻲ ‪ MAX  HEAPIFY‬ﺑﺮاي رﻳﺸﻪ اﻧﺠﺎم ﻣﻲ ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ زﻣﺎن اﺟﺮاي ﻣﺮﺗﺐ ﺳـﺎزي در ﺑـﺪﺗﺮﻳﻦ‬
‫ﺣﺎﻟﺖ ‪  n  1   lg n     n lg n ‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﻗﻀﻴﻪ ‪ :2‬در ﺷﺮاﻳﻄﻲ ﻛﻪ ﻫﻤﻪي ﻋﻨﺎﺻﺮ ﻣﺘﻤﺎﻳﺰ ﺑﺎﺷﻨﺪ‪ ،‬زﻣﺎن اﺟﺮاﻳﻲ ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖ ﻣﺮﺗﺐﺳﺎزي ‪   n lg n  ، heap‬اﺳﺖ ‪ CLRS, 6.4  5 ‬‬
‫اﺛﺒﺎت ‪ :‬در ﺷﺮاﻳﻄﻲ ﻛﻪ ﻫﻤﻪ ﻋﻨﺎﺻﺮ ﻣﺘﻤﺎﻳﺰ ﺑﺎﺷﻨﺪ ‪ .‬در ﻫﺮ ﻳﻚ از ‪ n-1‬ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ ‪ MAX  HEAPIFY‬ﺑﺮاي رﻳﺸﻪ ﮔﺮه ﺟـﺎﻳﮕﺰﻳﻦ ﺷـﺪه ﺑـﻪ ﺑﺮﮔـﻲ در‬
‫‪n‬‬
‫ﭘﺎﻳﻴﻦ ﺗﺮﻳﻦ ﺳﻄﺢ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد‪ .‬در اﻳﻦ وﺿﻌﻴﺖ ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖ زﻣﺎﻧﻲ رخ ﻣﻲ دﻫﺪ ﻛﻪ ﮔﺮه ﻣﻮرد ﻧﻈﺮ ﺑﻪ زﻳﺮ درﺧﺘﻲ ﺑـﺎ ‪  ‬ﮔـﺮه ﻣﻨﺘﻘـﻞ ﺷـﻮد و زﻣـﺎن‬
‫‪3‬‬
‫‪ n ‬‬
‫‪ T  n   T       1 ‬ﺧﻮاﻫــﺪ ﺑــﻮد ﺑﻨــﺎﺑﺮاﻳﻦ زﻣــﺎن اﺟــﺮاي ﻣﺮﺗــﺐ ﺳــﺎزي در ﺑﻬﺘــﺮﻳﻦ ﺣﺎﻟــﺖ‬
‫اﻧﺘﻘــﺎل ﺑﺮاﺑــﺮ ﺑــﺎ ‪ T  n     log n ‬‬
‫‪  n  1   lg n     n lg n ‬ﻣﻲ ﺷﻮد‪..‬‬
‫‪3‬‬
‫‪HEAP‬‬
‫ﻣﺮﺗﺐﺳﺎزي‬
‫‪Heap‬‬
‫‪15‬‬
‫ﺑﺮاي آراﻳﻪ ﺑﺎ ﻛﻠﻴﺪﻫﺎي ﻣﺴﺎوي‬
‫درﺻﻮرﺗﻴﻜﻪ ﻋﻨﺎﺻﺮ ورودي ﻳﻚ آراﻳﻪ ﺑﺎ ﻛﻠﻴﺪﻫﺎي ﻣﺴﺎوي ﺑﺎﺷﺪ آﻧﮕﺎه ﻫﺮﻳﻚ از ‪ n  1‬ﺑﺎر ﻓﺮﺧﻮاﻧﻲ روال ‪ MAX  HEAPIFY‬ﺑﺮاي رﻳﺸﻪ زﻣﺎﻧﻲ ﻣﻌﺎدل‬
‫ﺑﺎ ‪ O 1‬را ﺻﺮف ﻣﻲﻛﻨﺪ زﻳﺮا ﻫﻴﭻ اﻧﺘﻘﺎﻟﻲ ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ اﻧﺠﺎم ﻧﻤﻲ ﺷﻮد و درﻧﻬﺎﻳﺖ زﻣﺎن اﺟﺮاي ﻣﺮﺗﺐﺳﺎزي ﺑﺼﻮرت زﻳﺮ ﺑﺮاﺑﺮ ﺑﺎ ‪ O  n ‬ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪O  n    n  1 O 1  O  n ‬‬
‫‪ -2‬ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ ) ﺑﻪ ﻛﻤﻚ درﺧﺖ اﻧﺘﺨﺎﺑﻲ ﻳﺎ ‪( MinHeap‬‬
‫ﻓﺮض ﻛﻨﻴﺪ ‪ K‬آراﻳﻪ ﻣﺮﺗﺐ )ﺻﻌﻮدي( دارﻳﻢ ﻛﻪ ﺗﻌﺪاد ﻛﻞ ﺧﺎﻧﻪﻫﺎي ‪ K‬آراﻳﻪ ‪ n‬ﻣﻲﺑﺎﺷﺪ‪ .‬ﺣﺎل ﻣﻲﺧﻮاﻫﻴﻢ اﻳﻦ ‪ K‬آراﻳﻪ را ادﻏﺎم ﻛﺮده و در ﻳﻚ آراﻳﻪ ﺑـﻪ‬
‫ﺻﻮرت ﻣﺮﺗﺐ ﻧﮕﻬﺪاري ﻛﻨﻴﻢ‪ .‬دو روش ﻛﻠﻲ ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ ﺑﻪ ﺻﻮرت زﻳﺮ وﺟﻮد دارد‪:‬‬
‫اﻟﻒ( روش ﻋﻤﻮﻣﻲ‬
‫در اﻳﻦ روش از ﻃﺮﻳﻖ ﻣﻘﺎﻳﺴﻪ ﻋﻨﺎﺻﺮ اﺑﺘﺪاﻳﻲ ﻟﻴﺴﺘﻬﺎ در ﻫﺮﺑﺎر ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ ﺑﻴﻦ آﻧﻬﺎ را ﺧﺎرج ﻣﻴﻜﻨﻴﻢ ﺗﺎ درﻧﻬﺎﻳﺖ آراﻳﻪ ﻧﻬﺎﻳﻲ ﺣﺎﺻﻞ از ادﻏﺎم ﻟﻴﺴﺘﻬﺎ ﺑﻪ‬
‫ﻃﻮل ‪ n‬و ﻣﺮﺗﺐ ﺷﺪه ﺣﺎﺻﻞ ﺷﻮد ‪ ،‬اﻟﮕﻮرﻳﺘﻢ ﻣﺮﺑﻮط ﺑﻪ اﻳﻦ روش ﻣﻲ ﺗﻮاﻧﺪ ﺑﺼﻮرت زﻳﺮ ﺑﺎﺷﺪ‪:‬‬
‫‪1‬ـ ﻋﻀﻮ اول ﻫﻤﻪ آراﻳﻪﻫﺎ را ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﻛﺮده و ﺑﺎ ‪ K  1‬ﻣﻘﺎﻳﺴﻪ‪ ،‬ﻋﻀﻮ ﻣﻴﻨﻴﻤﻢ را ﺧﺎرج ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫‪2‬ـ در اﻳﻦ ﺣﺎﻟﺖ آراﻳﻪاي ﻛﻪ ﻋﻀﻮ ﻣﻴﻨﻴﻤﻢ از آن ﺧﺎرج ﺷﺪه ﻋﻨﺎﺻﺮش را ﻳﻚ واﺣﺪ ﺑﻪ ﺳﻤﺖ ﺑﺎﻻ ﺣﺮﻛﺖ ﻣﻲدﻫﺪ )راﻧﺶ ـ ‪.( RUN‬‬
‫‪ -3‬ﺳﻄﺮ ‪ 1‬و ‪ 2‬را ﺗﺎ زﻣﺎﻧﻲﻛﻪ ﻛﻠﻴﻪ ﻋﻨﺎﺻﺮ ﻟﻴﺴﺘﻬﺎ ﺑﻪ ﺻﻮرت ﻣﺮﺗﺐ ﺧﺎرج ﺷﻮﻧﺪ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ازآﻧﺠﺎﻛﻪ ﺑﺮاي ﺧﺮوج ﻫﺮ ﻋﻀﻮ ‪  k  1‬ﻣﻘﺎﻳﺴﻪ اﻧﺠﺎم ﻣﻲﺷﻮد در ﻧﺘﻴﺠﻪ ﺑﺮاي ‪ n‬ﻋﻀﻮ آراﻳﻪ ‪ n  k  1‬ﻣﻘﺎﻳﺴﻪ اﻧﺠﺎم ﻣﻲﺷﻮد و زﻣـﺎن ادﻏـﺎم ﺑـﺎ اﻳـﻦ روش‬
‫‪ O  nk ‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫ب( ‪) min heap‬درﺧﺖ اﻧﺘﺨﺎﺑﻲ(‬
‫اﺑﺘﺪا ﺑﻪ ﻛﻤﻚ ﻋﻨﺼﺮ اﺑﺘﺪاﻳﻲِ ﻫﺮ ﻳﻚ از ﻟﻴﺴﺘﻬﺎ درﺧﺖ اﻧﺘﺨﺎﺑﻲ ‪  min heap ‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲ ﺳﺎزﻳﻢ‪:‬‬
‫ﻋﻨﺼﺮِ اول ﻫﺮﻳﻚ از ﻟﻴﺴﺘﻬﺎ را ﺑﻪ ﻋﻨﻮان ﺑﺮگﻫﺎي درﺧﺖ اﻧﺘﺨﺎﺑﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ و ﺳﺎﻳﺮ ﮔﺮه ﻫﺎي درﺧﺖ را ﺑﻪ ﺷﻜﻞ ﺑﺮﻧﺪه )ﻛﻮﭼﻜﺘﺮ( ــ ﺑﺎزﻧـﺪه )ﺑﺰرﮔﺘـﺮ( در‬
‫ﻧﻈﺮ ﻣﻴﮕﻴﺮﻳﻢ ‪ ،‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ ﺑﻴﻦ ﻫﺮ دو ﮔﺮه‪ ‬ﻛﻨﺎر ﻫﻢ ﮔﺮهاي را ﺑﻪ ﻋﻨﻮان واﻟﺪ)ﺑﺮﻧﺪه( اﻧﺘﺨﺎب ﻣﻲﻛﻨﻴﻢ ﻛﻪ ﻛﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ‪ .‬اﻳﻦ ﻋﻤﻞ را ﺑﺮاي ﺳﻄﻮح ﺑﺎ ﻻﺗﺮ‬
‫آنﻗﺪر ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ ﺗﺎ ﺑﻪ رﻳﺸﻪ درﺧﺖ ﺑﺮﺳﻴﻢ و ﻛﻮﭼﻚﺗﺮﻳﻦ ﻋﻨﺼﺮ در رﻳﺸﻪ ﻗﺮار ﮔﻴﺮد‪.‬‬
‫ﺑﺎ ﻣﻘﺎﻳﺴﻪ ‪ 2‬ﺑﺎ ‪ 2 ، 7‬ﺑﺮﻧﺪه و ﺑﺎ ﻣﻘﺎﻳﺴﻪ ‪ 10‬ﺑﺎ ‪ 10 ، 12‬ﺑﺮﻧﺪه در ﻧﻬﺎﻳﺖ ﺑﺎ ﻣﻘﺎﻳﺴﻪ ‪ 10‬ﺑﺎ ‪ 2 ، 2‬ﺑﺮﻧﺪه ﻣﻲﺷﻮد و در رﻳﺸﻪ ﻗﺮار ﻣﻲﮔﻴﺮد‪.‬‬
‫‪16‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫روش ﻛﺎر ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺘﻬﺎ ﺑﻪ ﻛﻤﻚ درﺧﺖ اﻧﺘﺨﺎﺑﻲ‪:‬‬
‫‪ -1‬رﻳﺸﻪ درﺧﺖ اﻧﺘﺨﺎﺑﻲ را ﺣﺬف ﻛﺮده و در آراﻳﻪ ﻧﻬﺎﻳﻲ ﻗﺮار ﻣﻲدﻫﻴﻢ )ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ(‬
‫‪-2‬در ﻟﻴﺴﺘﻲ ﻛﻪ ﻋﻨﺼﺮ رﻳﺸﻪ از آن اﻧﺘﺨﺎب ﺷﺪه ﻳﻚ واﺣﺪ ﺑﻪ ﺳﻤﺖ ﺑﺎﻻ ﺣﺮﻛﺖ )راﻧﺶ(ﻛﺮده و ﺑﺎ ﻣﻘﺎﻳﺴﺎت ﻣﻨﺎﺳﺐ دوﺑﺎره درﺧﺖ اﻧﺘﺨﺎﺑﻲ را ﺗﺎ رﻳﺸﻪ ﺗﺠﺪﻳﺪ‬
‫ﺳﺎﺧﺘﺎر ﻣﻲﻛﻨﻴﻢ‬
‫‪ -3‬ﺳﻄﺮ ‪ 1‬و ‪ 2‬را ﺗﺎ زﻣﺎﻧﻲﻛﻪ ﻛﻠﻴﻪ ﻋﻨﺎﺻﺮ ﻟﻴﺴﺘﻬﺎ ﺑﻪ ﺻﻮرت ﻣﺮﺗﺐ ﺧﺎرج ﺷﻮﻧﺪ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﺗﺤﻠﻴﻞ زﻣﺎن اﺟﺮا‪:‬‬
‫اﺑﺘﺪا در زﻣﺎن ‪ O  k ‬از ‪ k‬ﻋﻨﺼﺮ اﺑﺘﺪاﻳﻲ در ﻟﻴﺴﺘﻬﺎ )ﺑﻪ ﻋﻨﻮان ﺑﺮگ( درﺧﺖ اﻧﺘﺨﺎﺑﻲ )‪ (minheap‬ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮد‪ ،‬ﺳﭙﺲ از آﻧﺠﺎﻛﻪ ﺑﻌﺪ از ﺧﺎرج ﻛـﺮدن‬
‫ﻫﺮ ﻋﻨﺼﺮ از رﻳﺸﻪ درﺧﺖ اﻧﺘﺨﺎﺑﻲ ﺑﺮاي ﺗﺠﺪﻳﺪ ﺳﺎﺧﺘﺎر زﻣﺎﻧﻲ ﻣﺘﻨﺎﺳﺐ ﺑﺎ ارﺗﻔﺎعِ درﺧﺖ ‪  lgk ‬ﻧﻴﺎز دارﻳﻢ ﺑﺮاي ادﻏﺎم ﻋﻨﺎﺻﺮ در ﻫﻤﻪ ﻟﻴﺴﺘﻬﺎ ﻛـﻪ ﺣـﺎوي ‪n‬‬
‫ﻋﻨﺼﺮ ﻫﺴﺘﻨﺪ زﻣﺎن ﺑﺮاﺑﺮ ﺑﺎ ‪ O  nlgk ‬ﺧﻮاﻫﺪ ﺑﻮد ﺑﻨﺎﺑﺮاﻳﻦ در ﻧﻬﺎﻳﺖ زﻣﺎﻧﻲ ﻣﻌﺎدل ﺑﺎ ‪ O  k  + O  nlgk   O  nlgk ‬ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺘﻬﺎ ﻧﻴﺎز ﺧـﻮاﻫﻴﻢ‬
‫داﺷﺖ ‪ CLRS, 6.5  9 ‬‬
‫ﻳﺎدآوري‪:‬‬
‫از آﻧﺠﺎﻛﻪ ﺗﻌﺪاد ﺑﺮﮔﻬﺎي درﺧﺖ اﻧﺘﺨﺎﺑﻲ ‪  min heap ‬ﺳﺎﺧﺘﻪ ﺷﺪه ﺑﺮاﺑﺮ ﺑﺎ ﺗﻌﺪاد ﻟﻴﺴﺘﻬﺎ ﻳﻌﻨﻲ ‪ k‬اﺳﺖ ‪ ،‬در ﺣﺎﻟﺘﻴﻜﻪ درﺧﺖ ﻣﻮرد ﻧﻈﺮ را ﭘﺮ در ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‬
‫آﻧﮕﺎه ﺛﺎﺑﺖ ﻣﻲ ﺷﻮد ﻛﻪ ارﺗﻔﺎع درﺧﺖ ﻣﺘﻨﺎﺳﺐ ﺑﺎ ‪ lgk‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪ : n 0 = 2h ‬درﺧﺖ ﭘﺮ ﺑﻪ ارﺗﻔﺎع ‪)h‬ﺳﻄﺢ رﻳﺸﻪ ﺻﻔﺮ(‬
‫‪ k = 2h ‬‬
‫‪ h = lg k‬‬
‫ﻧﺘﻴﺠﻪ‪ :‬اﺳﺘﻔﺎده از درﺧﺖ اﻧﺘﺨﺎﺑﻲ ‪  min heap ‬ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ ﻛﺎراﺗﺮ از روش ﻋﻤﻮﻣﻲ ﺑﻮده و زﻣﺎن ﻛﻤﺘﺮي ﻧﻴﺎز ﺧﻮاﻫﺪ داﺷﺖ زﻳﺮا‪:‬‬
‫‪. O  nlgk  < O  nk ‬‬
‫‪ -3‬ﺻﻒ اوﻟﻮﻳﺖ‬
‫ﺗﻌﺮﻳﻒ‪ :‬ﺻﻒ اوﻟﻮﻳﺖ ﺑﻪ ﻣﺠﻤﻮﻋﻪاي از ﻋﻨﺎﺻﺮ ﮔﻔﺘﻪ ﻣﻲﺷﻮد ﻛﻪ در آن ﺑﻪ ﻫﺮ ﻋﻨﺼﺮ ﻳﻚ اوﻟﻮﻳﺖ داده ﻣﻲﺷﻮد‪ .‬و ﺗﺮﺗﻴﺐ ﺣﺬف و ﭘﺮدازش دادهﻫﺎ ﺑﺮ ﻃﺒﻖ دو‬
‫ﻗﺎﻋﺪه زﻳﺮ اﺳﺖ‪:‬‬
‫‪1‬ـ ﻋﻨﺼﺮي ﻛﻪ داراي اوﻟﻮﻳﺖ ﺑﻴﺸﺘﺮ اﺳﺖ ﻗﺒﻞ از ﺑﻘﻴﻪ ﻋﻨﺎﺻﺮ ﺣﺬف ﺷﺪه و ﭘﺮدازش ﻣﻲﺷﻮد‪.‬‬
‫‪2‬ـ دو ﻋﻨﺼﺮي ﻛﻪ داراي اوﻟﻮﻳﺖ ﻳﻜﺴﺎن ﻫﺴﺘﻨﺪ ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﺗﺮﺗﻴﺒﻲ ﻛﻪ ﺑﻪ ﺻﻒ وارد ﺷﺪهاﻧﺪ ﭘﺮدازش ﻣﻲﺷﻮد‪.‬‬
‫در ﻫﺮ ﺻﻒ اوﻟﻮﻳﺖ دو ﻋﻤﻞ ﺣﺬف و درج ﻋﻨﺼﺮ اﻧﺠﺎم ﻣﻲﺷﻮد‪.‬‬
‫ﭘﻴﺎده ﺳﺎزي ﺻﻒ اوﻟﻮﻳﺖ‬
‫ﺑﻪ ﻃﻮر ﻛﻠﻲ ﺑﺮاي ﭘﻴﺎدهﺳﺎزي ﻫﺮ ﺻﻒ اوﻟﻮﻳﺖ ﻣﻲ ﺗﻮان از ﻳﻜﻲ از ﺳﺎﺧﺘﺎرﻫﺎي زﻳﺮ را اﺳﺘﻔﺎده ﻛﺮد‪:‬‬
‫‪1‬ـ آراﻳﻪﻫﺎ‬
‫‪2‬ـ ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي‬
‫زﻣﺎنﻫﺎي ﺣﺬف و درج در ﻫﺮ ﻳﻚ از ﺳﺎﺧﺘﺎرﻫﺎ ﺑﻪ ﺷﺮح زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ ‪:‬‬
‫‪3‬ـ درﺧﺖ ‪Heap‬‬
‫‪HEAP‬‬
‫زﻣﺎن ﺣﺬف‬
‫زﻣﺎن درج‬
‫ﺳﺎﺧﺘﺎر‬
‫‪O n ‬‬
‫‪O  1‬‬
‫آراﻳﻪ ﻧﺎﻣﺮﺗﺐ‬
‫‪O  1‬‬
‫‪O n ‬‬
‫آراﻳﻪ ﻣﺮﺗﺐ‬
‫‪O n ‬‬
‫‪O 1‬‬
‫ﻟﻴﺴﺖ ﻧﺎﻣﺮﺗﺐ‬
‫‪O 1‬‬
‫‪O n ‬‬
‫ﻟﻴﺴﺖ ﻣﺮﺗﺐ‬
‫‪O  logn ‬‬
‫‪O  logn ‬‬
‫درﺧﺖ ‪Heap‬‬
‫‪17‬‬
‫ﻧﺘﻴﺠﻪ‪:‬‬
‫از آﻧﺠﺎ ﻛﻪ ﺳﺎﺧﺘﺎر ‪ Heap‬در دوﻋﻤﻞ درج و ﺣﺬف ﻧﺴﺒﺖ ﺑﻪ دو ﺳﺎﺧﺘﺎر دﻳﮕﺮ )آراﻳﻪ و ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي( زﻣﺎن ﻛﻤﺘﺮي)ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي(دارد درﻧﺘﻴﺠﻪ‬
‫ﺑﺮاي ﭘﻴﺎده ﺳﺎزي ﺻﻒ اوﻟﻮﻳﺖ ﻛﺎراﺗﺮ اﺳﺖ‪.‬‬
‫ﭘﻴﺎده ﺳﺎزي ﺻﻒ اوﻟﻮﻳﺖ ﺑﻪ ﻛﻤﻚ ‪Heap‬‬
‫ﺻﻒ اوﻟﻮﻳﺖ‪ 1‬ﺳﺎﺧﺘﻤﺎن دادهاي اﺳﺖ ﻛﻪ ﺑﺮاي ﻧﮕﻬﺪاري ﻣﺠﻤﻮﻋﻪاي ﻣﺎﻧﻨﺪ ‪ S‬از ﻋﻨﺎﺻﺮ ﻛﻪ ﻫﺮ ﻛﺪام ﻣﻘﺪاري ﺑﻪ ﻧﺎم ﻛﻠﻴﺪ دارﻧﺪ ﺑﻪﻛﺎر ﻣﻲرود‪ .‬واﺿﺢ اﺳﺖ ﻛﻪ‬
‫ﻣﻲﺗﻮاﻧﻴﻢ ﺻﻒ اوﻟﻮﻳﺖ را ﺑﺎ اﺳﺘﻔﺎده از ‪ heap‬ﭘﻴﺎدهﺳﺎزي ﻛﻨﻴﻢ؛ در اﻳﻦ ﺻﻮرت دو ﻧﻮع ﺻﻒ اوﻟﻮﻳﺖ دارﻳـﻢ‪ :‬ﺻـﻒ اوﻟﻮﻳـﺖ ﻣـﺎﻛﺰﻳﻤﻢ‪ 2‬و ﺻـﻒ اوﻟﻮﻳـﺖ‬
‫ﻣﻴﻨﻴﻤﻢ‪.3‬‬
‫ﺻﻒﻫﺎي اوﻟﻮﻳﺖ ﻣﺎﻛﺰﻳﻤﻢ ﺑﺎ اﺳﺘﻔﺎده از ‪ max heap‬اﻋﻤﺎل زﻳﺮ را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲﻛﻨﻨﺪ‪:‬‬
‫‪ : MAXIMUM  S  -1‬ﻋﻨﺼﺮي ﺑﺎ ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ )رﻳﺸﻪ( را از ‪ S‬ﺑﺮﻣﻲﮔﺮداﻧﺪ‬
‫‪ : EXTRACT  MAX  S  -2‬ﻋﻨﺼﺮي ﺑﺎ ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ)رﻳﺸﻪ( را از ﻣﺠﻤﻮﻋﻪي ‪ S‬ﺣﺬف ﻛﺮده و ﻣﻘﺪار آﻧﺮا ﺑﺮﻣﻲﮔﺮداﻧﺪ‪.‬‬
‫‪ : INCREASE  KEY  S, x , k  -3‬ﻣﻘﺪار ﻛﻠﻴﺪ‪ ‬ﻋﻨﺼﺮ ‪ x‬را در ﻣﺠﻤﻮﻋﻪي ‪ S‬ﺑﻪ ﻣﻘﺪار ﺟﺪﻳﺪ ‪ k‬اﻓﺰاﻳﺶ ﻣﻲدﻫﺪ‬
‫‪ : INSERT  S, x  -4‬ﻋﻨﺼﺮ ‪ x‬ﺑﺎ ﻣﻘﺪار ﻛﻠﻴﺪ ‪ k‬را ﺑﻪ ﻣﺠﻤﻮﻋﻪي ‪ S‬اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ‪ .‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺧﻮاﻫﻴﻢ داﺷﺖ‪S  S  {x} :‬‬
‫ﺻﻒﻫﺎي اوﻟﻮﻳﺖ ﻣﻴﻨﻴﻤﻢ ﺑﺎ اﺳﺘﻔﺎده از ‪ min heap‬اﻋﻤﺎل زﻳﺮ را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲﻛﻨﻨﺪ‪:‬‬
‫‪ : MINIMUM  S -1‬ﻋﻨﺼﺮي ﺑﺎ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ)رﻳﺸﻪ( را از ﻣﺠﻤﻮﻋﻪي ‪ S‬ﺑﺮﻣﻲﮔﺮداﻧﺪ‬
‫‪ : EXTRACT  MIN  S -2‬ﻋﻨﺼﺮي ﺑﺎ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ)رﻳﺸﻪ( را از ﻣﺠﻤﻮﻋﻪي ‪ S‬ﺣﺬف ﻛﺮده و ﻣﻘﺪار آﻧﺮا ﺑﺮﻣﻲﮔﺮاﻧﺪ‪.‬‬
‫‪ : DECREASE  KEY  S, x , k  -3‬ﻣﻘﺪار ﻛﻠﻴﺪ‪ ‬ﻋﻨﺼﺮ ‪ x‬را در ﻣﺠﻤﻮﻋﻪي ‪ S‬ﺑﻪ ﻣﻘﺪار ‪ k‬ﻛﺎﻫﺶ ﻣﻲدﻫﺪ‪.‬‬
‫‪ : INSERT  S, x  -4‬ﻋﻨﺼﺮ ‪ x‬ﺑﺎ ﻣﻘﺪار ﻛﻠﻴﺪ ‪ k‬را ﺑﻪ ﻣﺠﻤﻮﻋﻪي ‪ S‬اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ‪ .‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺧﻮاﻫﻴﻢ داﺷﺖ‪S  S  {x} :‬‬
‫ﺣﺎل ﺑﺎ ﻓﺮض اﻳﻨﻜﻪ ﺻﻒﻫﺎي اوﻟﻮﻳﺖ ﻣﺎﻛﺰﻳﻤﻢ و ﻣﻴﻨﻴﻤﻢ ﺑﻪﺗﺮﺗﻴﺐ از ﻃﺮﻳﻖ ‪ max heap‬و ‪ min heap‬ﭘﻴﺎدهﺳﺎزي ﺷﻮﻧﺪ‪ ،‬ﻋﻤﻠﻜﺮد ﻫﺮ ﻳﻚ از اﻳﻦ ﻋﻤﻠﻴﺎت را‬
‫در ‪ heap‬ﻣﺘﻨﺎﻇﺮاً ﺗﻮﺿﻴﺢ ﻣﻲدﻫﻴﻢ‪ .‬ﺳﭙﺲ ﺑﻪ ﺗﺤﻠﻴﻞ ﭘﻴﭽﻴﺪﮔﻲ آن ﺑﺮ روي ‪ heap‬ﭘﺮداﺧﺘﻪ و در اﻧﺘﻬﺎ‪ ،‬ﭘﻴﺎدهﺳﺎزي ﺻﻒﻫﺎي اوﻟﻮﻳﺖ را ﺑﺎ اﺳﺘﻔﺎده از ‪heap‬‬
‫در ﺳﺎﺧﺘﻤﺎن دادهﻫﺎي ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي و آراﻳﻪ ﻣﻮرد ﺑﺮرﺳﻲ ﻗﺮار ﻣﻲدﻫﻴﻢ‪.‬‬
‫دﻗﺖ ﻛﻨﻴﺪ‪ :‬ازآﻧﺠﺎﻛﻪ ﺻﻒ اوﻟﻮﻳﺖ را در ‪ heap‬ﭘﻴﺎدهﺳﺎزي ﻣﻲﻛﻨﻴﻢ ﻣﺠﻤﻮﻋﻪي ‪ S‬ﻫﻤﺎن آراﻳﻪي ‪ A‬اﺳﺖ‪.‬‬
‫‪MAXIMUM‬‬
‫ﻋﻨﺼﺮي ﺑﺎ ﺑﺰرﮔﺘﺮﻳﻦ ﻛﻠﻴﺪ در رﻳﺸﻪ درﺧﺖ ‪ max heap‬ﻗﺮار داﺷﺘﻪ و در زﻣﺎن ‪ O 1‬ﺑﺮﮔﺮداﻧﺪه ﻣﻲ ﺷﻮد‪ .‬ﺑﻄﻮر ﻣـﺸﺎﺑﻪ ﻋﻨـﺼﺮي ﺑـﺎ ﻛـﻮﭼﻜﺘﺮﻳﻦ ﻛﻠﻴـﺪ در‬
‫رﻳﺸﻪ درﺧﺖ ‪ min heap‬ﻗﺮار داﺷﺘﻪ و در زﻣﺎن ‪ O 1‬ﺑﺮﮔﺮداﻧﺪه ﻣﻲ ﺷﻮد‪.‬‬
‫‪HEAP  EXTRACT  MAX‬‬
‫اﻳﻦ روال در ‪ max heap‬ﻋﻨﺼﺮي ﺑﺎ ﺑﺰرگﺗﺮﻳﻦ ﻛﻠﻴﺪ را از درﺧﺖ ‪ maxheap‬ﺟﺪا ﻛﺮده و ﺑﺮﻣﻲﮔﺮداﻧﺪ‪ .‬ازآﻧﺠﺎﻛـﻪ در ‪ max heap‬ﺑـﺰرگﺗـﺮﻳﻦ ﻋﻨـﺼﺮ در‬
‫رﻳﺸﻪ ‪  A 1‬ﻗﺮار دارد‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ اﺑﺘﺪا رﻳﺸﻪ را در ﻣﺘﻐﻴﺮ ‪ max‬ﻗﺮار داده و ﺳﭙﺲ آﺧﺮﻳﻦ ﻋﻨﺼﺮ ‪ heap‬را در رﻳﺸﻪ ‪  A 1‬ﻗﺮار ﻣﻲدﻫـﺪ و از اﻧـﺪازهي‬
‫‪1‬‬
‫‪. priority queue‬‬
‫‪. max priority queue‬‬
‫‪3‬‬
‫‪. min priority queue‬‬
‫‪2‬‬
‫‪18‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ heap‬ﻳﻚ واﺣﺪ ﻛﻢ ﻣﻲﻛﻨﺪ‪ .‬ﺑﺎ اﻳﻦ ﻛﺎر ﻓﺮزﻧﺪان رﻳﺸﻪ‪ max heap ،‬ﺑﺎﻗﻲ ﺧﻮاﻫﻨﺪ ﻣﺎﻧﺪ اﻣﺎ درﺧﺖ ﻣﺸﺘﻖ ﺷﺪه از رﻳﺸﻪ ﻣﻤﻜﻦ اﺳﺖ وﻳﮋﮔـﻲ ‪max heap‬‬
‫را ﻧﻘﺾ ﻛﻨﺪ‪ .‬ازاﻳﻦرو ﺑﺮاي ﺣﻔﻆ وﻳﮋﮔﻲ ‪ max heap‬ﻳﻚ ﻓﺮاﺧﻮاﻧﻲ ‪ MAX  HEAPIFY‬ﺑﺮاي آراﻳﻪي ‪ A 1  n  1‬اﻧﺠﺎم ﻣﻲﺷﻮد‪.‬‬
‫‪HEAP. EXTRACT - MAX  A ‬‬
‫‪1 if A.heap  size  1‬‬
‫"‪2 error " heap underflow‬‬
‫‪3 max  A 1‬‬
‫‪A 1  A  A.heap  size‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫زﻣﺎن اﺟﺮاﻳﻲ روال ‪HEAP  EXTRACT  MAX‬‬
‫اﺳﺖ‪ .‬ﭘﺲ اﻳﻦ روال زﻣﺎن ‪ O  lg n ‬را ﺻﺮف ﻣﻲﻛﻨﺪ‪.‬‬
‫ﺑﻪﻃﻮر ﻣﺸﺎﺑﻪ روال ‪HEAP  EXTRACT  MIN‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6 MAX  HEAPIFY  A ,1‬‬
‫‪7 return max‬‬
‫ﺑﺮاي ﻣﻘﺪاردﻫﻲ اوﻟﻴﻪ ﺑﺮاﺑـﺮ ﺑـﺎ ‪ O 1‬و زﻣـﺎن ‪ MAX  HEAPIFY‬ﺑﺮاﺑـﺮ ﺑـﺎ ‪O  lg n ‬‬
‫ﻋﻨﺼﺮي ﺑﺎ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ را از درﺧﺖ ‪ minheap‬ﺟﺪا ﻛﺮده و ﺑﺮﻣﻲﮔﺮداﻧﺪ‪.‬‬
‫‪HEAP. EXTRACT - MIN  A ‬‬
‫‪if A.heap  size  1‬‬
‫" ‪error" heap underflow‬‬
‫‪min  A 1‬‬
‫‪A 1   A  A.heap  size ‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫‪MIN  HEAPIFY  A ,1‬‬
‫‪return min‬‬
‫‪HEAP  INCREASE  KEY‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫اﻳﻦ روال ﻛﻠﻴﺪ ﻋﻨﺼﺮي از ‪ max heap‬را ﺑﺎ اﻧﺪﻳﺲ ‪ i‬ﺑﻪ ﻳﻚ ﻣﻘﺪار ﺟﺪﻳﺪ ﺑﻴﺶﺗﺮ اﻓﺰاﻳﺶ ﻣﻲدﻫﺪ‪ .‬ﭼﻮن ﻣﻤﻜﻦ اﺳـﺖ ﺑـﺎ اﻓـﺰاﻳﺶ ﻛﻠﻴـﺪ ‪ ، A  i ‬درﺧـﺖ‬
‫وﻳﮋﮔﻲ ‪ max heap‬را از دﺳﺖ ﺑﺪﻫﺪ‪ ،‬ﺗﺎﺑﻊ ﻣﺴﻴﺮي از اﻳﻦ ﮔﺮه ﺗﺎ رﻳﺸﻪ را ﺑﺮاي ﻳﺎﻓﺘﻦ ﻣﻜﺎن ﻣﻨﺎﺳﺐ آن ﻛﻠﻴﺪ ﻣﻲﭘﻴﻤﺎﻳﺪ‪ .‬در ﻃﻲ اﻳﻦ ﻣـﺴﻴﺮ‪ ،‬ﻛﻠﻴـﺪ اﻓـﺰاﻳﺶ‬
‫ﻳﺎﻓﺘﻪ ﻣﻜﺮراً ﺑﺎ ﭘﺪرش ﻣﻘﺎﻳﺴﻪ ﻣﻲﺷﻮد‪ .‬اﮔﺮ اﻳﻦ ﻛﻠﻴﺪ از ﭘﺪرش ﺑﺰرگﺗﺮ ﺑﺎﺷﺪ‪ ،‬ﺑﺎ آن ﺟﺎﺑﻪﺟﺎ ﻣﻲﺷﻮد‪ ،‬در ﻏﻴﺮ اﻳﻦ ﺻﻮرت روال ﺑﻪ ﭘﺎﻳﺎن ﻣﻲرﺳﺪ و ﻣﻘﺪار ﺟﺪﻳـﺪ‬
‫‪ ، key‬ﻣﺘﻌﻠﻖ ﺑﻪ ﻛﻠﻴﺪ ﮔﺮهي ‪ A i ‬ﻣﻲﺷﻮد‪.‬‬
‫‪HEAP‬‬
‫‪19‬‬
‫‪HEAP - INCREASE - KEY  A ,i ,key ‬‬
‫‪1 if key  A i ‬‬
‫"‪error " new key is smaller than current key‬‬
‫‪A i   key‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 while i  1 and A  PARENT  i    A i ‬‬
‫‪exchange A i  with A  PARENT  i  ‬‬
‫ازآﻧﺠﺎﻛﻪ اﻳﻦ روال ﻣﺴﻴﺮي از ﮔﺮهي ‪ i‬را ﺣﺪاﻛﺜﺮ ﺗﺎ رﻳﺸﻪ ﻣﻲﭘﻴﻤﺎﻳﺪ زﻣﺎن اﺟﺮاﻳﻲ آن ‪ O  lg n ‬اﺳﺖ‪.‬‬
‫‪i  PARENT  i ‬‬
‫‪5‬‬
‫‪6‬‬
‫ﻣﺜﺎل در ﻳﻚ ‪ max heap‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲﺧﻮاﻫﻴﻢ ﻣﻘﺪار ﻛﻠﻴﺪ‪ ‬ﮔﺮه ﺷﻤﺎرة ‪ 8‬ﻳﻌﻨﻲ ‪ 19‬را ﺑﻪ ‪ 70‬اﻓﺰاﻳﺶ دﻫﻴﻢ‪ .‬در اﺛﺮِ اﻳﻦ اﻓﺰاﻳﺶ‪ ،‬ﻣﻘﺪار ﻛﻠﻴﺪ‬
‫‪  70 ‬ﺗﺎ ﻗﺒﻞ از رﻳﺸﻪ ﺑﺎﻻ ﻣﻲآﻳﺪ ﺗﺎ وﻳﮋﮔﻲِ ‪ max heap‬ﺣﻔﻆ ﺷﻮد‪.‬‬
‫ﺑﻪﻃﻮر ﻣﺸﺎﺑﻪ روال ‪HEAP  DECREASE  KEY‬‬
‫ﻛﻠﻴﺪ ﻋﻨﺼﺮ ‪ i‬ام ﻣﺮﺑﻮط ﺑﻪ ‪ min heap‬را ﺑﻪ ﻣﻘﺪار ﻛﻤﺘﺮ از ﻗﺒﻠﺶ ﻛﺎﻫﺶ ﻣﻲدﻫﺪ‪.‬‬
‫‪HEAP - DECREASE - KEY  A ,i ,key ‬‬
‫‪1 if key  A i ‬‬
‫"‪error " new key is larger than current key‬‬
‫‪A i   key‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 while i  1 and A  PARENT  i    A i ‬‬
‫‪exchange A i  with A  PARENT  i  ‬‬
‫زﻣﺎن اﺟﺮاﻳﻲ اﻳﻦ روال ﺑﺮاﺑﺮ ﺑﺎ ‪ O  lg n ‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪5‬‬
‫‪6 i  PARENT  i ‬‬
‫ﻣﺜﺎل در ﻳﻚ ‪ min heap‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲﺧﻮاﻫﻴﻢ ﻣﻘﺪار ﻛﻠﻴﺪ‪ ‬ﮔﺮه ﺷﻤﺎرة ‪ 8‬ﻳﻌﻨﻲ ‪ 37‬را ﺑﻪ ‪ 10‬ﻛﺎﻫﺶ دﻫﻴﻢ‪ .‬در اﺛﺮِ اﻳﻦ ﻛﺎﻫﺶ‪ ،‬ﻣﻘﺪار‬
‫ﻛﻠﻴﺪ ‪ 10 ‬ﺗﺎ رﻳﺸﻪ ﺑﺎﻻ ﻣﻲآﻳﺪ ﺗﺎ وﻳﮋﮔﻲِ ‪ min heap‬ﺣﻔﻆ ﺷﻮد‪.‬‬
‫‪Max  HEAP  INSERT‬‬
‫ﻗﺎﻋﺪة ﻛﻠﻲ ﺑﺮاي درج ﻳﻚ ﮔﺮه ﺟﺪﻳﺪ در ﻳﻚ ‪ heap‬آن اﺳﺖ ﻛﻪ اﺑﺘﺪا ﮔﺮه ﺟﺪﻳﺪ ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ اﺿﺎﻓﻪ ﺷﺪه ﺳﭙﺲ ﺑﺎ ﻣﻘﺎﻳﺴﻪ و در ﺻﻮرت ﻧﻴﺎز ﺟﺎﺑﺠـﺎﻳﻲ‬
‫ﺑﺎ واﻟﺪ و اﺟﺪادش در ﻣﻜﺎن ﻣﻨﺎﺳﺒﻲ ﻗﺮار ﻣﻲﮔﻴﺮد‪ ،‬ﺗﺎ وﻳﮋﮔﻲ ‪ max heap‬ﺣﻔﻆ ﺷﻮد‪.‬‬
‫‪20‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﺗﺎﺑﻊ ‪ MAX  HEAP  INSERT‬ﻋﻤﻞ درج را ﺑﻪﺻﻮرت زﻳﺮ در ﻳﻚ ‪ maxheap‬اﻧﺠﺎم ﻣﻲدﻫﺪ‪:‬‬
‫‪ -1‬اﺑﺘﺪا اﻧﺪازة درﺧﺖ را ﻳﻚ واﺣﺪ اﻓﺰاﻳﺶ داده و ﮔﺮهاي ﺟﺪﻳﺪ )ﺑﺎ ﻛﻠﻴﺪ ‪ ( ‬را ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ )ﺳﻄﺮ ‪ 1‬و ‪(2‬‬
‫‪ -2‬ﺳﭙﺲ ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ ‪ HEAP  INCREASE  KEY‬ﻛﻠﻴﺪ‪ ‬ﮔﺮه ﺟﺪﻳﺪ را از ‪ ‬ﺑﻪ ‪) key‬ﻣﻘﺪار ﺟﺪﻳﺪ( اﻓﺰاﻳﺶ داده و آن را در ﻣﻜﺎن ﻣﻨﺎﺳﺒ ِ‬
‫ﻲ‬
‫در ﻣﺴﻴﺮِ ﮔﺮه ﺟﺪﻳﺪ ﺗﺎ رﻳﺸﻪ ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬
‫ﺗﺤﻠﻴﻞ اﻟﮕﻮرﻳﺘﻢ‪:‬‬
‫‪MAX - HEAP - INSERT  A , key ‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫‪1‬‬
‫‪A  A.heap  size    ‬‬
‫‪2‬‬
‫‪HEAP - INCREASE - KEY  A , A.heap  size , key ‬‬
‫‪3‬‬
‫درﻣﺜﺎل ﺑﺎﻻ ﺑﺎ درج ﮔﺮه ﺑﺎ ﻛﻠﻴﺪ ‪ 100‬ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ ‪ ،‬ﻛﻠﻴﺪ ﻣﻮرد ﻧﻈﺮ در اﺛﺮ اﺟﺮاي ﺗﺎﺑﻊ ‪ INCREASE‬ﺗﺎ ﮔﺮه رﻳﺸﻪ ﺑﺎﻻ ﻣﻲ رود‪.‬‬
‫زﻣﺎن اﺟﺮا‪:‬‬
‫از آن ﺟﺎ ﻛﻪ ﻣﻤﻜﻦ اﺳﺖ ﻣﻘﺪار ﻛﻠﻴﺪ در ﮔﺮه ﺟﺪﻳﺪ)ﮔﺮه آﺧﺮ ﺑﺎ اﻧﺪﻳﺲ ‪ (n‬ﻣﺴﻴﺮي از ﮔﺮه ﻣﻮردﻧﻈﺮ ﺗﺎ رﻳﺸﻪ را ﻃﻲ ﻛﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ زﻣـﺎن اﺟـﺮاي اﻟﮕـﻮرﻳﺘﻢ درج‬
‫ﻳﻚ ﮔﺮه در درﺧﺖ ‪ heap‬ﺣﺪاﻛﺜﺮ ﺑﻪ اﻧﺪازه ﻋﻤﻖ اﻳﻦ ﮔﺮه ﻳﻌﻨﻲ )‪ lg n   O(lgn‬ﺧﻮاﻫﺪ ﺑﻮد‬
‫ﺑﻄﻮر ﻣﺸﺎﺑﻪ ﺗﺎﺑﻊ ‪ MIN  HEAP  INSERT‬ﻋﻤﻞ درج را ﺑﻪﺻﻮرت زﻳﺮ در ﻳﻚ ‪ maxheap‬اﻧﺠﺎم ﻣﻲدﻫﺪ‪:‬‬
‫‪ -1‬اﺑﺘﺪا اﻧﺪازة درﺧﺖ را ﻳﻚ واﺣﺪ اﻓﺰاﻳﺶ داده و ﮔﺮهاي ﺟﺪﻳﺪ )ﺑﺎ ﻛﻠﻴﺪ ‪ ( ‬را ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ )ﺳﻄﺮ ‪ 1‬و ‪(2‬‬
‫‪ -2‬ﺳﭙﺲ ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ ‪ HEAP  DECREASE  KEY‬ﻛﻠﻴﺪ‪ ‬ﮔﺮه ﺟﺪﻳﺪ را از ‪ ‬ﺑﻪ ‪) key‬ﻣﻘﺪار ﺟﺪﻳﺪ( ﻛﺎﻫﺶ داده و آن را در ﻣﻜﺎن ﻣﻨﺎﺳﺒ ِ‬
‫ﻲ‬
‫در ﻣﺴﻴﺮِ ﮔﺮه ﺟﺪﻳﺪ ﺗﺎ رﻳﺸﻪ ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬
‫‪MIN - HEAP - INSERT  A , key ‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫‪1‬‬
‫‪A  A.heap  size    ‬‬
‫‪HEAP - DECREASE - KEY  A , A.heap  size , key ‬‬
‫‪2‬‬
‫درﻣﺜﺎل ﺑﺎﻻ ﺑﺎ درج ﮔﺮه ﺑﺎ ﻛﻠﻴﺪ ‪ 10‬ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ ‪ ،‬ﻛﻠﻴﺪ ﻣﻮرد ﻧﻈﺮ در اﺛﺮ اﺟﺮاي ﺗﺎﺑﻊ ‪ DECREASE‬ﺗﺎ ﮔﺮه رﻳﺸﻪ ﺑﺎﻻ ﻣﻲ رود‪.‬‬
‫درج در ‪ HEAP‬ﺟﺎﺑﺠﺎ ﭘﺬﻳﺮ ﻧﻴﺴﺖ‬
‫‪3‬‬
‫‪HEAP‬‬
‫‪21‬‬
‫درﺻﻮرﺗﻲﻛﻪ ﺗﺮﺗﻴﺐ درج ﻋﻨﺎﺻﺮ در ﻳﻚ ‪ heap‬ﻋﻮض ﺷﻮد‪ ،‬ﻣﻤﻜﻦ اﺳﺖ درﺧﺘﺎن ﻳﻜﺴﺎن ﻳﺎ ﻣﺘﻔﺎوﺗﻲ ﺑﻪدﺳﺖ آﻳﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﻋﻤﻠﻴـﺎت درج در درﺧـﺖ‪heap ‬‬
‫ﺟﺎﺑﺠﺎﭘﺬﻳﺮ ﻧﻴﺴﺖ ‪ ،‬ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫ﺷﺮح ﻋﻤﻠﻴﺎت‬
‫ﺗﺮﺗﻴﺐ درج ﻋﻨﺎﺻﺮ در ﻳﻚ ‪minheap‬‬
‫‪‬‬
‫‪1, 2, 3‬‬
‫‪‬‬
‫‪2,1, 3‬‬
‫‪‬‬
‫‪1,3, 2‬‬
‫ﺳﺎﺧﺖ‪ heap ‬ﺑﻪ روش ﺑﺮون ازﺟﺎ ) درج ‪ n‬ﻛﻠﻴﺪ در درﺧﺖ ﺗﻬﻲ(‬
‫ﺑــﺎ ‪ n‬ﺑــﺎر ﻓﺮاﺧــﻮاﻧﻲ ﻣﺘــﻮاﻟﻲ روال ‪ MAX  HEAP  INSERT‬در ﻳــﻚ ‪ heap‬ﺗﻬــﻲ ﻣــﻲﺗــﻮاﻧﻴﻢ ﻳــﻚ درﺧــﺖ ‪ heap‬ﺑــﺎ ‪ n‬ﮔــﺮه را ﺑــﺴﺎزﻳﻢ‪.‬‬
‫‪ BUILD  MAX  HEAP  A ‬ﻧﺴﺨﻪاي ﻣﺘﻔﺎوت از ‪ BUILD  MAX  HEAP  A ‬اﺳﺖ ﻛﻪ آراﻳﻪي ‪ A‬را ﺑﻪﺻﻮرت ﺑﺮون ازﺟﺎ ﺑـﻪ ﻳـﻚ‬
‫درﺧﺖ ‪ heap‬ﺗﺒﺪﻳﻞ ﻣﻲﻛﻨﺪ‪.‬‬
‫‪BUILD - MAX - HEAP  A ‬‬
‫‪1 A.heap_size = 1‬‬
‫‪2 for i = 1 to A.length‬‬
‫‪3‬‬
‫‪MAX - HEAP - INSERT  A , A i ‬‬
‫ازآﻧﺠﺎﻛﻪ اﻳﻦ روال ‪ n‬ﻋﻨﺼﺮ را ﺑﻪ ﻳﻚ درﺧﺖ ﺗﻬﻲ اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ و زﻣﺎن اﺟﺮاي ﻫﺮ ﺑـﺎر ﻓﺮاﺧـﻮاﻧﻲ ﺗـﺎﺑﻊ ‪ ، MAX  HEAP  INSERT‬ﺑـﺮاي ﮔـﺮه ﺑـﺎ‬
‫اﻧﺪﻳﺲ ‪ i‬ﺑﺮاﺑﺮ ﺑﺎ ﻋﻤﻖ ﮔﺮه ﻳﻌﻨﻲ ‪  lg i ‬اﺳﺖ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ زﻣﺎن اﺟﺮاي اﻳﻦ روال ﺑﺼﻮرت زﻳﺮ ﺑﺮاﺑﺮ ﺑﺎ )‪ O(nlogn‬ﺧﻮاﻫﺪ ﺑﻮد‪(CLRS,6-1.b).‬‬
‫‪n‬‬
‫‪ lg i   lg 1+ lg 2 + ... + lg n = lg n! = O(nlogn) ‬‬
‫‪i=1‬‬
‫ﻣﺜﺎل‪ :‬ﻣﻲ ﺧﻮاﻫﻴﻢ اﻋﺪاد ‪ 30,20,50,10,40,70,60,80,60‬را از ﭼﭗ ﺑﻪ راﺳﺖ در ﻳﻚ ‪ maxhep‬ﺗﻬﻲ درج ﻛﻨﻴﻢ‬
‫‪22‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﻣﻘﺎﻳﺴﻪ روﺷﻬﺎي ﺳﺎﺧﺖ درﺧﺖ ‪HEAP‬‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﻄﺎﻟﺐ ﺑﻴﺎن ﺷﺪه ﺗﺎ ﺑﺤﺎل ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﺘﻴﺠﻪ ﺑﮕﻴﺮﻳﻢ ﻛﻪ ﺑﻄﻮر ﻛﻠﻲ دو روش ﻋﻤﻮﻣﻲ ﺑﺮاي اﻳﺠﺎد ﻳﻚ درﺧﺖ ‪ heap‬وﺟﻮد دارد‪:‬‬
‫اﻟﻒ( روش درﺟﺎ‪ :‬ﺗﺒﺪﻳﻞ ﻳﻚ آراﻳﻪ ﺑﻪ درﺧﺖ ‪ heap‬ﺑﺎ اﺳﺘﻔﺎده از روال ‪ BUILD  MAX  HEAP  A ‬در زﻣﺎن )‪O(n‬‬
‫ب ( روش ﺑﺮون ازﺟﺎ‪ :‬اﺿﺎﻓﻪ ﻛﺮدن ‪ n‬ﻋﻨﺼﺮ ﺑﻪ ﻳﻚ درﺧﺖ ‪ heap‬ﺗﻬﻲ ﺑﺎ اﺳﺘﻔﺎده از روال ‪ BUILD  MAX  HEAP  A ‬در زﻣﺎن )‪O(nlogn‬‬
‫ﺑﺎ ﺑﺮرﺳﻲ و ﺗﺤﻠﻴﻞ ﻫﺮ ﻳﻚ از دو روش ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﺘﺎﻳﺞ زﻳﺮ را ﺑﺪﺳﺖ آورﻳﻢ‪:‬‬
‫‪ -1‬ﻫﻴﭗ ﻫﺎي ﺑﺪﺳﺖ آﻣﺪه از دو روش اﻟﺰاﻣﺎ ﻳﻜﺴﺎن ﻧﻴﺴﺘﻨﺪ)‪(CLRS,6-1.a‬‬
‫‪ -2‬روش درﺟﺎ از ﻣﺮﺗﺒﻪ ﺧﻄﻲ ﺑﻮده درﻧﺘﻴﺠﻪ زﻣﺎن ﻛﻤﺘﺮ و ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي داﺷﺘﻪ و ﺑﻪ روش ﺑﺮون از ﺟﺎ ﺗﺮﺟﻴﺢ داده ﻣﻲ ﺷﻮد‪.‬‬
‫‪ ) MAX  HEAP  Change‬ﺗﻐﻴﻴﺮ ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮه دﻟﺨﻮاه(‬
‫اﻳﻦ روال ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮة ‪ i‬اُم از ‪ max heap‬را ﺑﻪ ﻣﻘﺪار ﺟﺪﻳﺪ ‪ k‬ﺗﻐﻴﻴﺮ ﻣﻲ دﻫﺪ‪ .‬در اﻳﻦ وﺿﻌﻴﺖ ﻳﻜﻲ از دو ﺣﺎﻟﺖ زﻳﺮ ﺑﻮﺟﻮد ﻣﻲ آﻳﺪ‪:‬‬
‫ﺣﺎﻟﺖ اول‪ :‬اﮔﺮ ﻣﻘﺪار ﺟﺪﻳﺪ ﻛﻠﻴﺪ‪ ‬ﮔﺮة ‪ i‬ﻳﻌﻨﻲ ‪ k‬از ﻣﻘﺪار ﻛﻠﻴﺪ واﻟﺪش ﺑﺰرگﺗﺮ ﺑﺎﺷﺪ‪ ،‬ازآﻧﺠﺎﻛﻪ درﺧﺖ ﻗﺒﻼً ‪ max heap‬ﺑﻮده اﺳﺖ‪ ،‬ﻣﺎﻧﻨﺪ آن اﺳﺖ ﻛﻪ‬
‫ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮهي ‪ i‬ﺑﻪ ﺑﻴﺸﺘﺮ از ﻗﺒﻠﺶ اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ روال ‪ HEAP  INCREASE  KEY‬وﻳﮋﮔﻲ ‪ max heap‬ﺣﻔﻆ‬
‫ﻣﻲﺷﻮد‪.‬‬
‫ﺣﺎﻟﺖ دوم ‪ :‬اﮔﺮ ﻣﻘﺪار ﺟﺪﻳﺪ ﻛﻠﻴﺪ‪ ‬ﮔﺮة ‪ i‬از ﻣﻘﺪار ﻛﻠﻴﺪ واﻟﺪش ﻛﻮﭼﻚﺗﺮ ﺑﺎﺷﺪ‪ ،‬آنﮔﺎه ﺑﺎ اﺟﺮاي روال ‪ MAX  HEAPIFY‬ﻣﻲﺗﻮان وﻳﮋﮔﻲ‬
‫‪ max heap‬را ﺑﺮاي زﻳﺮ درﺧﺖ‪ ‬ﻣﺸﺘﻖ ﺷﺪه از ‪ i‬ﺣﻔﻆ ﻛﺮد‪.‬‬
‫‪MAX - HEAP - Change  i , k ‬‬
‫‪1 A i   k‬‬
‫‪2 if key  A  PARENT  i  ‬‬
‫‪MAX - HEAPIFY  A ,i ‬‬
‫‪3‬‬
‫‪return‬‬
‫‪4‬‬
‫‪else‬‬
‫‪5‬‬
‫‪HEAP - INCREASE - KEY  A ,i , k ‬‬
‫ازآﻧﺠﺎﻛﻪ در اﻳﻦ روال ﺣﺘﻤﺎ ﻳﻜﻲ از دو ﺣﺎﻟﺖ اول ﻳﺎ دوم رخ ﻣﻲدﻫﺪ‪ ،‬روال ﺣﺪاﻛﺜﺮ‪ ،‬ﻣﺴﻴﺮي از ﮔﺮهي ‪ i‬ﺗﺎ ﻳﻚ ﺑﺮگ و ﻳـﺎ ﻣـﺴﻴﺮي از ﮔـﺮهي ‪ i‬ﺗـﺎ رﻳـﺸﻪ را‬
‫ﻣﻲﭘﻴﻤﺎﻳﺪ‪ .‬ﭘﺲ زﻣﺎن اﺟﺮاﻳﻲ اﻳﻦ روال ﺑﺮاﺑﺮ ﺑﺎ ‪ O  lgn ‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪HEAP‬‬
‫‪23‬‬
‫در اﻳﻦ ﻣﺜﺎل ﮔﺮه ﺷﻤﺎره ‪ 2‬ﺑﺎ ﻣﻘﺪار ﻛﻠﻴﺪ ‪ 29‬ﺑﻪ ﻣﻘﺪار ﺟﺪﻳﺪ ‪ 11‬ﺗﻐﻴﻴﺮ ﻳﺎﻓﺘﻪ و از آﻧﺠﺎ ﻛﻪ ﻣﻘﺪار آن ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ اﺳﺖ روال ‪ Heapify‬ﺑﺮاي آن اﺟﺮا ﻣﻲ ﺷﻮد‬
‫در اﻳﻦ ﻣﺜﺎل ﮔﺮه ﺷﻤﺎره ‪ 2‬ﺑﺎ ﻣﻘﺪار ﻛﻠﻴﺪ ‪ 29‬ﺑﻪ ﻣﻘﺪار ﺟﺪﻳﺪ ‪ 70‬ﺗﻐﻴﻴﺮ ﻳﺎﻓﺘﻪ و از آﻧﺠﺎ ﻛﻪ ﻣﻘﺪار آن اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ اﺳﺖ روال ‪ Increase-key‬ﺑﺮاي آن اﺟﺮا‬
‫ﻣﻲ ﺷﻮد‬
‫ﺑﻄﻮر ﻣﺸﺎﺑﻪ روال ‪ MIN - HEAP - Change‬ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮة ‪ i‬اُم از ‪ min heap‬را ﺑﻪ ﻣﻘﺪار ﺟﺪﻳﺪ ‪ k‬ﺗﻐﻴﻴﺮ ﻣﻲ دﻫﺪ‪.‬‬
‫‪MIN - HEAP - Change  i , k ‬‬
‫‪1 A i   k‬‬
‫‪2 if key  A  PARENT  i  ‬‬
‫‪MAX - HEAPIFY  A ,i ‬‬
‫‪3‬‬
‫‪return‬‬
‫‪4‬‬
‫‪else‬‬
‫‪5‬‬
‫‪HEAP - DECREASE - KEY  A ,i , k ‬‬
‫‪ ) MAX  HEAP  DELETE‬ﺣﺬف ﮔﺮه دﻟﺨﻮاه(‬
‫اﻳﻦ روال ﮔﺮة دﻟﺨﻮاه ﺑﺎ اﻧﺪﻳﺲِ ‪ i‬را از ‪ max heap‬ﺣﺬف ﻣﻲﻛﻨﺪ‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر آﺧﺮﻳﻦ ﻋﻨﺼﺮ ‪ heap‬را ﺟﺎﻳﮕﺰﻳﻦ ﮔﺮهي ‪ i‬ﻛﺮده و از اﻧـﺪازه ‪ heap‬ﻳـﻚ‬
‫واﺣﺪ ﻛﻢ ﻣﻲﻛﻨﺪ‪ .‬در اﻳﻦ وﺿﻌﻴﺖ ﻳﻜﻲ از دو ﺣﺎﻟﺖ زﻳﺮ ﺑﻮﺟﻮد ﻣﻲ آﻳﺪ‪:‬‬
‫ﺣﺎﻟﺖ اول‪ :‬اﮔﺮ ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮة ﺟﺎﻳﮕﺰﻳﻦ ﺷﺪه از ﻣﻘﺪار ﻛﻠﻴﺪ واﻟﺪش ﺑﺰرگﺗﺮ ﺑﺎﺷﺪ‪ ،‬ازآﻧﺠﺎﻛﻪ درﺧﺖ ﻗﺒﻼً ‪ max heap‬ﺑﻮده اﺳﺖ‪ ،‬ﻣﺎﻧﻨﺪ آن اﺳﺖ ﻛﻪ ﻣﻘﺪار‬
‫ﻛﻠﻴﺪ ﮔﺮهي ‪ i‬ﺑﻪ ﻣﻘﺪاري ﺑﻴﺸﺘﺮ از ﻗﺒﻠﺶ اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ روال ‪ HEAP  INCREASE  KEY‬وﻳﮋﮔﻲ ‪max heap‬‬
‫ﺣﻔﻆ ﻣﻲﺷﻮد‪.‬‬
‫ﺣﺎﻟﺖ دوم ‪ :‬اﮔﺮ ﻣﻘﺪار ﻛﻠﻴﺪ ﮔﺮهي ﺟﺎﻳﮕﺰﻳﻦ ﺷﺪه از ﻣﻘﺪار ﻛﻠﻴﺪ واﻟﺪش ﻛﻮﭼﻚﺗﺮ ﺑﺎﺷﺪ‪ ،‬آنﮔﺎه ﺑﺎ اﺟﺮاي روال ‪ MAX  HEAPIFY‬ﻣﻲﺗﻮان وﻳﮋﮔﻲ‬
‫‪ max heap‬را ﺑﺮاي درﺧﺖ ﻣﺸﺘﻖ ﺷﺪه از ‪ i‬ﺣﻔﻆ ﻛﺮد‪.‬‬
‫‪MAX - HEAP - DELETE  A ,i ‬‬
‫‪1 A i   A  A.heap  size ‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫‪key  A i ‬‬
‫‪if key  A  PARENT  i  ‬‬
‫‪MAX - HEAPIFY  A ,i ‬‬
‫‪return‬‬
‫‪else HEAP - INCREASE - KEY  A ,i , key ‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫ازآﻧﺠﺎﻛﻪ ﺣﺘﻤﺎً در اﻳﻦ روال ﻳﻜﻲ از دو ﺣﺎﻟﺖ ‪ 1‬ﻳﺎ ‪ 2‬رخ ﻣﻲدﻫﺪ‪ ،‬روال ﺣﺪاﻛﺜﺮ‪ ،‬ﻣﺴﻴﺮي از ﮔﺮهي ‪ i‬ﺗﺎ ﻳـﻚ ﺑـﺮگ و ﻳـﺎ ﻣـﺴﻴﺮي از ﮔـﺮهي ‪ i‬ﺗـﺎ رﻳـﺸﻪ را‬
‫ﻣﻲﭘﻴﻤﺎﻳﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ زﻣﺎن اﺟﺮاﻳﻲ اﻳﻦ روال ﺑﺮاﺑﺮ ﺑﺎ ‪ O  lgn ‬ﺧﻮاﻫﺪ ﺑﻮد‪(CLRS,6.5-8 ).‬‬
‫‪24‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫در ﻣﺜﺎل ﺑﺎﻻ ﻫﻨﮕﺎم ﺣﺬف ﮔﺮه ﺑﺎ اﻧﺪﻳﺲ ‪ ، 2‬ﮔﺮه آﺧﺮ ﺑﺎ ﻛﻠﻴﺪ ‪ 25‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪ .‬ﻛﻪ در اداﻣﻪ ﻧﻴﺎز ﺑﻪ اﺟﺮاي روال ‪ heapify‬دارﻳﻢ ‪.‬‬
‫در ﻣﺜﺎل ﺑﺎﻻ ﻫﻨﮕﺎم ﺣﺬف ﮔﺮه ﺑﺎ اﻧﺪﻳﺲ ‪ ، 4‬ﮔﺮه آﺧﺮ ﺑﺎ ﻛﻠﻴﺪ ‪ 58‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪ .‬و از آﻧﺠﺎ ﻛﻪ ﻣﻘﺪار آن اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ اﺳﺖ روال ‪ Increase-key‬ﺑﺮاي‬
‫آن اﺟﺮا ﻣﻲ ﺷﻮد‬
‫ﺑﻪﻃﻮر ﻣﺸﺎﺑﻪ روال ‪MIN - HEAP - DELETE‬‬
‫ﮔﺮة دﻟﺨﻮاه ﺑﺎ اﻧﺪﻳﺲِ ‪ i‬را از ﻳﻚ ‪ min heap‬ﺣﺬف ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪MIN - HEAP - DELETE  A ,i ‬‬
‫‪1 A i   A  A.heap  size ‬‬
‫‪A.heap  size  A.heap  size  1‬‬
‫‪key  A i ‬‬
‫‪if key  A  PARENT  i  ‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪MIN - HEAPIFY  A ,i ‬‬
‫‪5‬‬
‫‪return‬‬
‫‪6‬‬
‫‪else HEAP - DECREASE - KEY  A ,i , key ‬‬
‫‪7‬‬
‫ﭘﻴﺪاﻛﺮدن ‪ K‬اُﻣﻴﻦ ﻛﻮﭼﻚﺗﺮ در ‪ min - heap‬ﺑﺼﻮرت ﻛﺎرا‬
‫اﺑﺘﺪا ﻳﻚ ﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎﻟﻲ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ و رﻳﺸﻪ ﻫﻴﭗ اﺻﻠﻲ را در آن درج ﻣﻲ ﻛﻨﻴﻢ ‪ ،‬ﺳﭙﺲ ‪ k‬ﺑﺎر روال زﻳﺮ را ﺗﻜﺮار ﻣﻲ ﻛﻨﻴﻢ‪:‬‬
‫‪ -1‬از ﻫﻴﭗ ﺟﺪﻳﺪ رﻳﺸﻪ را ﺣﺬف ﻣﻲ ﻛﻨﻴﻢ‬
‫‪ -2‬ﻓﺮزﻧﺪان ﻋﻨﺼﺮِ ﺣﺬف ﺷﺪه را از ﻫﻴﭗ اﺻﻠﻲ در ﻫﻴﭗ ﺟﺪﻳﺪ درج ﻣﻲ ﻛﻨﻴﻢ‬
‫در ‪ k‬اُُﻣﻴﻦ ﺗﻜﺮار روال ﺑﺎﻻ ‪ k‬اُﻣﻴﻦ ﻛﻮﭼﻜﺘﺮ از رﻳﺸﻪ ﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎرج ﻣﻲ ﺷﻮد و اﻟﮕﻮرﻳﺘﻢ ﭘﺎﻳﺎن ﻣﻲ ﻳﺎﺑﺪ‬
‫زﻣﺎن اﻟﮕﻮرﻳﺘﻢ‪:‬‬
‫از آﻧﺠﺎﻛﻪ ﺗﻌﺪاد ﻋﻨﺎﺻﺮ ﻫﻴﭗ ﺟﺪﻳﺪ ﺣﺪاﻛﺜﺮ ‪ O  k ‬ﻣﻲ ﺑﺎﺷﺪ ﺑﻨﺎﺑﺮاﻳﻦ ارﺗﻔﺎع درﺧﺖ ‪ O  lg k ‬و زﻣﺎن اﻟﮕﻮرﻳﺘﻢ در ﻧﻬﺎﻳﺖ ‪ O  k lg k ‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﻣﺜﺎل ‪ :‬دردر ﺧﺖ ‪ min Heap‬زﻳﺮ ﻣﻲ ﺧﻮاﻫﻴﻢ ﭼﻬﺎرﻣﻴﻦ ﻋﻨﺼﺮ ﻛﻮﭼﻜﺘﺮ)ﻋﺪد ‪ (20‬را ﺧﺎرج ﻛﻨﻴﻢ ‪ ،‬ﻋﻨﺎﺻﺮي ﻛﻪ از اﻳﻦ درﺧـﺖ در ﻫﻴـﭗ ﺟﺪﻳـﺪ ﻗـﺮار ﻣـﻲ‬
‫ﮔﻴﺮﻧﺪ‪ ،‬ﺑﻪ ﺗﺮﺗﻴﺐ در ﻣﺴﻴﺮِ اوﻟﻴﻦ ‪ ،‬دوﻣﻴﻦ و ﺳﻮﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ ﺧﻮاﻫﻨﺪ ﺑﻮد ‪:‬‬
‫ﻣﺮاﺣﻞ ﻛﺎر اﻟﮕﻮرﻳﺘﻢ ﺑﻌﺪ از درج رﻳﺸﻪ درﺧﺖ)ﻛﻠﻴﺪ ‪ (12‬در ﻳﻚ ﻫﻴﭗ ﺧﺎﻟﻲ ﺟﺪﻳﺪ ﺑﺼﻮرت زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪HEAP‬‬
‫‪25‬‬
‫ﺗﻜﺮار اول ‪ :‬رﻳﺸﻪ )‪ (12‬از ﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎرج ﺷﺪه و دوﻓﺮزﻧﺪش)‪ 16‬و‪ (30‬از ﻫﻴﭗ اﺻﻠﻲ در آن درج ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺗﻜﺮار دوم ‪:‬رﻳﺸﻪ)‪ (16‬ازﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎرج ﺷﺪه و دو ﻓﺮزﻧﺪش )‪ 18‬و‪ (70‬از ﻫﻴﭗ اﺻﻠﻲ در آن درج ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺗﻜﺮارﺳﻮم ‪:‬رﻳﺸﻪ)‪ (18‬از ﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎرج ﺷﺪه و دو ﻓﺮزﻧﺪش)‪ 20‬و‪ (34‬از ﻫﻴﭗ اﺻﻠﻲ در آن درج ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺗﻜﺮارﭼﻬﺎرم‪:‬رﻳﺸﻪ)‪(20‬از ﻫﻴﭗ ﺟﺪﻳﺪ ﺧﺎرج ﺷﺪه و اﻟﮕﻮرﻳﺘﻢ ﭘﺎﻳﺎن ﻣﻲ ﭘﺬﻳﺮد‪.‬‬
‫ﭘﻴﺪا ﻛﺮدن ‪ K‬اُﻣﻴﻦ ﺑﺰرگﺗﺮ در ‪ max - heap‬ﺑﺼﻮرت ﻛﺎرا‬
‫ﺑﻄﻮر ﻣﺸﺎﺑﻪ ﻣﻲ ﺗﻮاﻧﻴﻢ ‪ K‬اُﻣﻴﻦ ﺑﺰرﮔﺘﺮ را از ﻳﻚ درﺧﺖ ‪ max - heap‬در زﻣﺎن ‪ O  k lg k ‬ﭘﻴﺪا ﻛﻨﻴﻢ‬
‫ﺗﺒﺪﻳﻞ درﺧﺖ‬
‫‪Heap‬‬
‫ﺑﻪ درﺧﺖ‬
‫‪BST‬‬
‫ﻫﻴﭻ اﻟﮕﻮرﻳﺘﻤﻲ ﻣﺒﺘﻨﻲ ﺑﺮ ﻣﻘﺎﻳﺴﻪ ﻧﻤﻲﺗﻮاﻧﺪ ﻛﻢﺗﺮ از زﻣﺎن ‪ n log n‬ﻳﻚ درﺧﺖ ‪ Heap‬را ﺑﻪ درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ‪  BST ‬ﺗﺒﺪﻳﻞ ﻛﻨﺪ‪ ،‬ﺑﻪ اﻟﮕـﻮرﻳﺘﻢ‬
‫زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ (1‬ﺳﺎﺧﺘﻦ درﺧﺖ ‪ Heap‬از آراﻳﻪ داده ﺷﺪه ﺑﻪ ﺻﻮرت درﺟﺎ‬
‫‪ (2‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ درﺧﺖ ‪BST‬‬
‫‪ (3‬ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎنﺗﺮﺗﻴﺐ ‪  LVR ‬ﺑﺮاي درﺧﺖ ‪BST‬‬
‫‪On‬‬
‫؟‬
‫‪On‬‬
‫‪‬‬
‫اﮔﺮ ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ درﺧﺖ ‪ BST‬ﻛﻢﺗﺮ از زﻣﺎن ‪ n log n‬اﻧﺠﺎم ﺷﻮد‪ .‬آﻧﮕﺎه ﻣﺎ ﺗﻮاﻧﺴﺘﻪاﻳﻢ ﻛﻢﺗﺮ از زﻣـﺎن ‪ n log n‬ﻳـﻚ آراﻳـﻪ دﻟﺨـﻮاه را ﻣﺮﺗـﺐ‬
‫ﻛﻨﻴﻢ در ﺣﺎﻟﻴﻜﻪ ﺣﺪاﻗﻞ زﻣﺎن ﻣﺮﺗﺐﺳﺎزي ﺑﺮاي اﻟﮕﻮرﻳﺘﻢﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ﻣﻘﺎﻳﺴﻪ ﻣﺎﻧﻨﺪ ‪ ... ، merge sort ، Quick sort :‬ﺑﺮاﺑﺮ ﺑﺎ ‪ n log n‬اﺳـﺖ‪ .‬ﺑﻨـﺎﺑﺮاﻳﻦ‬
‫ﻧﺘﻴﺠﻪﮔﻴﺮي زﻳﺮ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﺳﺘﺪﻻل ﻓﻮق ﻗﺎﺑﻞ اﺳﺘﻨﺒﺎط ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﻧﺘﻴﺠﻪ‪ :‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ درﺧﺖ ‪ BST‬ﺣﺪاﻗﻞ در زﻣﺎن ‪   n log n ‬اﻧﺠﺎم ﻣﻲﭘﺬﻳﺮد‪.‬‬
‫ﺗﺒﺪﻳﻞ درﺧﺖ‬
‫‪BST‬‬
‫ﺑﻪ درﺧﺖ‬
‫‪Heap‬‬
‫ﻫﺮ درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ‪  BST ‬ﺑﻪ ﻛﻤﻚ ﻳﻜﻲ از اﻟﮕﻮرﻳﺘﻢﻫﺎي زﻳﺮ ﻣﻲﺗﻮاﻧﺪ از ﻣﺮﺗﺒﻪ ﺧﻄﻲ ‪ O  n ‬ﺑﻪ ﻳﻚ درﺧﺖ ‪ Heap‬ﺗﺒﺪﻳﻞ ﺷﻮد‪.‬‬
‫‪26‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫اﻟﮕﻮرﻳﺘﻢ ‪: I‬‬
‫‪ (1‬ﻳﻜﻲ از ﭘﻴﻤﺎﻳﺶﻫﺎي درﺧﺖ ‪ BST‬را ﺑﻪ دﻟﺨﻮاه در آراﻳﻪ ‪ A‬ذﺧﻴﺮه ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫‪ (2‬اﻟﮕﻮرﻳﺘﻢ ‪ BUILD  HEAP‬را ﺑﺮ روي آراﻳﻪ ‪ A‬اﺟﺮا ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫زﻣﺎن اﺟﺮا‪O  n  :‬‬
‫ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓﻲ‪O  n  :‬‬
‫اﻟﮕﻮرﻳﺘﻢ ‪: II‬‬
‫از آن ﺟﺎ ﻛﻪ ﭘﻴﻤﺎﻳﺶﻫﺎي ‪ LVR‬و ‪ RVL‬از ﻫﺮ درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﺎﻋﺚ ﻧﻤﺎﻳﺶ ﺻﻌﻮدي و ﻧﺰوﻟﻲ ﻛﻠﻴﺪﻫﺎ ﻣﻲﺷﻮﻧﺪ و ﻫﻤﭽﻨﻴﻦ ﻫﺮ آراﻳـﻪ‬
‫ﺻﻌﻮدي و ﻧﺰوﻟﻲ ﺑﻪ ﺗﺮﺗﻴﺐ ﻳﻚ ﻧﻤﺎﻳﺶ از درﺧﺖ ‪ max Heap‬و ‪ min Heap‬ﻫﺴﺘﻨﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﻣـﻲﺗـﻮاﻧﻴﻢ ﺑـﺪون اﺳـﺘﻔﺎده از اﻟﮕـﻮرﻳﺘﻢ ‪Build  Heap‬‬
‫ﻫﻨﮕﺎم اﻧﺠﺎم ﭘﻴﻤﺎﻳﺶﻫﺎي ﻣﻮردﻧﻈﺮ ﺑﻪ ﺟﺎي ﻧﻤﺎﻳﺶ ﻛﻠﻴﺪﻫﺎ آنﻫﺎ را در ﻳﻚ آراﻳﻪ ذﺧﻴﺮه ﻛﻨﻴﻢ‪.‬‬
‫زﻣﺎن اﺟﺮا‪O  n  :‬‬
‫ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓﻲ‪O  n  :‬‬
‫اﻟﮕﻮرﻳﺘﻢ ‪: III‬‬
‫‪ (1‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ BST‬ﺑﻪ ﻳﻚ ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي ﻣﺮﺗﺐ‬
‫‪ (2‬ﺗﺒﺪﻳﻞ ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي ﻣﺮﺗﺐ ﺑﻪ ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ‬
‫ﻛﻞ زﻣﺎن اﺟﺮا‪O  n  :‬‬
‫ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓﻲ‪O 1 :‬‬
‫ﺟﺪول زﻣﺎﻧﻲِ اﺟﺮاي ﻋﻤﻠﻴﺎت ﻣﺨﺘﻠﻒ در ‪Heap‬‬
‫زﻣﺎن اﺟﺮا‬
‫‪O 1‬‬
‫ﻋﻤﻠﻴﺎت در ‪Heap‬‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻋﻨﺼﺮ ﻣﺎﻛﺰﻳﻤﻢ در ‪) Max Heap‬رﻳﺸﻪ(‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ در ‪) Min Heap‬رﻳﺸﻪ(‬
‫‪ ‬درج ﻋﻨﺼﺮ ﺟﺪﻳﺪ ‪ INSERT ‬‬
‫‪ ‬ﺣﺬف ﻳﻚ ﮔﺮه دﻟﺨﻮاه ‪ DELETE ‬‬
‫‪O  lg n ‬‬
‫‪On‬‬
‫‪O  n lg n ‬‬
‫‪O  n lg k ‬‬
‫‪ ‬ﺣﺬف ﻋﻨﺼﺮ ﻣﺎﻛﺰﻳﻤﻢ از رﻳﺸﻪ ‪ EXTRACT  MAX  Max Heap‬‬
‫‪ ‬ﺣﺬف ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ از رﻳﺸﻪ ‪ EXTRACT  MIN  Min Heap‬‬
‫‪ ‬اﻓﺰاﻳﺶ ﻣﻘﺪار ﻛﻠﻴﺪ ﻳﻚ ﮔﺮه ‪ INCREASE  KEY ‬‬
‫‪ ‬ﻛﺎﻫﺶ ﻣﻘﺪار ﻛﻠﻴﺪ ﻳﻚ ﮔﺮه ‪ DECREASE  KEY ‬‬
‫‪ ‬ﺗﻐﻴﻴﺮ ﻣﻘﺪار ﻛﻠﻴﺪ ﻳﻚ ﮔﺮه ‪ CHANGE  KEY ‬‬
‫‪ ‬ﻛﻨﺘﺮل وﻳﮋﮔﻲ ‪ Heap‬ﺑﺮاي ﻳﻚ ﻋﻨﺼﺮ ‪ HEAPIFY ‬‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻳﻚ ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪ ﻣﺸﺨﺺ ‪SEARCH ‬‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪ ﻣﻴﻨﻴﻤﻢ در ‪) MaxHeap‬واﻗﻊ در ﻳﻜﻲ از ﺑﺮگﻫﺎ(‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪ ﻣﺎﻛﺰﻳﻤﻢ در ‪) MinHeap‬واﻗﻊ در ﻳﻜﻲ از ﺑﺮگﻫﺎ(‬
‫‪ ‬ﺳﺎﺧﺖ‪ Heap ‬ﺑﻪ روش درﺟﺎ )ﺗﺒﺪﻳﻞ آراﻳﻪ ﺑﺎ ‪ n‬ﻛﻠﻴﺪ ﺑﻪ ‪(heap‬‬
‫‪ ‬ﻛﻨﺘﺮلِ ‪ Heap‬ﺑﻮدنِ ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﺎ ‪ n‬ﻛﻠﻴﺪ‬
‫‪ ‬ﺗﺒﺪﻳﻞ ﻳﻚ ‪ Min Heap‬ﺑﻪ ‪ Max Heap‬و ﺑﺎﻟﻌﻜﺲ‬
‫‪ ‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ BST‬ﺑﻪ ‪Heap‬‬
‫‪ ‬ﺳﺎﺧﺖ‪ Heap ‬ﺑﻪ روش ﺑﺮون از ﺟﺎ )درج ‪ n‬ﻛﻠﻴﺪ ﺑﻪ درﺧﺖ ﺗﻬﻲ(‬
‫‪ ‬ﻣﺮﺗﺐﺳﺎزي ﻫﺮ آراﻳﻪ ‪ n‬ﺗﺎﻳﻲ ﺑﻪ روش ﻫﺮﻣﻲ ‪ Heap sort ‬‬
‫‪ ‬ادﻏﺎم ‪ k‬ﻟﻴﺴﺖ ﻣﺮﺗﺐ ﺑﺎ ‪ n‬ﻛﻠﻴﺪ‬
‫‪Om  n‬‬
‫‪ ‬ادﻏﺎم دو ‪ Heap‬ﺑﺎ اﻧﺪازه ﻫﺎي ‪ m‬و ‪n‬‬
‫‪O  k lg k ‬‬
‫‪ ‬ﭘﻴﺪا ﻛﺮدن ‪ k‬اُﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻛﻠﻴﺪ در ﻳﻚ ‪ Min Heap‬ﺑﺎ ‪ n‬ﻛﻠﻴﺪ‬
‫‪ ‬ﭘﻴﺪا ﻛﺮدن ‪ k‬اُﻣﻴﻦ ﺑﺰرﮔﺘﺮﻳﻦ ﻛﻠﻴﺪ در ﻳﻚ ‪ Max Heap‬ﺑﺎ ‪ n‬ﻛﻠﻴﺪ‬
‫‪ ‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ ‪BST‬‬
‫‪  n lg n ‬‬
‫‪HEAP‬‬
‫‪27‬‬
‫ﺳﻮاﻻت آزﻣﻮن ﻫﺎي ﺳﺮاﺳﺮي و آزاد و داﻧﺸﮕﺎﻫﻬﺎي ﺧﺎرج‬
‫‪ 1‬ـ ﻳﻚ ﻣﺎﻛﺰﻳﻤﻢ ـ ﻫﻴﭗ ﺣﺎوي ‪ 64‬ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪﻫﺎي ﻣﺘﻔﺎوت ‪ 1‬ﺗﺎ ‪ 64‬اﺳﺖ‪ .‬ﺑﺰرگﺗﺮﻳﻦ ﻋﺪدي ﻛﻪ ﻣﻲﺗﻮاﻧﺪ در ﺑﺮگ واﻗﻊ در آﺧﺮﻳﻦ ﺳﻄﺢ‬
‫اﻳﻦ ﻫﻴﭗ ﻗﺮار ﮔﻴﺮد‪ ،‬ﻛﺪامﻳﻚ از اﻋﺪاد زﻳﺮ ﻣﻲﺗﻮاﻧﺪ ﺑﺎﺷﺪ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪ ، 83‬ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(91‬‬
‫‪58 (2‬‬
‫‪59 (1‬‬
‫‪56 (4‬‬
‫‪57 (3‬‬
‫‪ 2‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ ﻣﺎﻛﺰﻳﻤﻢ ـ ﻫﻴﭗ ﺣﺎوي اﻋﺪاد ﻣﺘﻤﺎﻳﺰ ‪ 1‬ﺗﺎ ‪ 1023‬اﺳﺖ ﺣﺪاﻛﺜﺮ ﭼﻨﺪﺗﺎ از اﻋﺪاد ﺑﻴﺶﺗﺮ از ‪ 1000‬ﻣﻲﺗﻮاﻧﺪ در ﭘﺎﻳﻴﻦﺗﺮ ﻳـﻦ‬
‫ﺳﻄﺢ درﺧﺖ ﻗﺮار ﮔﻴﺮﻧﺪ؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(83‬‬
‫‪12 (2‬‬
‫‪10 (1‬‬
‫‪14 (4‬‬
‫‪13 (3‬‬
‫‪ 3‬ـ در ﻳﻚ ‪ heap‬ﺑﺎ ‪ n‬ﮔﺮه ﻛﻪ در ﻳﻚ آراﻳﻪ ﻧﻤﺎﻳﺶ داده ﺷﺪه ﺑﺎﺷﺪ ﮔﺮه ‪ i‬ام در زﻳﺮ درﺧﺖ ﭼﭗ درﺧﺖ‪ ،‬ﻣﺘﻨـﺎﻇﺮ ﺑـﺎ ﮔـﺮه ‪ j‬ام در زﻳـﺮ‬
‫درﺧﺖ راﺳﺖ درﺧﺖ ﻣﻲﺑﺎﺷﺪ ﺑﻪﻃﻮري ﻛﻪ ‪) ......‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(85‬‬
‫‪(1‬‬
‫‪log i2   1‬‬
‫;‪j  j/ 2‬‬
‫‪ji2‬‬
‫‪if j  n‬‬
‫‪(2‬‬
‫‪log i2  1‬‬
‫‪log i2  1‬‬
‫;‪j  j/ 2‬‬
‫‪ji2‬‬
‫‪if j  n‬‬
‫‪log i2   1‬‬
‫‪ji2‬‬
‫‪ji2‬‬
‫‪j  1 (4‬‬
‫‪j  1 (3‬‬
‫‪if j  n‬‬
‫‪j‬‬
‫‪2‬‬
‫‪2‬‬
‫‪ 4‬ـ اﮔﺮ در ﻳﻚ ‪ min  heap‬ﺟﺎي زﻳﺮ درﺧﺖﻫﺎي ﭼﭗ و راﺳﺖ ﺗﻌﻮﻳﺾ ﺷﻮد در آن ﺻﻮرت ﻛﺪام ﮔﺰﻳﻨﻪ ﺻﺤﻴﺢ اﺳﺖ؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(85‬‬
‫‪j‬‬
‫‪if j  n‬‬
‫‪ (1‬ﻫﻤﻴﺸﻪ ﺳﺎﺧﺘﺎر ‪ min  heap‬از ﺑﻴﻦ ﻣﻲرود‪.‬‬
‫‪ (2‬ﺳﺎﺧﺘﺎر ‪ min  heap‬ﺗﺒﺪﻳﻞ ﺑﻪ ‪ max  heap‬ﻣﻲﺷﻮد‪.‬‬
‫‪ (3‬در ﺑﺮﺧﻲ از ﺷﺮاﻳﻂ ﺳﺎﺧﺘﺎر ‪ min  heap‬از ﺑﻴﻦ ﻣﻲرود‪.‬‬
‫‪ (4‬در ﻫﻴﭻ ﺷﺮاﻳﻄﻲ ﺳﺎﺧﺘﺎر ‪ min  heap‬از ﺑﻴﻦ ﻧﻤﻲرود‪.‬‬
‫‪ 5‬ـ ﻣﺎﻛﺰﻳﻤﻢ ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ‪ min  heap‬ﻛﺮدن ﻳﻚ ‪ max  heap‬ﺑﺎ ‪ n‬ﮔﺮه ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪):‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(84‬‬
‫‪O  n  log n  (1‬‬
‫‪O  log n  (2‬‬
‫‪O  n log n  (3‬‬
‫‪O  2n  (4‬‬
‫‪ 6‬ـ ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎن ﺳﺎﺧﺖ ﻳﻚ ‪ heap‬از ﺣﻞ ﻛﺪام ﻓﺮﻣﻮل ﺑﺎزﮔﺸﺘﻲ زﻳﺮ ﺣﺎﺻﻞ ﻣﻲﺷﻮد؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(87‬‬
‫‪ n ‬‬
‫‪T  n   T   O 1 (1‬‬
‫‪ 2‬‬
‫‪T  n   T  n  1  T  n  2   O  n  (2‬‬
‫‪ n ‬‬
‫‪T  n   2 T    O  n  (3‬‬
‫‪ 2‬‬
‫‪T  n   T  n  K  1  T  K   O 11  K  n (4‬‬
‫‪ 7‬ـ ﻛﺪامﻳﻚ از اﻋﻤﺎل زﻳﺮ را ﻧﻤﻲﺗﻮان در ﻳﻚ ‪ max-heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ در ﻣﺮﺗﺒﻪي )‪ O(lgn‬اﻧﺠﺎم داد؟ )ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(88‬‬
‫‪ (1‬ﻳﺎﻓﺘﻦ ﻳﻚ ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪ ﻣﺸﺨﺺ‬
‫‪ (2‬ﺣﺬف ﻳﻚ ﻋﻨﺼﺮ داده ﺷﺪه‬
‫‪ (3‬ﻛﺎﻫﺶ ﻣﻘﺪار ﻛﻠﻴﺪ ﻳﻚ ﻋﻨﺼﺮ داده ﺷﺪه‬
‫‪ (4‬اﻓﺰاﻳﺶ ﻣﻘﺪار ﻛﻠﻴﺪ ﻳﻚ ﻋﻨﺼﺮ داده ﺷﺪه‬
‫‪ 8‬ـ ﻫﻴﭗ زﻳﺮ داده ﺷﺪه اﺳﺖ‪:‬‬
‫‪A 1...18  20 15 18 7 9 14 16 3 6 8 4 13 10 12 11 1 2 5‬‬
‫ﻋﻤﻞ )‪ Change(i,k‬ﻛﻠﻴﺪ ‪ A i ‬را ﺑﻪ ‪ k‬ﺗﻐﻴﻴﺮ ﻣﻲدﻫﺪ و ﺑﺎ اﻧﺠﺎم ﺗﻌﺪاد ﺟﺎﺑﻪﺟﺎﻳﻲ ﻛﺎري ﻣﻲﻛﻨﺪ ﻛﻪ آراﻳﻪ ﻣﺠﺪداً ﺑﻪﺻﻮرت ﻫﻴﭗ درآﻳﺪ‪ .‬ﻣﺎ اﻳﻦ ‪2‬‬
‫ﻋﻤﻞ را ﺑﻪﺗﺮﺗﻴﺐ اﻧﺠﺎم ﻣﻲدﻫﻴﻢ‪. Change 11,16  Change  2, 4  :‬ﻣﺠﻤﻮع ﺗﻌﺪاد ﺟﺎﺑﻪﺟﺎﻳﻲ )‪(swap‬ﻫﺎ ﭼﻨﺪ ﺗﺎﺳﺖ؟)ﺳﺮاﺳﺮي ‪(88‬‬
‫‪3 (1‬‬
‫‪4 (2‬‬
‫‪5 (3‬‬
‫‪6 (4‬‬
‫‪28‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ 9‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ ﻳﻚ ﻣﺎﻛﺰﻳﻤﻢ ـ ﻫﻴﭗ دودوﻳﻲ ﺣﺎوي‪ N‬ﻋﺪد ﻣﺘﻤﺎﻳﺰ اﺳﺖ )ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ در رﻳﺸﻪ و دراﻳﻪي اول ﻗﺮار دارد(‪ .‬ﭼﻬـﺎرﻣﻴﻦ‬
‫ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ اﻳﻦ ﻋﻨﺎﺻﺮ در ﻛﺪامﻳﻚ از دراﻳﻪﻫﺎ ﻧﻤﻲﺗﻮاﻧﺪ ﻗﺮار ﺑﮕﻴﺮد؟ )‪ IT‬ﺳﺮاﺳﺮي ‪(83‬‬
‫‪ 2 (1‬ﻳﺎ ‪3‬‬
‫‪ 8 (2‬ﺗﺎ ‪15‬‬
‫‪ 6 ،5 ،4 (4‬ﻳﺎ ‪7‬‬
‫‪ 16 (3‬ﺗﺎ ‪31‬‬
‫‪ 10‬ـ ﻋﻤﻖ ﻳﻚ ﮔﺮه در دراﻳﻪي ‪ i‬در ﻳﻚ ﻫﻴﭗ ﺑﺎ ‪ n‬ﮔﺮه ﭼﻪﻗﺪر اﺳﺖ؟ ) ‪ IT‬ﺳﺮاﺳﺮي ‪(83‬‬
‫‪ lg i  (1‬‬
‫‪i  1 (2‬‬
‫‪ i / 2  (4‬‬
‫‪ i / 2  (3‬‬
‫‪ 11‬ـ ﻳﻚ درﺧﺖ دودوﻳﻲ ﺟﺴﺖوﺟﻮ ﺑﺎ ‪ n‬ﮔﺮه را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ ﻛﻪ ﻋﻨﺎﺻﺮ آن ﻣﺘﻤﺎﻳﺰ و ﺧﺎﺻﻴﺖ ﻫﺮم ﺑﻴﺸﻴﻨﻪ ﻫﻢ داﺷﺘﻪ ﺑﺎﺷﺪ )ﻣﻘﺪار ﻫـﺮ‬
‫رأس از ﻓﺮزﻧﺪاﻧﺶ ﻛﻢ ﺗﺮ ﻧﺒﺎﺷﺪ‪ (.‬اﮔﺮ ‪ h‬ارﺗﻔﺎع اﻳﻦ درﺧﺖ ﺑﺎﺷﺪ‪ ،‬دارﻳﻢ‪) :‬دﻛﺘﺮي ‪(91‬‬
‫‪ (2‬ﻣﻴﺎﻧﮕﻴﻦ ‪ h‬ﺑﺮاﺑﺮ ‪ O  lg n ‬اﺳﺖ‪.‬‬
‫‪ (4‬ﭼﻨﻴﻦ درﺧﺘﻲ وﺟﻮد ﻧﺪارد‪.‬‬
‫‪h  O  n  (1‬‬
‫‪h  O  lg n  (3‬‬
‫‪ 12‬ـ ﻧﻤﻲﺗﻮان ﺳﺎﺧﺘﻤﺎن دادهاي ﺑﺮاي ‪ n‬ﻋﻨﺼﺮ ﻃﺮاﺣﻲ ﻛﺮد ﻛﻪ …………… )ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(87‬‬
‫‪ (1‬ﺳﺎﺧﺖ آن ‪ O  n lg n ‬و ﺣﺬف ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ آن‪ ،‬درج و ﺣﺬف ﻛﻠﻴﺪ ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه در آن ‪ O  lg n ‬ﺑﺎﺷﺪ‪.‬‬
‫‪ (2‬ﺳﺎﺧﺖ آن ‪ O  n ‬و ﺣﺬف ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ آن‪ ،‬درج‪ ،‬ﺣﺬف و اﻓﺰاﻳﺶ و ﻛﺎﻫﺶ ﻛﻠﻴﺪ ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه در آن ‪ O  lg n ‬ﺑﺎﺷﺪ‪.‬‬
‫‪ (3‬ﺳﺎﺧﺖ آن ‪ O  n ‬و ﺣﺬف ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ آن‪ ،‬درج‪ ،‬ﺣﺬف و اﻓﺰاﻳﺶ ﻛﻠﻴﺪ ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه در آن ‪ O  lg n ‬ﺑﺎﺷﺪ‪.‬‬
‫‪ (4‬ﺳﺎﺧﺖ آن ‪ O  n ‬و ﺣﺬف ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ آن ‪ O 1‬و درج و ﺣﺬف ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه در آن ‪ O  lg n ‬ﺑﺎﺷﺪ‪.‬‬
‫‪ 13‬ـ ﺳﻮﻣﻴﻦ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ در ﻳﻚ ‪ Min Heap‬ﺑﺎ ﻛﻠﻴﺪﻫﺎي ﻣﺘﻤﺎﻳﺰ در دراﻳﻪﻫﺎﻳﻲ ﺑﺎ ﭼﻪ اﻧﺪﻳﺲﻫﺎﻳﻲ ﻣﻲﺗﻮاﻧﺪ ﺑﺎﺷﺪ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(86‬‬
‫‪2 , 3 , 4 , 5 , 6 , 7 (2‬‬
‫‪1 , 2 , 3 , 4 , 5 , 6 , 7 (4‬‬
‫‪1 , 2 , 3 (1‬‬
‫‪4 , 5 , 6 , 7 (3‬‬
‫‪ 14‬ـ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ دو ‪ min  heap‬ﺑﻪ ﺗﻌﺪاد ‪ m‬و ‪ n‬را ﺑﺎ ﻫﻢ ‪ merge‬ﻛﻨﻴﻢ ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ آن ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪):‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(85‬‬
‫‪m log mn (1‬‬
‫‪m log n  n log m (2‬‬
‫‪n log n .lg m (3‬‬
‫‪m.log n .log m (4‬‬
‫‪ 15‬ـ ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ ﺷﺎﻣﻞ ‪ n‬ﻋﺪد داده ﺷﺪه اﺳﺖ‪ .‬ﻣﻲﺧﻮاﻫﻴﻢ ﺗﻤﺎﻣﻲ اﻋﺪاد ﻛﻮﭼﻚﺗﺮ ﻳﺎ ﻣﺴﺎوي ﻳﻚ ﻋﺪد داده ﺷﺪهي ‪ x‬را در اﻳـﻦ ﻫـﺮم‬
‫ﭘﻴﺪا ﻛﻨﻴﻢ‪ .‬ﻓﺮض ﻛﻨﻴﺪ ﺗﻌﺪاد ﭼﻨﻴﻦ اﻋﺪادي ‪ k‬اﺳﺖ‪ .‬ﺑﻬﺘﺮﻳﻦ ﻣﺮﺗﺒﻪي زﻣﺎﻧﻲ ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﻛﺎر ﭼﻴﺴﺖ؟)دﻛﺘﺮي ‪(92‬‬
‫‪O  k  (1‬‬
‫‪O  k log k  (2‬‬
‫‪O  k log n  (3‬‬
‫‪O  k  n  (4‬‬
‫‪ 16‬ـ در ﻳﻚ آراﻳﻪ دﻟﺨﻮاه ﺑﺎ ‪ 12‬ﻋﻨﺼﺮ ﭼﻨﺪ ﻣﻘﺎﻳﺴﻪ ﺣﺪاﻛﺜﺮ ﻧﻴﺎز ﻣﻲﺑﺎﺷﺪ ﺗﺎ اﻳﻦ آراﻳﻪ ﺗﺒﺪﻳﻞ ﺑﻪ ﻳﻚ ‪ min  heap‬ﺷﻮد‪).‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(86‬‬
‫‪6 (1‬‬
‫‪10 (2‬‬
‫‪12 (3‬‬
‫‪18 (4‬‬
‫‪ 17‬ـ ﻳﻚ ‪ max – heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﺑﻪﺻﻮرت آراﻳﻪ ﭘﻴﺎدهﺳﺎزي ﺷﺪه اﺳﺖ‪) .‬ﻋﻨﺼﺮ ﻣﺎﻛﺰﻳﻤﻢ در رﻳﺸﻪ اﺳﺖ(‪ .‬ﻣﻨﺎﺳﺐﺗﺮﻳﻦ ﮔﺰﻳﻨﻪ ﺑﺮاي ﭘﻴﺪاﻛﺮدن‬
‫ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ در اﻳﻦ ﺳﺎﺧﺘﻤﺎن داده ﻛﺪام اﺳﺖ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(81‬‬
‫‪ (1‬اﻳﻦ ﻛﺎر را ﻫﻤﻮاره ﻣﻲﺗﻮان ﺑﺎ ‪ O  log n ‬ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ‪ heap‬اﻧﺠﺎم داد‪.‬‬
‫‪n‬‬
‫‪ (2‬اﻳﻦ ﻛﺎر ﺑﻪ ﺣﺪاﻛﺜﺮ‬
‫‪2‬‬
‫‪ (3‬اﻳﻦ ﻛﺎر ﻣﻤﻜﻦ اﺳﺖ ﺑﻪ ‪ n  1‬ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ‪ heap‬ﻧﻴﺎز داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ‪ heap‬ﻧﻴﺎز دارد‪.‬‬
‫‪ (4‬ﺗﻨﻬﺎ در ﺻﻮرﺗﻲ ﻛﻪ ‪ heap‬ﻋﻨﺎﺻﺮ ﺗﻜﺮاري ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻣﻲﺗﻮان اﻳﻦ ﻛﺎر را ﺑﺎ ‪ O  log n ‬ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ‪ heap‬اﻧﺠﺎم داد‪.‬‬
‫‪ 18‬ـ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ ﺑﺎ ﻋﻨﺎﺻﺮ ﻣﺘﻔﺎوت را ﺑﻪ ﺻﻮرت ﻛﺎرا ﺑﺎ ﭼﻨﺪ ﻣﻘﺎﻳﺴﻪ ﺑﻴﻦ ﻋﻨﺎﺻﺮ آن ﻣﻲﺗﻮان ﺑﻪ دﺳﺖ آورد؟)دﻛﺘﺮي ‪(91‬‬
‫‪(1‬‬
‫‪lg n   1‬‬
‫‪n  1 (2‬‬
‫‪ n / 2   1 (3‬‬
‫‪ n  1 / 2  (4‬‬
‫‪HEAP‬‬
‫‪29‬‬
‫‪ 19‬ـ ﻳﻚ ﻟﻴﺴﺖ ‪ 12‬ﻋﻨﺼﺮي ﺣﺎوي ﻛﻠﻴﺪﻫﺎي ﻳﻚ ﺗﺎ دوازده ﺑﻪ ﺻﻮرت ﺻﻌﻮدي ﻣﺮﺗﺐ اﺳﺖ‪ .‬اﮔﺮ اﻳﻦ ﻟﻴﺴﺖ ﺑﻪ ﺻﻮرت درﺟﺎ ﺗﺒﺪﻳﻞ ﺑﻪ ﻳﻚ ‪Max‬‬
‫‪ Heap‬ﺷﻮد‪ ،‬ﻋﻨﺼﺮ ﭘﻨﺠﻢ ﻟﻴﺴﺖ ﻛﺪام ﮔﺰﻳﻨﻪ اﺳﺖ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(89‬‬
‫‪10 (1‬‬
‫‪11 (2‬‬
‫‪8 (4‬‬
‫‪9 (3‬‬
‫‪ 20‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻛﻪ در ‪ Max – heap‬اﺳﺘﻔﺎده ﺷﺪه در ﺳﺎﺧﺘﻤﺎن دادهي ‪ ،X‬ﻫﺮ ﻋﻨﺼﺮ ﻳﻚ زوج ﻣﺮﺗﺐ ﺑﻪ ﺻﻮرت ‪  Key , Value ‬اﺳﺖ ﻛـﻪ‬
‫ﻣﻌﻴﺎر ﻣﻘﺎﻳﺴﻪي ﻋﻨﺎﺻﺮ ﻣﻘﺪار ‪ key‬آنﻫﺎ ﻣﻲﺑﺎﺷﺪ‪ .‬ﺳﺎﺧﺘﻤﺎن داده ‪ X‬ﻳﻚ ﭘﻴﺎدهﺳﺎزي از ﻛﺪام ﮔﺰﻳﻨﻪ اﺳﺖ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(89‬‬
‫‪Stack (2‬‬
‫‪Min Heap (4‬‬
‫‪Queue (1‬‬
‫‪Max Heap (3‬‬
‫{ ‪X::A  x ‬‬
‫;‪Count  ‬‬
‫; ‪Max  heap  insert  H ,  count , x  ‬‬
‫}‬
‫{ ‪X::B  x ‬‬
‫‪P  Heap  Extract  max  H ‬‬
‫; ‪Re turn  value  p ‬‬
‫}‬
‫‪ 21‬ـ اﮔﺮ آراﻳﻪ ‪ 10 15 22 4 11 23 19 14‬ﻧﻤﺎﻳﺶ ﻳﻚ درﺧﺖ ﺑﺎﻳﻨﺮي ﺑﺎﺷﺪ‪ ،‬و آن را ﺗﺒﺪﻳﻞ ﺑﻪ ﻳﻚ ‪ Min  Heap‬ﻧﻤـﺎﻳﻴﻢ در‬
‫آن ﺻﻮرت ﻣﺤﺘﻮاي آراﻳﻪ ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺑﻮد ﺑﺎ‪) :‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(83‬‬
‫‪4,10,15,19,11, 23, 22,14 (1‬‬
‫‪4,10,14,15,11,19, 22, 23 (2‬‬
‫‪4,10,11,14,15,19, 22, 23 (3‬‬
‫‪4,10,19,14,11, 23, 22,15 (4‬‬
‫‪ 22‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻣﻲﺧﻮاﻫﻴﻢ ﻣﺮﺗﺐﺳﺎزي ‪ Heap Sort‬را روي آراﻳﻪاي ﻛﻪ ﺷﺎﻣﻞ ‪ 14‬ﻋﻨﺼﺮ زﻳﺮ اﺳﺖ‪ ،‬اﻧﺠﺎم دﻫﻴﻢ‪،‬‬
‫‪A 1...A 14  16 , 50 , 23 , 20 , 21 , 40 , 41 , 30 , 3 , 32 , 33 , 34 , 35 , 36‬‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ آراﻳﻪ ﻳﻚ ‪ Max Heap‬ﺑﻪ ﺻﻮرت درﺟﺎ ﭼﻨﺪ ﺟﺎﺑﺠﺎﻳﻲ ﺑﻴﻦ ﮔﺮه ﺑﺎ ﻓﺮزﻧﺪ اﻧﺠﺎم ﻣﻲﺷﻮد؟)‪ IT‬ﺳﺮاﺳﺮي ‪(87‬‬
‫‪7 (1‬‬
‫‪6 (2‬‬
‫‪4 (4‬‬
‫‪5 (3‬‬
‫‪ 23‬ـ ﺑﻪ ﻳﻚ ‪ Min-heap‬ﺧﺎﻟﻲ ﮔﺮهﻫﺎﻳﻲ ﺑﺎ ﻛﻠﻴﺪﻫﺎي )ﺑﻪ ﺗﺮﺗﻴﺐ از رأﺳﺖ ﺑﻪ ﭼـﭗ( ‪ 2 , 50 , 45 , 70 , 75 , 22 , 40 , 55 , 45‬اﺿـﺎﻓﻪ ﺷـﺪه‬
‫اﺳﺖ‪ Min- heap .‬ﺣﺎﺻﻞ ﻛﺪام ﮔﺰﻳﻨﻪ اﺳﺖ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(86‬‬
‫‪2 , 22 , 45 , 40 , 75 , 70 , 45 , 55 , 50 (1‬‬
‫‪2 , 22 , 40 , 45 , 75 , 70 , 45 , 50 , 55 (3‬‬
‫‪2 , 45 , 22 , 50 , 75 , 45 , 40 , 70 , 55 (2‬‬
‫‪2 , 22 , 45 , 40 , 75 , 70 , 45 , 50 , 55 (4‬‬
‫‪ 24‬ـ ﺑﻪ ﻳﻚ ‪ Min–Heap‬ﺧﺎﻟﻲ ﺑﻪ ﺗﺮﺗﻴﺐ ﮔﺮهﻫﺎﻳﻲ ﺑﺎ ﻛﻠﻴﺪﻫﺎي )از رأﺳﺖ ﺑﻪ ﭼﭗ( ‪ 75 , 40 , 55 , 45 , 42 , 50 , 45 , 70‬اﺿﺎﻓﻪ ﺷﺪه اﺳـﺖ‪.‬‬
‫ﺳﭙﺲ ﻋﻤﻞ ﺣﺬف ‪  Delete ‬ﺑﺮ روي ‪ Min  Heap‬اﻧﺠﺎم ﺷﺪه اﺳﺖ‪ Min  Heap .‬ﺣﺎﺻﻞ ﻣﻄﺎﺑﻖ ﻛﺪام ﮔﺰﻳﻨﻪ ﺧﻮاﻫﺪ ﺑﻮد؟‬
‫)‪ IT‬ﺳﺮاﺳﺮي ‪(84‬‬
‫‪ 45 , 50 , 55 , 75 , 70 (2‬‬
‫‪ 45 , 55 , 50 , 75, 70 (4‬‬
‫‪ 45 , 50 , 55, 70 , 75 (1‬‬
‫‪ 45 , 55 , 50 , 70 , 75 (3‬‬
‫‪ 25‬ـ آراﻳﻪ ‪ n‬ﺧﺎﻧﻪاي ‪ A‬را در ﻧﻈﺮ ﻣﻲﮔﻴﺮﻳﻢ ﻛﻪ ﺑﺮاي ذﺧﻴﺮهﺳﺎزي ﻋﻨﺎﺻﺮ ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﮔﺮﻓﺘـﻪ‪ .‬ﻓـﺮض ﻛﻨـﻴﻢ‬
‫اﻟﮕﻮرﻳﺘﻤﻲ ﻛﺎرا ﺑﺮاي ﺑﺮرﺳﻲ اﻳﻦﻛﻪ اﻳﻦ درﺧﺖ دودوﻳﻲ ﻳﻚ ‪ Heap‬اﺳﺖ ﻳﺎ ﺧﻴﺮ در اﺧﺘﻴﺎر دارﻳﻢ‪ .‬ﭘﻴﭽﻴﺪﮔﻲ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ در ﺑـﺪﺗﺮﻳﻦ‬
‫ﺣﺎﻟﺖ ﭼﻘﺪر اﺳﺖ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪ ، 81‬ﺗﺨﺼﺼﻲ ﻫﻮش آزاد ‪(86‬‬
‫‪O  n  (1‬‬
‫‪  (2‬‬
‫‪O n2‬‬
‫‪O  log n  (3‬‬
‫‪O  n log n  (4‬‬
‫‪ 26‬ـ ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ ﺷﺪه ‪ L1 , L 2 ,..., L k‬ﻛﺪامﻳﻚ از ﺳﺎﺧﺘﺎر دادهﻫﺎي زﻳﺮ )ﻋﻼوه ﺑﺮ ﻟﻴﺴﺖﻫﺎي ورودي( ﺑﻬﺘﺮﻳﻦ اﺳﺖ؟‬
‫)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(83‬‬
‫‪ (1‬درﺧﺖ ‪Min-heap‬‬
‫‪ (2‬ﻟﻴﺴﺖ دو ﻃﺮﻓﻪ ﺧﻄﻲ‬
‫‪ (3‬آراﻳﻪ ﺧﻄﻲ‬
‫‪ (4‬درﺧﺖ دودوﻳﻲ ﺟﺴﺘﺠﻮ‬
‫‪30‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ 27‬ـ آراﻳﻪ ‪ T‬ﻛﻪ در آن ﺗﻌﺪادي از ﺧﺎﻧﻪﻫﺎ ﻫﻨﻮز ﻣﻘﺪاردﻫﻲ ﻧﺸﺪهاﻧﺪ را در ﻧﻈﺮ ﻣﻲﮔﻴﺮﻳﻢ‪.‬‬
‫‪10‬‬
‫‪9‬‬
‫‪8‬‬
‫‪7‬‬
‫‪6‬‬
‫‪28 20 7‬‬
‫‪4‬‬
‫‪5‬‬
‫‪17‬‬
‫‪3‬‬
‫‪30‬‬
‫‪2‬‬
‫‪1‬‬
‫‪75‬‬
‫‪T‬‬
‫ﺑﺎ ﻗﺮار دادن ﻣﻘﺎدﻳﺮ ﻛﺪام ﻳﻚ از ﻣﻮارد زﻳﺮ اﻳﻦ آراﻳﻪ ﺑﻪ ﻳﻚ ﻫﻴﭗ ﺗﺒﺪﻳﻞ ﺧﻮاﻫﺪ ﺷﺪ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(85‬‬
‫‪(1‬‬
‫‪T  2  30 ; T  4  9 ; T 9  10 ; T 10  6‬‬
‫‪T  2  15 ; T  4  15 ; T 9  17 ; T 10  10 (2‬‬
‫‪T  2  35 ; T  4  30 ; T 9  32 ; T 10  16 (3‬‬
‫‪T  2  21 ; T  4  14 ; T 9  0 ; T 10  16 (4‬‬
‫‪ 28‬ـ درﺧﺖ ﻧﻴﻤﻪ ﻣﺮﺗﺐ )‪ (Heap‬زﻳﺮ را ﺑﻪ ﺻﻮرت آراﻳﻪ ﭘﻴﺎدهﺳﺎزي ﻛﺮدهاﻳﻢ‪:‬‬
‫‪A[1...11]  13,14,16,19, 21,19, 68, 65, 26,32,31‬‬
‫اﮔﺮ ‪ D‬را ﻋﻤﻞ ‪) Deletemin‬ﺣﺬف ﻛﻮﭼﻜﺘﺮﻳﻦ اﻟﻤﺎن( ‪ I  x ‬را ﻋﻤﻞ درج ﻋﻨﺼﺮ ‪ x‬در ﻳﻚ درﺧﺖ ﻧﻴﻤﻪ ﻣﺮﺗﺐ ﺑﻨﺎﻣﻴﻢ آراﻳﻪ ﺣﺎﺻﻞ از‬
‫اﻋﻤﺎل زﻳﺮ را ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ از ﭼﭗ ﺑﻪ راﺳﺖ ﺑﺮ روي اﻳﻦ درﺧﺖ اﻧﺠﺎم ﻣﻲﺷﻮﻧﺪ ﻛﺪامﻳﻚ از ﮔﺰﻳﻨﻪﻫﺎي زﻳﺮ اﺳﺖ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(73‬‬
‫‪D , I  17  , I  15  , D , D‬‬
‫‪16 , 17 , 19 , 19 , 31 , 68 , 21 , 65 , 26 , 32 (1‬‬
‫‪16 , 19 , 17 , 19 , 31 , 21 , 68 , 65 , 26 , 32 (2‬‬
‫‪16 , 17 , 19 , 26 , 19 , 21 , 68 , 65 , 31 , 32 (3‬‬
‫‪(4‬‬
‫‪16 , 19 , 17 , 31 , 19 , 32 , 68 , 65 , 26 , 21‬‬
‫‪ 29‬ـ ﻓﺮض ﻛﻨﻴﺪ آراﻳﻪ ‪ A‬از اﻧﺪﻳﺲ ‪ 1‬ﺗﺎ ‪ n  1‬ﺑﻪ ﺻﻮرت ‪ heap‬اﺳﺖ‪) .‬رﻳﺸﻪ ‪ heap‬ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ اﺳﺖ( اﻟﮕﻮرﻳﺘﻢ زﻳﺮ ﺑﺮاي درج‬
‫‪ A  n ‬ﺑﻪ اﻳﻦ ‪ heap‬ﭘﻴﺸﻨﻬﺎد ﺷﺪه اﺳﺖ‪ .‬ﻛﺪامﻳﻚ از ﮔﺰﻳﻨﻪﻫﺎي زﻳﺮ را ﺑﺎﻳﺪ ﺑﺠﺎي ﻗﺮار دﻫﻴﻢ ﺗﺎ اﻟﮕﻮرﻳﺘﻢ ﻫﻤﻮاره درﺳﺖ ﻛﺎر ﻛﻨﺪ؟‬
‫)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(79‬‬
‫‪(1‬‬
‫‪(2‬‬
‫‪(3‬‬
‫‪(4‬‬
‫‪A  i   temp‬‬
‫‪A  i   temp‬‬
‫‪A  i   temp‬‬
‫‪A  i   A  j‬‬
‫‪i  1 and‬‬
‫‪i  0 and‬‬
‫‪i  0 and‬‬
‫‪i  1 and‬‬
‫‪procedure insert  A , n ‬‬
‫;‪int egeri , j, n‬‬
‫;‪j  n‬‬
‫; ‪i  n / 2‬‬
‫; ‪temp  A  n ‬‬
‫‪while...do‬‬
‫‪A  j  A  i ‬‬
‫;‪j  i‬‬
‫; ‪i  i / 2 ‬‬
‫‪endwhile‬‬
‫;‪A  j  temp‬‬
‫‪end‬‬
‫‪HEAP‬‬
‫‪31‬‬
‫‪ 30‬ـ آراﻳﻪ زﻳﺮ ﻳﻚ ‪ heap‬اﺳﺖ‪ .‬ﺑﺮاي درج ﻋﺪد ‪ 95‬در آراﻳﻪ ﺑﻪ ﮔﻮﻧﻪاي ﻛﻪ آراﻳﻪ ﻧﻬﺎﻳﻲ ﻧﻴﺰ وﺿﻌﻴﺖ ‪ heap‬داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﭼﻨـﺪ ﻋﻤـﻞ ‪exchange‬‬
‫)ﺗﻌﻮﻳﺾ دو ﻛﻤﻴﺖ( ﻻزم اﺳﺖ؟ )ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(80‬‬
‫‪ (1‬دو‬
‫‪ (2‬ﭼﻬﺎر‬
‫‪ (3‬ﺷﺶ‬
‫‪ (4‬ﻫﺸﺖ‬
‫‪100‬‬
‫‪90‬‬
‫‪82‬‬
‫‪85‬‬
‫‪74‬‬
‫‪75‬‬
‫‪73‬‬
‫‪68‬‬
‫‪70‬‬
‫‪ 31‬ـ ﻛﺪامﻳﻚ از ﮔﺰﻳﻨﻪﻫﺎي زﻳﺮ ﻧﻤﻲﺗﻮاﻧﺪ ﻳﻚ ﺑﺎزﻧﻤﺎﻳﻲ از ﻳﻚ ‪ Max Heap‬ﺑﺎ آراﻳﻪ ﺑﺎﺷﺪ )ﺗﺮﺗﻴﺐ ﻋﻨﺎﺻﺮ از ﭼﭗ ﺑﻪ راﺳﺖ اﺳﺖ(‪.‬‬
‫)‪ IT‬ﺳﺮاﺳﺮي ‪(85‬‬
‫‪20 17 17 3 4 2 1 (2‬‬
‫‪20 10 18 3 4 2 (4‬‬
‫‪20 5 10 6 3 4 1 (1‬‬
‫‪20 5 10 3 4 2 1 (3‬‬
‫‪ 32‬ـ ﭼﻨﺪ ‪ Min-heap‬ﻣﺘﻔﺎوت ﻣﻲﺗﻮان ﺑﺎ ‪ 7‬ﮔﺮه ﺑﺎ ﻛﻠﻴﺪﻫﺎي ‪ 1‬ﺗﺎ ‪ 7‬ﺳﺎﺧﺖ؟ )‪ IT‬ﺳﺮاﺳﺮي ‪ IT ، 88‬ﺳﺮاﺳﺮي ‪(90‬‬
‫‪160 (1‬‬
‫‪80 (2‬‬
‫‪20 (4‬‬
‫‪40 (3‬‬
‫‪ 33‬ـ ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮان اﻋﺪاد ‪ 1‬ﺗﺎ ‪ 11‬را در ﮔﺮهﻫﺎي درﺧﺖ زﻳﺮ ﺑﺮﭼﺴﺐﮔﺬاري ﻛﺮد ﺗﺎ ﻋﺪد ﻫﺮ ﮔـﺮه از اﻋـﺪاد ﻓﺮزﻧـﺪان آن ﺑـﺰرگﺗـﺮ‬
‫ﺑﺎﺷﺪ؟دﻗﺖ ﻛﻨﻴﺪ ﻛﻪ از ﻫﺮ ‪ 11‬ﻋﺪد ﺑﺎﻳﺪ اﺳﺘﻔﺎده ﺷﻮد و ﺗﻜﺮار ﻣﺠﺎز ﻧﻴﺴﺖ‪) .‬ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ـ ‪(1391‬‬
‫‪(1‬‬
‫‪(2‬‬
‫‪(3‬‬
‫‪(4‬‬
‫‪96‬‬
‫‪2048‬‬
‫‪11520‬‬
‫‪4096‬‬
‫‪ 34‬ـ ﻳﻚ ‪ Max Heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ را ﻛﻪ در آراﻳﻪ ‪ A 1...n ‬ﻗﺮار دارد‪ ،‬در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪ .‬ﻣﺮﺗﺒﻪ زﻣﺎﻧﻲ اﻟﮕﻮرﻳﺘﻢ ﺣﺬف ﻋﻨـﺼﺮ ‪ i‬ام ‪ 1  i  n ‬از‬
‫اﻳﻦ‪ Max Heap‬ﺑﻪ ﮔﻮﻧﻪاي ﻛﻪ ﺳﺎﺧﺘﺎر ‪ Max Heap‬را ﺣﻔﻆ ﻛﻨﺪ‪ ،‬ﭼﻴﺴﺖ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(1390‬‬
‫‪1 (1‬‬
‫‪log n (2‬‬
‫‪n (3‬‬
‫‪n log n (4‬‬
‫‪32‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ 35‬ـ ﻋﺪد در آراﻳﺔ ‪ T‬ذﺧﻴﺮ ﺷﺪهاﻧﺪ‪ .‬ﺑﺮاي ‪ T‬اﻟﮕﻮرﻳﺘﻢ ذﻛﺮ ﺷﺪه را اﺟﺮا ﻣﻲﻛﻨﻴﻢ‪ .‬اﮔﺮ ‪ t‬ﺗﻌﺪاد دﻓﻌﺎت اﺟﺮاي ﺣﻠﻘﻪ ‪ repeat‬ﺑﺎﺷﺪ ﺑﺎ ﻓﺮض اﻳﻨﻜـﻪ‬
‫‪ K   lg n ‬ﺑﺎﺷﺪ‪ .‬ﻛﺪامﻳﻚ از ﮔﺰارهﻫﺎي زﻳﺮ ﺻﺤﻴﺢ اﺳﺖ ؟)ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(86‬‬
‫‪ ...  k (1‬‬
‫‪k 3‬‬
‫‪3  2‬‬
‫‪ ...  k (2‬‬
‫‪k 2‬‬
‫‪4 2‬‬
‫‪k 2‬‬
‫‪t22‬‬
‫‪k 2‬‬
‫‪t3 2‬‬
‫‪ ...   k  1 (3‬‬
‫‪k 3‬‬
‫‪4 2‬‬
‫‪ ...   k  1 (4‬‬
‫‪k 2‬‬
‫‪3  2‬‬
‫‪k 2‬‬
‫‪k 1‬‬
‫‪‬‬
‫‪‬‬
‫‪procedure M T 1..n ‬‬
‫‪n‬‬
‫‪for i    downto 1 do‬‬
‫‪2‬‬
‫‪R i‬‬
‫‪t3 2‬‬
‫‪t22‬‬
‫‪repeat‬‬
‫‪j R‬‬
‫‪if 2 j  n and T  2 j  T  R  then‬‬
‫‪R 2j‬‬
‫‪if 2 j  1  n and T  2 j  1  T  R  then‬‬
‫‪R  2 j 1‬‬
‫‪swap T  j , T  R ‬‬
‫‪until j  R‬‬
‫‪ 36‬ـ ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎن ﺗﺒﺪﻳﻞ ﻳﻚ ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﺑﻪ ﻳﻚ درﺧﺖ ﺟﺴﺘﺠﻮي ﺑﺎﻳﻨﺮي ﺣﺪاﻗﻞ ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪) :‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(82‬‬
‫‪(log n) (1‬‬
‫‪(n 2 ) (3‬‬
‫‪(n) (2‬‬
‫‪(n log n) (4‬‬
‫‪ 37‬ـ ﺻﻒ اوﻟﻮﻳﺖ ‪  Pr iority Oueue ‬ﺑﺎ اﺳﺘﻔﺎده از ‪ Heap‬ﭘﻴﺎدهﺳﺎزي ﺷﺪه اﺳﺖ‪ .‬ﻛﺪامﻳﻚ از ﻋﺒﺎرات زﻳﺮ ﺻﺤﻴﺢ اﺳﺖ؟ ‪ n‬ﺗﻌﺪاد اﻗـﻼم در‬
‫ﺻﻒ اوﻟﻮﻳﺖ ﻣﻲﺑﺎﺷﺪ‪) .‬ﺳﺮاﺳﺮي ﻛﺎﻣﭙﻴﻮﺗﺮ ‪ IT ، 75‬آزاد ‪(84‬‬
‫‪ (1‬ﻋﻤﻠﮕﺮ »ﭘﻴﺪا ﻛﺮدن ﻣﺎﻛﺰﻳﻤﻢ و ﺣﺬف آن« از ﺻﻒ اوﻟﻮﻳﺖ داراي ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ‪ O 1‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪ (2‬ﻋﻤﻠﮕﺮ »اﺿﺎﻓﻪ ﻛﺮدن« ﻳﻚ ﻗﻠﻢ ﺟﺪﻳﺪ ﺑﻪ ﺻﻒ اوﻟﻮﻳﺖ داراي ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ‪ O  n lg n ‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪ (3‬ﻋﻤﻠﮕﺮ »ﭘﻴﺪا ﻛﺮدن ﻣﺎﻛﺰﻳﻤﻢ« داراي ﭘﻴﭽﻴﺪﮔﻲ ‪ O  lg n ‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪ (4‬ﻋﻤﻠﮕﺮ »اﺿﺎﻓﻪ ﻛﺮدن« ﻳﻚ ﻗﻠﻢ ﺟﺪﻳﺪ ﺑﻪ ﺻﻒ اوﻟﻮﻳﺖ داراي ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ‪ O  lg n ‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪ 38‬ـ داده ﺳﺎﺧﺘﺎر ) ‪ I‬ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ اﺳﺖ ﻛﻪ اﻋﺪاد دلﺧﻮاه ‪ a1 , , a n‬را در ﺑﺮگﻫﺎي ﺧﻮد ذﺧﻴﺮه ﻣﻲﻛﻨـﺪ‪) .‬درﺧـﺖ دودوﻳـﻲ‬
‫ﻛﺎﻣﻞ درﺧﺘﻲ اﺳﺖ ﻛﻪ اﮔﺮ ﺑﺮگﻫﺎي ﺳﻄﺢ آﺧﺮ آنرا ﺑﺮدارﻳﻢ‪ .‬درﺧﺖ ﺑﺎﻗﻲ ﻣﺎﻧﺪه ﭘﺮ ﻳﻌﻨﻲ ﻛﺎﻣﻞ و ﻛﺎﻣﻼً ﻣﺘﻮازن‪ ،‬ﺧﻮاﻫﺪ ﺑﻮد و ﺑﺮگﻫـﺎي‬
‫ﺳﻄﺢ آﺧﺮ آن ﺑﻪ ﺻﻮرت ﻣﺘﻮاﻟﻲ از ﭼﭗ ﺑﻪ راﺳﺖ ﻗﺮار دارﻧﺪ‪ .‬ﻫﺮم ﻳﺎ )‪ heap‬ﭼﻨﻴﻦ ﺳﺎﺧﺘﺎري دارد‪ (.‬ﻫﻢﭼﻨﻴﻦ ﻣﻲداﻧـﻴﻢ ﻛـﻪ ﻫـﺮ ﮔـﺮه‬
‫داﺧﻠﻲ ﻓﻘﻂ ﻣﻘﺪار ﻛﻮﭼﻚﺗﺮﻳﻦ ﻋﺪد دو ﻓﺮزﻧﺪش را ذﺧﻴﺮه ﻣﻲﻛﻨﺪ‪.‬‬
‫ﭼﻨﺪﺗﺎ از اﻋﻤﺎل زﻳﺮ را ﻣﻲﺗﻮان در اﻳﻦ داده ﺳﺎﺧﺘﺎر در ﻣﺮﺗﺒﻪي ‪ O  lg n ‬اﻧﺠﺎم داد؟)‪ IT‬ﺳﺮاﺳﺮي ‪(1392‬‬
‫‪ ‬ﺣﺬف ﻳﻚ ﻋﻨﺼﺮ دلﺧﻮاه از ‪D‬‬
‫‪ ‬درج ﻳﻚ ﻋﻨﺼﺮ دلﺧﻮاه در ‪D‬‬
‫‪ ‬ﻛﺎﻫﺶ ﻣﻘﺪار ﻳﻚ ﻋﻨﺼﺮ ﻣﻮﺟﻮد در ‪D‬‬
‫‪0 (1‬‬
‫‪1 (2‬‬
‫‪3 (4‬‬
‫‪2 (3‬‬
‫‪ 39‬ـ ﻳﻚ ﻫﺮم ﺑﻴﺸﻴﻨﻪ )‪ (max-heap‬ﺑﻪ اﻧﺪازهي ‪ m‬و ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ )‪ (min-heap‬ﺑﻪ اﻧﺪازهي ‪ n‬ﻣﻮﺟﻮدﻧﺪ‪ .‬ﺑﻬﺘﺮﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑـﺮاي ادﻏـﺎم‬
‫اﻳﻦ دو و اﻳﺠﺎد ﻳﻚ ﻫﺮم ﺑﻴﺸﻴﻨﻪ از ﻛﺪام ﻣﺮﺗﺒﻪ اﺳﺖ؟)‪ IT‬ﺳﺮاﺳﺮي ‪(1393‬‬
‫‪O  n  m  (1‬‬
‫‪O  n log m  m log n  (2‬‬
‫‪O  n log n  m log m  (3‬‬
‫‪O  min n log m , m log n  (4‬‬
‫‪ 40‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ ﺑﺎ ﻳﻚ درﺧﺖ ﻣﺘﻮازن ﭘﻴﺎده ﺳﺎزي ﺷﺪه اﺳﺖ‪ .‬ﻛﺪام ﮔﺰﻳﻨﻪ ﻧﺎدرﺳﺖ اﺳﺖ؟ )‪ IT‬ﺳﺮاﺳﺮي ‪(1394‬‬
‫‪ (1‬ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ ﺣﺘﻤﺎً در ﻳﻚ ﺑﺮگ ذﺧﻴﺮه ﺷﺪه اﺳﺖ‪.‬‬
‫‪HEAP‬‬
‫‪33‬‬
‫‪ (2‬ﺳﻮﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ ﺣﺘﻤﺎٌ ﻓﺮزﻧﺪ رﻳﺸﻪ اﺳﺖ‪.‬‬
‫‪ (3‬دوﻣﻴﻦ ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ ﻟﺰوﻣﺎً در ﺑﺮگ ذﺧﻴﺮه ﻧﻤﻲﺷﻮد‪.‬‬
‫‪ (4‬ﻫﺮ ﺳﻪ ﮔﺰﻳﻨﻪي ﺑﺎﻻ‬
‫‪ 41‬ـ ﻓﺮض ﻛﻨﻴﺪ دو ﻫﺮم ﻣﻴﻨﻴﻤﻢ ‪  min  heap ‬ﻫﺮ ﻳﻚ داراي ‪ n‬ﻋﺪد داده ﺷﺪه ﺑﺎﺷﻨﺪ‪ .‬ادﻏﺎم اﻳﻦ دو ﻫﺮم در ﻳﻚ آراﻳﻪ ﺑﻪ ﺻﻮرت ﺻـﻌﻮدي‬
‫داراي ﭼﻪ ﻣﺮﺗﺒﺔ زﻣﺎﻧﻲ اﺳﺖ؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(91‬‬
‫‪O  n  (1‬‬
‫‪O  log n  (2‬‬
‫‪‬‬
‫‪O  n log n  (3‬‬
‫‪‬‬
‫‪O n log 2 n (4‬‬
‫‪ 42‬ـ اﮔﺮ در اﻟﮕﻮرﻳﺘﻢ اﻓﺰودن ﻳﻚ ﻋﻨﺼﺮ ﺑﻪ درﺧﺖ ‪ heap‬از روش ﺟﺴﺘﺠﻮي دودوﻳﻲ ﺑﺮاي ﻳﺎﻓﺘﻦ ﻣﻜﺎن ﻋﻨﺼﺮ ﺟﺪﻳﺪ اﺳﺘﻔﺎده ﺷﻮد‪ ،‬ﻛﺪامﻳﻚ از‬
‫ﺟﻤﻼت زﻳﺮ ﺻﺤﻴﺢ اﺳﺖ؟) ﻧﺮماﻓﺰارآزاد ‪(81‬‬
‫‪ (1‬ﻣﺮﺗﺒﻪ اﻟﮕﻮرﻳﺘﻢ ﺗﻐﻴﻴﺮ ﻧﻜﺮده وﻟﻲ ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪﻫﺎ ﻛﻢﺗﺮ ﻣﻲﺷﻮد‪.‬‬
‫‪ (2‬ﻣﺮﺗﺒﻪ اﻟﮕﻮرﻳﺘﻢ و ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪﻫﺎ ﻛﻢﺗﺮ ﻣﻲﺷﻮد‪.‬‬
‫‪ (3‬ﻣﺮﺗﺒﻪ اﻟﮕﻮرﻳﺘﻢ ﺗﻐﻴﻴﺮ ﻧﻜﺮده وﻟﻲ ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪﻫﺎ ﺑﻴﺶﺗﺮ ﻣﻲﺷﻮد‪.‬‬
‫‪ (4‬ﻣﺮﺗﺒﻪ اﻟﮕﻮرﻳﺘﻢ و ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪﻫﺎ ﺗﻐﻴﻴﺮ ﻧﻤﻲﻛﻨﺪ‪.‬‬
‫‪ 43‬ـ ﺗﻌﺪاد ﺑﺮگﻫﺎي ﻳﻚ ‪ max – heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﭼﻨﺪ ﺗﺎ اﺳﺖ؟)دﻛﺘﺮي ‪(93‬‬
‫‪n  1 (1‬‬
‫‪n  2 (2‬‬
‫‪n‬‬
‫‪ 2  (3‬‬
‫‪ ‬‬
‫‪n‬‬
‫‪ 2  (4‬‬
‫‪ ‬‬
‫‪ 44‬ـ در ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ )‪ (min-heap‬ﺑﺎ ‪ n  100‬ﻋﻨﺼﺮ ﻣﻲﺧﻮاﻫﻴﻢ ﻋﻨﺼﺮ ﺑﺎ اﻧﺪﻳﺲ ‪ 10‬را ﺣﺬف ﻛﻨﻴﻢ‪) .‬ﻓﺮض ﻛﻨﻴﺪ آراﻳﻪاي ﻛـﻪ ﻫـﺮم را در‬
‫ﺧﻮد ذﺧﻴﺮه ﻛﺮده و داراي اﻧﺪﻳﺲﻫﺎي ‪ 1‬ﺗﺎ ‪ 100‬اﺳﺖ‪ (.‬اﻟﮕﻮرﻳﺘﻢ ﺣﺬف اﻳـﻦ ﻋﻨـﺼﺮ در ﺑـﺪﺗﺮﻳﻦ ﺣﺎﻟـﺖ ﭼـﻪ ﺗﻌـﺪاد ﻣﻘﺎﻳـﺴﻪ ﺑـﻴﻦ‬
‫ﻛﻠﻴﺪﻫﺎاﻧﺠﺎم ﻣﻲدﻫﺪ؟)دﻛﺘﺮي ‪(93‬‬
‫‪9 (1‬‬
‫‪7 (2‬‬
‫‪3 (4‬‬
‫‪5 (3‬‬
‫‪ 45‬ـ ﻛﺎراﺗﺮﻳﻦ اﻟﮕﻮرﻳﺘﻢ در ﭼﻪ زﻣﺎﻧﻲ ‪ k‬اُﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ را از ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﭘﻴﺪا ﻣﻴﻜﻨﺪ؟)داﻧﺸﮕﺎه ‪( MIT‬‬
‫‪O  k lg k  (1‬‬
‫‪O  n lg n  (2‬‬
‫‪ k lg n  (4‬‬
‫‪O  n  k  (3‬‬
‫‪ 46‬ـ اﻟﮕﻮرﻳﺘﻢ ‪ HeapSort‬در ﭼﻪ زﻣﺎﻧﻲ ﻳﻚ ورودي ﺑﺎ ﻋﻨﺎﺻﺮ ﻳﻜﺴﺎن را ﻣﺮﺗﺐ ﻣﻲ ﻛﻨﺪ؟)داﻧﺸﮕﺎه ‪( MIT‬‬
‫‪ ‬‬
‫‪O n 2 (1‬‬
‫‪O  n lg n  (2‬‬
‫‪ n lg2 n  (4‬‬
‫‪O  n  (3‬‬
‫‪ 47‬ـ در ﻳﻚ ‪ heap‬دﻟﺨﻮاه ﺑﺎ ‪n‬ﻋﻨﺼﺮ ﺑﻪ ﻃﻮر ﺗﺼﺎدﻓﻲ ﺑﻪ ﻫﺮ ﻋﻨﺼﺮ ﻳﻚ واﺣﺪ اﺿﺎﻓﻪ ﻳﺎ ﻳﻚ واﺣﺪ از آن ﻛﻢ ﻣﻴﻜﻨﻴﻢ در ﭼﻪ زﻣﺎﻧﻲ ﺗﻤﺎم ‪ n‬ﺗﻐﻴﻴﺮ‬
‫روي ﻫﻤﻪ ﻋﻨﺎﺻﺮ اﻧﺠﺎم ﺷﺪه و درﺧﺖ ﻫﻤﭽﻨﺎن ‪ heap‬ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ؟)داﻧﺸﮕﺎه ‪( MIT‬‬
‫‪O  lg n  (1‬‬
‫‪O  n  (2‬‬
‫‪ ‬‬
‫‪ n lg lg n  (4‬‬
‫‪O n 2 (3‬‬
‫‪ 48‬ـ ﻳﻚ ‪ heap‬ﺑﺎ ‪ n  2k‬ﻋﻨﺼﺮ را در آراﻳﻪ اي ﺑﻪ ﻃﻮل ‪ n‬در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪ ،‬اﮔﺮ ‪ n‬ﺑﺎر ﻋﻤﻞ ﺣﺬف ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ را ﺑﻄـﻮر ﻣﺘـﻮاﻟﻲ روي آن‬
‫اﻧﺠﺎم دﻫﻴﻢ و ﺑﺮاي اﻓﺰاﻳﺶ ﻛﺎراﻳﻲ ﺣﺎﻓﻈﻪ ﻫﺮﺑﺎر ﻛﻪ اﻧﺪازه ‪ heap‬ﺑﻪ ﺗﻮاﻧﻲ ﭘﺎﻳﻴﻦ ﺗﺮ) ‪ ( ..., 2k  2 , 2k 1  2 j‬ﻛﺎﻫﺶ ﭘﻴﺪا ﻛـﺮد آﻧـﺮا ﺑـﻪ‬
‫‪ ‬‬
‫آراﻳﻪ اي ﻛﻮﭼﻜﺘﺮ ﺑﻄﻮل ‪ 2 j‬اﻧﺘﻘﺎل دﻫﻴﻢ ‪ ،‬در ﺻﻮرﺗﻴﻜﻪ ﻫﺰﻳﻨﻪ ﻫﺮ اﻧﺘﻘﺎل ﺑﻪ اﻧﺪازه ﭘﺎﻳﻴﻦ ﺗﺮ ‪  2 j‬ﺑﺎﺷﺪ‪ ،‬ﻣﺠﻤﻮع ﻫﺰﻳﻨﻪ ﻫﺎي اﻧﺘﻘﺎل‬
‫در ﻛﻞ ﭼﻘﺪر اﺳﺖ ؟ ) ﻫﺰﻳﻨﻪ ﺣﺬف ﻋﻨﺎﺻﺮ ﺗﻮﺳﻂ اﻟﮕﻮرﻳﺘﻢ ‪ heapify‬را در ﻧﻈﺮ ﻧﮕﻴﺮﻳﺪ()داﻧﺸﮕﺎه ‪( MIT‬‬
‫‪O  n lg lg n  (1‬‬
‫‪O  n lg n  (2‬‬
‫‪O  n  (3‬‬
‫‪ n lg2 n  (4‬‬
‫‪ 49‬ـ در اﻟﮕﻮرﻳﺘﻢ ‪ heapify‬ﻳﻚ آراﻳﻪ دﻟﺨﻮاه ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ‪ A i ‬در ‪ heap‬در ﻋﻤﻖ ‪ a‬ﺧﻮاﻫﺪ ﺑﻮد و ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪﻫﺎ ﺑﺮاي ﮔﻨﺠﺎﻧﺪن اﻳﻦ ﻋﻨـﺼﺮ‬
‫در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ‪ b‬ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﻣﻘﺪار ‪ a‬و ‪ b‬ﭼﻴﺴﺖ؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(89‬‬
‫‪ n‬‬
‫‪ n‬‬
‫‪a   lg  , b  2 lg  (1‬‬
‫‪ i‬‬
‫‪ i‬‬
‫‪a   lg i  , b  2 lg i  (2‬‬
‫‪34‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪a   lg n  , b  2 lg n  (3‬‬
‫‪a   lg n  , b  2 lg n  (4‬‬
‫‪ 50‬ـ اﮔﺮ دﻧﺒﺎﻟﺔ زﻳﺮ ﻳﻚ ‪ max  heap‬را ﺑﺨﻮاﻫﺪ ﻧﺸﺎن دﻫﺪ ﻛﺪام اﻋﺪاد ﺑﺎﻳﺪ ﺑﺎ ﭼﻪ ﻣﻘﺎدﻳﺮ ﺗﻌﻮﻳﺾ ﺷﻮﻧﺪ؟)ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(88‬‬
‫‪23,17,14, 6,3,10,1,5, 7,11‬‬
‫) ‪ a‬ﺑﻪ ‪ b‬ﺗﻐﻴﻴﺮ ﻧﻤﺎﻳﺪ ﻳﻌﻨﻲ ‪( a  b‬‬
‫‪7  8 , 14  15 (2‬‬
‫‪10  11 , 1  8 (4‬‬
‫‪6  12 , 3  15 (1‬‬
‫‪6  9 , 3  10 (3‬‬
‫‪ 51‬ـ ﻓﺮض ﻛﻨﻴﺪ ﻳﻚ ﻫﺮم ﻛﻤﻴﻨﻪ ﺷﺎﻣﻞ ‪ n‬ﻋﺪد ﻣﺘﻤﺎﻳﺰ داده ﺷﺪه ﺑﺎﺷﺪ‪ .‬ﭘﻨﺠﻤﻴﻦ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻋﺪد در ﻛﺪامﻳﻚ از دراﻳﻪﻫﺎ ﻧﻤـﻲﺗﻮاﻧـﺪ ﻗـﺮار‬
‫ﺑﮕﻴﺮد؟ )ﻋﻨﺼﺮ رﻳﺸﺔ ﻫﺮم در دراﻳﺔ ﺷﻤﺎرة ‪ 1‬ﻗﺮار دارد‪) (.‬ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪(93‬‬
‫‪ 1 (1‬ﺗﺎ ‪5‬‬
‫‪ 8 (2‬ﺗﺎ ‪15‬‬
‫‪ 16 (3‬ﺗﺎ ‪31‬‬
‫‪ 32 (4‬ﺗﺎ ‪63‬‬
‫‪HEAP‬‬
‫‪35‬‬
‫‪ .1‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ در ﻣﺒﺤﺚ ‪ k‬اﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ ﻣﻄﺮح ﺷﺪ‪ ،‬در ﺻﻮرﺗﻲﻛﻪ ‪ max heap‬ﺣﺎوي اﻋﺪاد ﻣﺘﻤﺎﻳﺰ ‪  , 2,1‬ﺗـﺎ ‪ n‬ﺑﺎﺷـﺪ‪ .‬آنﮔـﺎه ﺑـﺰرگﺗـﺮﻳﻦ‬
‫ﻋﺪدي ﻛﻪ ﻣﻲﺗﻮاﻧﺪ در ﭘﺎﻳﻴﻦﺗﺮﻳﻦ ﺳﻄﺢ از درﺧﺖ ﻗﺮار ﮔﻴﺮد ﺑﺮاﺑﺮ ﺑﺎ ‪ n  lg n ‬ﺑﻮده ﻛﻪ ﺑﻪ آن ﻣﺎﻛﺰﻳﻤﻢ ‪ lg n   1‬ام ﻣﻲﮔﻮﻳﻨﺪ‪ .‬در اﻳﻦ ﺳﻮال دارﻳﻢ‪:‬‬
‫‪  n  lg n   58‬ﺑﺰرگﺗﺮﻳﻦ ﻋﺪد در ﺳﻄﺢ آﺧﺮ ‪n  64 ‬‬
‫ﻳﺎدآوري‪:‬‬
‫در ﻫﺮ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﻪ ارﺗﻔﺎع ‪ ، h‬ﺣﺪاﻗﻞ ﺗﻌﺪاد ﮔﺮه ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﺤﺎﺳﺒﻪ ﻣﻲﺷﻮد‪.‬‬
‫‪ n  2h‬‬
‫‪ n  2h 1‬‬
‫‪.2‬‬
‫‪ 0‬‬
‫‪‬‬
‫‪ 1‬‬
‫ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ در ﻣﺒﺤﺚ ‪ k‬اﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ ﻣﻄﺮح ﺷﺪ‪ ،‬در ﺻﻮرﺗﻲﻛﻪ ﻳﻚ ‪ Maxheap‬ﺣﺎوي اﻋﺪاد ﻣﺘﻤﺎﻳﺰ ‪  , 2,1‬ﺗﺎ ‪ n‬ﺑﺎﺷﺪ‪ .‬آنﮔﺎه ﺑـﺰرگﺗـﺮﻳﻦ‬
‫ﻋﺪدي ﻛﻪ ﻣﻲﺗﻮاﻧﺪ در ﭘﺎﻳﻴﻦﺗﺮﻳﻦ ﺳﻄﺢ از درﺧﺖ ﻗﺮار ﮔﻴﺮد ﺑﺮاﺑﺮ ﺑﺎ ‪ n  lg n ‬ﺑﻮده ﻛﻪ ﺑﻪ آن ﻣﺎﻛﺰﻳﻤﻢ ‪ lg n   1‬ام ﻣﻲﮔﻮﻳﻨﺪ‪ ،‬در اﻳﻦ ﺳﻮال دارﻳﻢ‪:‬‬
‫‪n  1023 ‬‬
‫‪  n  lg n   1014‬ﺑﺰرگﺗﺮﻳﻦ ﻋﺪد در ﺳﻄﺢ آﺧﺮ‬
‫اﻳﻦ ﻧﺸﺎن ﻣﻲدﻫﺪ ﻛﻪ ﺣﺪاﻛﺜﺮ ‪ 14‬ﻋﺪد ﺑﺰرگﺗﺮ از ‪ 1000‬ﻣﻲﺗﻮاﻧﻨﺪ در ﺳﻄﺢ آﺧﺮ درﺧﺖ ﻗﺮار ﮔﻴﺮﻧﺪ‪.‬‬
‫‪36‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﻳﺎدآوري‪ :‬ﺗﻌﺪاد ﮔﺮه در ﻫﺮ درﺧﺖ دودوﻳﻲ ﭘﺮ ﺑﻪ ارﺗﻔﺎع ‪ h‬ﺑﻪ ﺻﻮرت زﻳﺮ ﺑﻪ دﺳﺖ ﻣﻲآﻳﺪ‪:‬‬
‫‪n  2n 1  1‬‬
‫‪n  2h  1‬‬
‫‪.3‬‬
‫‪0‬‬
‫‪‬‬
‫‪1‬‬
‫ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﮔﺮ ﺑﻪ ﮔﺮهﻫﺎي ﻣﺘﻨﺎﻇﺮ در دو زﻳﺮ درﺧﺖ ﭼﭗ و راﺳﺖ دﻗﺖ ﻛﻨﻴﻢ اﺧﺘﻼف ﺑﻴﻦ ﻫﺮ دو ﮔﺮه ﻣﺘﻨﺎﻇﺮ ﺑﺮاﺑﺮ ﺑﺎ‬
‫‪1‬‬
‫‪2‬‬
‫اﺳﺖ‪.‬‬
‫ﺑﺮاي ﻣﺜﺎل اﮔﺮ ﮔﺮهﻫﺎي ﻣﺘﻨﺎﻇﺮ در ﺳﻄﺢ آﺧﺮ از درﺧﺖ ﺑﺎﻻ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‪ ،‬ﺟﺪول زﻳﺮ راﺑﻄﻪ ﺑﻴﻦ آنﻫﺎ را ﻧﺸﺎن ﻣﻲدﻫﺪ‪.‬‬
‫‪j  i  2 lg i  1‬‬
‫‪i‬‬
‫‪8  2lg 8 1  12‬‬
‫‪8‬‬
‫‪9  2lg 9  1  13‬‬
‫‪9‬‬
‫‪10 10  2lg10 1  14‬‬
‫‪11 11  2lg11 1  15‬‬
‫‪ j‬‬
‫دﻗﺖ ﻛﻨﻴﺪ‪ :‬زﻣﺎﻧﻲﻛﻪ ‪ j  n‬ﺑﺎﺷﺪ‪ ،‬ﻳﻌﻨﻲ ﮔﺮه ‪ j‬وﺟﻮد ﻧﺪارد ﺑﻨﺎﺑﺮاﻳﻦ ﮔﺮه ﻣﺘﻨﺎﻇﺮ ﺑﺮاي ‪ i‬ﺑﺮاﺑﺮ ﺑﺎ ‪  ‬ﺧﻮاﻫﺪ ﺑﻮد ﻛﻪ واﻟﺪ ﮔﺮه ‪ j‬اﺳﺖ‪.‬‬
‫‪2‬‬
‫‪HEAP‬‬
‫‪.4‬‬
‫‪37‬‬
‫ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﮔﺮ در ﻳﻚ ﻫﻴﭗ دﻟﺨﻮاه ﺟﺎي زﻳﺮ درﺧﺖ ﭼﭗ و راﺳﺖ را ﻋﻮض ﻛﻨﻴﻢ ﺑﺎ اﻳﻦﻛﻪ وﻳﮋﮔﻲ ﻫﻴﭗ ﺣﻔﻆ ﻣﻲﺷﻮد اﻣﺎ در ﺑﺮﺧﻲ ﺷﺮاﻳﻂ ﻣﻤﻜﻦ اﺳﺖ ﺳﺎﺧﺘﺎر درﺧـﺖ‬
‫از ﺣﺎﻟﺖ ﻛﺎﻣﻞ ﺧﺎرج ﺷﺪه و از ﺑﻴﻦ ﺑﺮود ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫‪.5‬‬
‫ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﺷﺮاﻳﻄﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﻳﻚ آراﻳـﻪ ﺑـﺎ وﻳﮋﮔـﻲ ‪ min heap‬را ﺑـﻪ ‪ max heap‬و ﻳـﺎ ﺑـﺎﻟﻌﻜﺲ ﺗﺒـﺪﻳﻞ ﻛﻨـﻴﻢ‪ .‬ﻫـﺮ ﮔـﺮه ﻏﻴﺮﺑـﺮگ در اﺛـﺮ ﻓﺮاﺧـﻮاﻧﻲ ﺗـﺎﺑﻊ‬
‫‪ HEAPIFY‬ﺗﺎ ﻳﻚ ﮔﺮه ﺑﺮگ ﭘﺎﻳﻴﻦ آﻣﺪه و ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ را ﺧﻮاﻫﻴﻢ داﺷﺖ در اﻳﻦ ﺷﺮاﻳﻂ ﺑﺮاي ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ در ارﺗﻔﺎع ‪ h‬ﺑﺎ اﻳﻦ ﻓـﺮض ﻛـﻪ در ﻫـﺮ‬
‫ﺳﻄﺢ دو ﻣﻘﺎﻳﺴﻪ ﻻزم دارﻳﻢ ﺣﺪاﻛﺜﺮ ‪ 2h‬ﻣﻘﺎﻳﺴﻪ ﻻزم اﺳﺖ ﺗﺎ ﺑﻪ ﻳﻚ ﮔﺮه ﺑﺮگ ﻣﻨﺘﻘﻞ ﺷﻮد‪.‬‬
‫‪‬‬
‫‪ n ‬‬
‫‪lg n ‬‬
‫‪‬‬
‫‪  ‬ﺣﺪاﻛﺜﺮ ﺗﻌﺪاد ﮔﺮه در ارﺗﻔﺎع ‪h‬‬
‫‪h‬‬
‫‪‬‬
‫‪ n ‬‬
‫‪ ‬ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ در ﻛﻞ‪n 1  ‬‬
‫‪ 2n‬‬
‫‪‬‬
‫‪2 ‬‬
‫‪ n 1   2h  n‬‬
‫‪h‬‬
‫‪‬‬
‫‪  2h‬ﺣﺪاﻛﺜﺮ ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﻫﺮ ﮔﺮه در ارﺗﻔﺎع ‪h‬‬
‫‪h 1  2‬‬
‫‪h 0 2‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ﻳﺎدآوري‪ :‬ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از ارﺗﻔﺎع ‪ h  1‬ﺗﺎ ‪ h  lg n ‬و ﮔﺮهﻫﺎي ﺑﺮگ ﻫﻤﮕﻲ در ارﺗﻔﺎع ‪ h  0‬ﻗﺮار دارﻧﺪ‪.‬‬
‫ﻳﺎدآوري‪ :‬ﺑﺮاي ﻣﺤﺎﺳﺒﻪ‬
‫‪‬‬
‫‪h‬‬
‫‪ 2h‬‬
‫ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﻣﺒﺤﺚ »ﻣﺸﺘﻖ ﺳﺮي ﻫﻨﺪﺳﻲ« در ﭘﻴﻮﺳﺖ ﻛﺘﺎب )ﻣﻘﺪﻣﻪ رﻳﺎﺿﻲ( دارﻳﻢ‪:‬‬
‫‪h 0‬‬
‫‪h‬‬
‫‪‬‬
‫‪ 2h  2‬‬
‫‪h 0‬‬
‫‪.6‬‬
‫‪1‬‬
‫‪‬‬
‫‪x‬‬
‫‪x‬‬
‫‪2 ‬‬
‫‪ h x h ‬‬
‫‪‬‬
‫‪h 0‬‬
‫‪1  x 2‬‬
‫‪‬‬
‫‪0  x 1‬‬
‫‪‬‬
‫ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ ﻣﻲداﻧﻴﻢ‪ ،‬زﻣﺎن ﺳﺎﺧﺖ ﻳﻚ ‪ heap‬از ﻣﺮﺗﺒﻪ ﺧﻄﻲ ﻳﻌﻨﻲ ‪ O  n ‬اﺳﺖ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ‬
‫ﻗﻀﻴﻪ اﺻﻠﻲ ﺣﺎﻟﺖ ‪ II ‬‬
‫‪ n ‬‬
‫‪  O 1  O  lg n ‬‬
‫‪ 2 ‬‬
‫‪ : T  n   T ‬ﮔﺰﻳﻨﻪ ‪1‬‬
‫‪: T  n   T  n  1  T  n  2   O  n   O  b n  , b  1‬‬
‫‪ *‬‬
‫ﻗﻀﻴﻪ اﺻﻠﻲ ﺣﺎﻟﺖ ‪ II ‬‬
‫‪ n ‬‬
‫‪  O  n   O  n lg n ‬‬
‫‪ 2‬‬
‫‪: T  n   2T ‬ﮔﺰﻳﻨﻪ ‪3‬‬
‫‪**‬‬
‫‪: T  n   T  n  k  1  T  k   O 1 ‬‬
‫‪On ‬‬
‫‪ : *‬اﻳﻦ ﺗﺎﺑﻊ از ﻧﻮع ﺧﻄﻲ ﻏﻴﺮﻫﻤﮕﻦ ﺑﻮده و از آنﺟﺎ ﻛﻪ ﻳﻜﻲ از رﻳﺸﻪﻫﺎي ﻣﻌﺎدﻟﻪ ﻣﺸﺨﺼﻪ در آن ﺑﺰرگﺗﺮ از ﻳﻚ اﺳـﺖ در ﻧﺘﻴﺠـﻪ ﺟـﻮاب ﺗـﺎﺑﻊ از ﻣﺮﺗﺒـﻪ‬
‫ﻧﻤﺎﻳﻲ ﺧﻮاﻫﺪ ﺑﻮد و ﺧﻄﻲ ﻧﻴﺴﺖ‪.‬‬
‫‪‬‬
‫‪1 5‬‬
‫‪ r1 ‬‬
‫‪2‬‬
‫‪‬‬
‫‪‬‬
‫‪1 5‬‬
‫‪‬‬
‫‪2‬‬
‫‪  2‬ﻣﻌﺎدﻟﻪ ﻣﺸﺨﺼﻪ‬
‫‪ 1n n1 ‬‬
‫‪ r  r  1  r  1  0  r 2 ‬‬
‫‪2‬‬
‫‪‬‬
‫‪r 3  r 4  1‬‬
‫‪n‬‬
‫‪n‬‬
‫‪t n  t n 1  t n  2‬‬
‫‪ 1 5 ‬‬
‫‪ 1 5 ‬‬
‫‪ 1 5 ‬‬
‫‪t n  c 1. ‬‬
‫‪  c 2 .‬‬
‫‪  c 3 .1n  c 4 .n.1n  O ‬‬
‫‪‬‬
‫‪ 2 ‬‬
‫‪ 2 ‬‬
‫‪ 2 ‬‬
‫‪38‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ : **‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦﻛﻪ ‪ 1  k  n‬اﺳﺖ اﮔﺮ از روش ﺟﺎﻳﮕﺬاري ﺑﺮاي ﻣﻘﺎدﻳﺮ ‪ n  3, 4,‬ﺑﻪ ازاء ‪ k  2‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ آنﮔﺎه ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫‪T  3  T  2   T  2   O 1  2 T  2   O 1‬‬
‫‪T  4   T  3  T  2   O 1  3T  2   O 1‬‬
‫‪T  5   T  4   T  2   O 1  4 T  2   O 1‬‬
‫‪‬‬
‫‪T  n   T  n  k  1  T  k   O 1   n  1 T  2   O 1  O  n ‬‬
‫‪.7‬‬
‫ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻫﺮ درﺧﺖ ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﻫﻤﻮاره‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪ ‬ﻳﺎﻓﺘﻦ ﻳﻚ ﻋﻨﺼﺮ ﺑﺎ ﻛﻠﻴﺪ ﻣﺸﺨﺺ از ﻣﺮﺗﺒﻪ ﺧﻄﻲ ﻳﻌﻨﻲ ‪ O n‬اﺳﺖ‪.‬‬
‫‪ ‬اﻧﺠﺎم ﻫﺮ ﻳﻚ از ﻋﻤﻠﻴﺎت ﺣﺬف‪ ،‬ﻛﺎﻫﺶ و اﻓﺰاﻳﺶ ﻣﻘﺪار ﻳﻚ ﻋﻨﺼﺮ ﻣﺸﺨﺺ از ﻣﺮﺗﺒﻪ ‪ O  lg n ‬اﺳﺖ‪.‬‬
‫‪.8‬‬
‫ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﮔﺮ ﻋﻤﻠﻴﺎت را ﺑﻪ ﺗﺮﺗﻴﺐ ‪. Change  2, 4  , Change 11,16 ‬اﻧﺠﺎم دﻫﻴﻢ آﻧﮕﺎه ﻣﺠﻤﻮع ﺗﻌﺪاد ﺟﺎﺑﻪﺟﺎﻳﻲ ﻫﺎ ‪ 4‬ﺧﻮاﻫﺪ ﺑﻮد‬
‫اﮔﺮ ﻋﻤﻠﻴﺎت را ﺑﻪ ﺗﺮﺗﻴﺐ ‪. Change 11,16  , Change  2, 4 ‬اﻧﺠﺎم دﻫﻴﻢ آﻧﮕﺎه ﻣﺠﻤﻮع ﺗﻌﺪاد ﺟﺎﺑﻪﺟﺎﻳﻲ ﻫﺎ ‪ 4‬ﺧﻮاﻫﺪ ﺑﻮد‬
‫‪HEAP‬‬
‫‪.9‬‬
‫‪39‬‬
‫ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻫﺮ درﺧﺖ ‪ Maxheap‬ﺑﺎ ‪ n‬ﻋﺪد ﻣﺘﻤﺎﻳﺰ ﻫﻤﻮاره ﻣﻲﺗﻮاﻧﻴﻢ ‪ i‬اﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ را از ﺳﻄﺢ دوم ﺗـﺎ ﺳـﻄﺢ ‪ i‬ام در ﺧﺎﻧـﻪﻫـﺎي ‪ 2‬ﺗـﺎ ‪ 2i  1‬ﻗـﺮار‬
‫دﻫﻴﻢ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ‪:‬‬
‫ﭼﻬﺎرﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ‪ :‬ﻣﻲﺗﻮاﻧﺪ در ﺧﺎﻧﻪﻫﺎي ‪ 2‬ﺗﺎ ‪ 24  1‬از ﺳﻄﺢ دوم ﺗﺎ ﺳﻄﺢ ﭼﻬﺎرم ﻗﺮار ﮔﻴﺮد ﻛﻪ ﺧﺎﻧﻪﻫﺎي ‪ 2‬و ‪ 3‬در ﺳﻄﺢ دوم‪ ،‬ﺧﺎﻧﻪﻫـﺎي ‪4‬‬
‫ﺗﺎ ‪ 7‬در ﺳﻄﺢ ﺳﻮم و ﺧﺎﻧﻪ ‪ 8‬ﺗﺎ ‪ 15‬در ﺳﻄﺢ ﭼﻬﺎرم ﻗﺮار دارد و در ﺣﺎﻟﻲﻛﻪ ﺧﺎﻧﻪﻫﺎي ‪ 16‬ﺗﺎ ‪ 31‬در ﺳﻄﺢ ﭘﻨﺠﻢ ﻗﺮار دارد‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﭼﻬﺎرﻣﻴﻦ ﺑﺰرگﺗﺮﻳﻦ‬
‫ﻧﻤﻲﺗﻮاﻧﺪ در اﻳﻦ ﺧﺎﻧﻪﻫﺎ ﻗﺮار ﮔﻴﺮد‪.‬‬
‫‪ .10‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻋﻤﻖ ﻫﺮ ﮔﺮه ﺑﺎ ﺷﻤﺎره ‪ i‬در ﻫﺮ درﺧﺖ ‪ heap‬ﺑﺎ ‪ n‬ﮔﺮه ﻣﺎﻧﻨﺪ ﻫﺮ درﺧﺖ ﻛﺎﻣﻞ ﻣﺴﺘﻘﻞ از ‪ n‬ﺑﻮده و ﺑﺮاﺑﺮ ﺑﺎ ‪ lg i ‬اﺳﺖ‪.‬‬
‫‪ .11‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻳﻚ درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ﺗﻨﻬﺎ در ﺻﻮرﺗﻲﻛﻪ ارﻳﺐ ﺑﻪ ﭼﭗ ﻳﺎ ارﻳﺐ ﺑـﻪ راﺳـﺖ ﺑﺎﺷـﺪ ﻣـﻲﺗﻮاﻧـﺪ ﺧﺎﺻـﻴﺖ ﻫـﺮم ﺑﻴـﺸﻴﻨﻪ )‪ (Maxheap‬ﻳـﺎ ﻫـﺮم ﻛﻤﻴﻨـﻪ‬
‫)‪ (minheap‬را داﺷﺘﻪ ﺑﺎﺷﺪ ﺑﻪ ﻃﻮر ﻣﺜﺎل درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ﺑﺎ ﻛﻠﻴﺪﻫﺎي ‪  ,3, 2,1‬ﺗﺎ ‪ n‬را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪.‬‬
‫ﺑﻨﺎﺑﺮاﻳﻦ ارﺗﻔﺎع درﺧﺖ ﻣﻮردﻧﻈﺮ ‪ h  O  n ‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪ .12‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :1‬ﺳﺎﺧﺘﻤﺎن داده ‪) AVL‬درﺧﺖ ﺟﺴﺘﺠﻮي ﻣﺘﻮازن( اﻳﻦﮔﻮﻧﻪ ﻃﺮاﺣﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :2‬ﺳﺎﺧﺘﻤﺎن داده ‪) maxheap‬ﻫﺮم ﺑﻴﺸﻴﻨﻪ( اﻳﻦﮔﻮﻧﻪ ﻃﺮاﺣﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :3‬ﺳﺎﺧﺘﻤﺎن داده ‪) maxheap‬ﻫﺮم ﺑﻴﺸﻴﻨﻪ( اﻳﻦﮔﻮﻧﻪ ﻃﺮاﺣﻲ ﻣﻲﺷﻮد‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :4‬ﻫﻴﭻ ﺳﺎﺧﺘﻤﺎن دادهاي را ﻧﻤﻲﺗﻮان ﺑﺪﻳﻦﮔﻮﻧﻪ ﻃﺮاﺣﻲ ﻛﺮد‪.‬‬
‫‪ .13‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪i‬‬
‫در ﻫﺮ درﺧﺖ ‪ minheap‬ﺑﺎ ‪ n‬ﻛﻠﻴﺪ ﻣﺘﻤﺎﻳﺰ‪ ،‬ﻫﻤﻮاره ﻣﻲﺗﻮاﻧﻴﻢ ‪ i‬اﻣﻴﻦ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ را از ﺳﻄﺢ دوم ﺗﺎ ﺳﻄﺢ ‪ i‬ام در ﺧﺎﻧـﻪﻫـﺎي ‪ 2‬ﺗـﺎ ‪ 2  1‬ﻗـﺮار‬
‫دﻫﻴﻢ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ‪:‬‬
‫ﺳﻮﻣﻴﻦ ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ‪ :‬ﻣﻲﺗﻮاﻧﺪ دار ﺧﺎﻧﻪﻫﺎي ‪ 2‬ﺗﺎ ‪ 23  1‬از ﺳﻄﺢ دوم ﺗﺎ ﺳﻄﺢ ﺳﻮم ﻗﺮار ﮔﻴﺮدﻛﻪ ﺧﺎﻧﻪﻫﺎي ‪ 2‬و ‪ 3‬در ﺳﻄﺢ دوم و ﺧﺎﻧﻪﻫﺎي ‪ 4‬ﺗـﺎ‬
‫‪ 7‬در ﺳﻄﺢ ﺳﻮم ﻗﺮار دارﻧﺪ‪.‬‬
‫‪ .14‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫روش اول‪:‬‬
‫ﻳﻜﻲ از دو ﺣﺎﻟﺖ )اﻟﻒ( ﻳﺎ )ب( را ﺑﺮاي دو ﻫﻴﭗ اﻧﺠﺎم ﻣﻲ دﻫﻴﻢ ‪:‬‬
‫اﻟﻒ ‪ -‬ﻋﻨﺎﺻﺮ را ﻳﻜﻲ ﻳﻜﻲ از ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﺧﺎرج ﻛﺮده و در ‪ heap‬ﺑﺎ ‪ m‬ﻋﻨﺼﺮ درج ﻣﻲﻛﻨﻴﻢ ‪ ،‬زﻣﺎن ﻻزم ‪ O  m lg m  m lg n  m lg mn ‬اﺳﺖ‪.‬‬
‫‪40‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ب ‪ -‬ﻋﻨﺎﺻﺮ را ﻳﻜﻲ ﻳﻜﻲ از ‪ heap‬ﺑﺎ ‪ m‬ﻋﻨﺼﺮ ﺧﺎرج ﻛﺮده و در ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ درج ﻣﻲﻛﻨﻴﻢ ‪ ،‬زﻣﺎن ﻻزم ‪ O  n lg n  n lg m  n lg mn ‬اﺳﺖ‪.‬‬
‫روش دوم‪:‬‬
‫ﻋﻨﺎﺻﺮ دو ‪ heap‬را در آراﻳﻪ اي ﺑﻪ ﻃﻮل ‪ m+n‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ و اﻟﮕﻮرﻳﺘﻢ ‪ BUILD-MAX-HEAP‬را ﺑﺮاي آن در زﻣﺎن ‪ O  m  n ‬اﺟﺮا ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫‪ .15‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺎ اﺳﺘﻔﺎده از ﭘﻴﻤﺎﻳﺶ ﻋﻤﻘﻲ ﺷﺒﻴﻪ ﺑﻪ ‪) VLR‬ﭘﻴﺶ ﺗﺮﺗﻴﺐ( و ﻳﻚ ﺷﻤﺎرﻧﺪه ﺑﺎ ﻣﻘﺪار اوﻟﻴﻪ ﺻﻔﺮ ‪  co unt  0 ‬در درﺧﺖ از ﺑـﺎﻻ ﺑـﻪ ﭘـﺎﻳﻴﻦ و از ﭼـﭗ ﺑـﻪ‬
‫راﺳﺖ ﺣﺮﻛﺖ ﻣﻲﻛﻨﻴﻢ ﻫﻨﮕﺎم رﺳﻴﺪن ﺑﻪ ﻫﺮ ﮔﺮه ﻣﻘﺪار ﻛﻠﻴﺪ آنرا ﺑﺎ ‪ x‬ﻣﻘﺎﻳﺴﻪ ﻣﻲﻛﻨﻴﻢ‪:‬‬
‫‪ : key  x ‬ﻳﻚ واﺣﺪ ﺑﻪ ﺷﻤﺎرﻧﺪه ‪ count‬اﺿﺎﻓﻪ ﻛﺮده و ﻣﺴﻴﺮ را ﺑﺮ ﻃﺒﻖ ﭘﻴﻤﺎﻳﺶ ‪ VLR‬اداﻣﻪ ﻣﻲدﻫﻴﻢ‪.‬‬
‫‪ : key  x ‬اداﻣﻪ ﻣﺴﻴﺮ را ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﻣﺘﻮﻗﻒ ﻛﺮده و ﺑﺮ ﻃﺒﻖ ﭘﻴﻤﺎﻳﺶ ‪ VLR‬ﺑﻘﻴﻪ زﻳﺮ درﺧﺘﺎن را ﺑﺮرﺳﻲ ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﺑﻪﻃﻮر ﻣﺜﺎل ﻓﺮض ﻛﻨﻴﺪ ﻣﻲﺧﻮاﻫﻴﻢ ﺗﻤﺎم اﻋﺪاد ﻛﻮﭼﻚﺗﺮ ﻳﺎ ﻣﺴﺎوي ﺑﺎ ‪ x  38‬را در ﻫﺮم ﻛﻤﻴﻨﻪ )‪ (minheap‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﭘﻴﺪا ﻛﻨﻴﻢ‪:‬‬
‫ﺗﺤﻠﻴﻞ‪ :‬ﺑﺎ اﻳﻦ ﻓﺮض ﻛﻪ دﻗﻴﻘﺎً ‪ k‬ﻋﻨﺼﺮ ﻛﻮﭼﻚﺗﺮ ﻳﺎ ﻣﺴﺎوي ﺑﺎ ‪ x‬وﺟﻮد دارﻧﺪ زﻣﺎن اﺟﺮا ﻧﻬﺎﻳﺘﺎً ‪ O  k ‬ﺧﻮاﻫﺪ ﺷﺪ در ﻋﻴﻦ ﺣﺎل اﮔﺮ ‪ k‬ﻣﻌﻠﻮم ﻧﺒﺎﺷﺪ آنﮔﺎه‬
‫زﻣﺎن ﺣﺪاﻛﺜﺮ ‪ O  n ‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪ .16‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ ﻣﻲداﻧﻴﺪ ﺑﺮاي ﺗﺒﺪﻳﻞ ﻳﻚ آراﻳﻪ ﺑﻪ ﻳﻚ ‪ heap‬ﺑﺎﻳﺪ ﺑﺮاي ﺗﻤﺎم ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از ﺗﺎﺑﻊ ‪ heapify‬اﺳﺘﻔﺎده ﺷﻮد در اﻳﻦ ﺷـﺮاﻳﻂ ﺣـﺪاﻛﺜﺮ ﻣﻘﺎﻳـﺴﻪ‬
‫ﺑﺮاي ﻫﺮ ﮔﺮه ﻏﻴﺮ ﺑﺮگ زﻣﺎﻧﻲ اﺗﻔﺎق ﻣﻲاﻓﺘﺪ ﻛﻪ در اﺛﺮ ﻣﻘﺎﻳﺴﻪ و ﺟﺎﺑﺠﺎﻳﻲ ﺑﺎ ﺗﺎﺑﻊ ﻓﻮق ﺑﻪ ﭘﺎﻳﻴﻦﺗﺮﻳﻦ ﺑﺮگ در ﻳﻜﻲ از زﻳﺮدرﺧﺘﺎن ﻣﺸﺘﻖ ﺷﺪه از ﻓﺮ؟؟؟ ﻣﻨﺘﻘـﻞ‬
‫ﺷﻮد‪.‬‬
‫ﮔﺮه‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫وﺿﻌﻴﺖ ﻣﻘﺎﻳﺴﻪ ﮔﺮه در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ‬
‫ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮه ‪12‬‬
‫ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮهﻫﺎي ‪11,10 ‬‬
‫ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮهﻫﺎي ‪ 9,8 ‬‬
‫اﺑﺘﺪا ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮهﻫﺎي ‪  7, 6 ‬ﺳﭙﺲ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮه ‪12 ‬‬
‫اﺑﺘﺪا ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮهﻫﺎي ‪  5, 4 ‬ﺳﭙﺲ ﺑﺎ ﻳﻜﻲ از زوج ﮔﺮه ﻫﺎي ‪  9,8‬ﻳﺎ ‪11,10 ‬‬
‫اﺑﺘﺪا ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﮔﺮهﻫﺎي ‪  3, 2 ‬ﺳﭙﺲ ﺑﺎ ﮔﺮهﻫﺎي ‪ ،  5, 4 ‬در اﻧﺘﻬﺎ ﺑﺎ ﻳﻜﻲ از زوج ﮔﺮه ﻫﺎي ‪  9,8‬ﻳﺎ ‪11,10 ‬‬
‫ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪ‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪6‬‬
‫‪  18 ‬ﻣﺠﻤﻮع‬
‫‪HEAP‬‬
‫‪41‬‬
‫‪ .17‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻳﻚ ‪ maxheap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﻛﻪ ﺑﻪ ﺻﻮرت آراﻳﻪ ﭘﻴﺎدهﺳﺎزي ﺷﺪه اﺳﺖ ﻋﻨﺼﺮ ﻣﻲﻧﻴﻤﻢ در ﻳﻜﻲ از ﺑﺮگﻫﺎ ﻗﺮار دارد ﺑﻨـﺎﺑﺮاﻳﻦ از آنﺟـﺎ ﻛـﻪ ﺗﻌـﺪاد ﺑـﺮگﻫـﺎ‬
‫‪n‬‬
‫‪n‬‬
‫‪  ‬اﺳﺖ ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻋﻨﺼﺮ ﻣﻲﻧﻴﻤﻢ ﺑﻪ دﻗﻴﻘﺎً ‪    1‬ﻣﻘﺎﻳﺴﻪ ﻧﻴﺎز دارﻳﻢ‪.‬‬
‫‪2‬‬
‫‪2‬‬
‫‪ n ‬‬
‫‪‬‬
‫‪ n  1  n ‬‬
‫‪ ‬اﺳﺖ‬
‫ﻳﺎدآوري‪ :‬زﻳﺮ آراﻳﻪ ‪ A   2   1, , n ‬ﻫﻤﮕﻲ ﺑﺮگ ﻫﺴﺘﻨﺪ‪ ،‬و ﺗﻌﺪاد آﻧﻬﺎ ﺑﺮاﺑﺮ ﺑﺎ ‪   ‬‬
‫‪ 2  2‬‬
‫دﻗﺖ ﻛﻨﻴﺪ‪ :‬ﻃﺮاح ﺳﻮال ﺑﻪ اﺷﺘﺒﺎه در ﮔﺰﻳﻨﻪ ‪ 2‬از ﻛﻠﻤﻪ "ﺣﺪاﻛﺜﺮ" اﺳﺘﻔﺎده ﻛﺮده اﺳﺖ‪.‬‬
‫‪ .18‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻳﻚ ‪ minheap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﻛﻪ ﺑﻪ ﺻﻮرت آراﻳﻪ ‪ A 1, , n ‬ﭘﻴﺎدهﺳﺎزي ﺷﺪه اﺳﺖ ﻋﻨﺼﺮ ﻣﺎﻛﺰﻳﻤﻢ )ﺑﺰرگﺗﺮﻳﻦ ﻋﻨﺼﺮ( در ﻳﻜـﻲ از ﺑـﺮگﻫـﺎ ﻗـﺮار دارد‪.‬‬
‫‪n ‬‬
‫‪n‬‬
‫ﺑﻨﺎﺑﺮاﻳﻦ از آنﺟﺎ ﻛﻪ ﺗﻌﺪاد ﺑﺮگﻫﺎ ‪  ‬اﺳﺖ ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻋﻨﺼﺮ ﻣﺎﻛﺰﻳﻤﻢ ﺑﻪ دﻗﻴﻘﺎً ‪    1‬ﻣﻘﺎﻳﺴﻪ ﻧﻴﺎز دارﻳﻢ‪ .‬در ﻋﻴﻦ ﺣﺎل ﮔﺰﻳﻨﻪ ‪ 4‬ﺗﻌﺪاد ﺑﺮﮔﻬﺎ را‬
‫‪2‬‬
‫‪2‬‬
‫ﻧﺸﺎن ﻣﻲ دﻫﺪ‪.‬‬
‫‪‬‬
‫‪‬‬
‫ﻳﺎدآوري‪ :‬زﻳﺮ آراﻳﻪ ‪  1, , n ‬‬
‫‪ n‬‬
‫‪ n  1  n ‬‬
‫‪ ‬اﺳﺖ‬
‫‪ A  ‬ﻫﻤﮕﻲ ﺑﺮگ ﻫﺴﺘﻨﺪ‪ .‬و ﺗﻌﺪاد آﻧﻬﺎ ﺑﺮاﺑﺮ ﺑﺎ ‪  ‬‬
‫‪‬‬
‫‪ 2‬‬
‫‪ 2  2‬‬
‫‪ .19‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ ﻳﻚ آراﻳﻪ ﺑﻪ ﻳﻚ ‪ max heap‬ﺑﻪ ﺻﻮرت درﺟﺎ ﺑﺎﻳﺪ ﺑﺮاي ﻫﺮ ﻳﻚ از ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از روال ‪ heapify‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﻳﻦ ﻋﻤﻞ ﺑﺎﻳﺪ از ﭘﺎﻳﻴﻦ ﺑـﻪ‬
‫ﺑﺎﻻ و ﺳﻄﺢ ﺑﻪ ﺳﻄﺢ از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮﺑﺮگ ﺗﺎ ﮔﺮه رﻳﺸﻪ اﻧﺠﺎم ﭘﺬﻳﺮد‪.‬‬
‫‪ .20‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻳﻚ ‪ maxheap‬ﻛﻪ در آن ﻫﺮ ﮔﺮه ﺑﻪ ﺻﻮرت زوج >ﻣﻘﺪار ﻛﻠﻴﺪ=‪ Value‬و اﻧﺪﻳﺲ=‪ < key‬ﻧﻤﺎﻳﺶ داده ﻣﻲﺷﻮد‪ .‬ﺳﺎﺧﺘﻤﺎن داده ‪ x‬ﻣﻲﺗﻮاﻧﺪ ﺑﻪ ﻳﻜﻲ از دو‬
‫ﺷﻜﻞ زﻳﺮ ﭘﻴﺎدهﺳﺎزي ﺷﻮد‪:‬‬
‫ﺻﻒ )‪(Queue‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫درج در اﻧﺘﻬﺎ‪ count++ :‬ﻳﻚ ﮔﺮه ﺑﻪ اﻧﺘﻬﺎي ﺳﺎﺧﺘﺎر اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ‪.‬‬
‫ﺣﺬف از اﺑﺘﺪا‪ :‬اﮔﺮ ﻣﻌﻴﺎر ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﺣﺬف ‪ ،‬ﺑﺰرگﺗﺮﻳﻦ ﻣﻘﺪار ﻛﻠﻴﺪ )‪ (Value‬ﺑﺎﺷﺪ آنﮔﺎه ﻋﻤﻞ ﺣﺬف از اﺑﺘﺪا )رﻳﺸﻪ( اﻧﺠﺎم ﻣﻲﺷﻮد‪.‬‬
‫ﭘﺸﺘﻪ )‪(Stack‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫درج در اﻧﺘﻬﺎ‪ count++ :‬ﻳﻚ ﮔﺮه ﺑﻪ اﻧﺘﻬﺎي ﺳﺎﺧﺘﺎر اﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ‪.‬‬
‫ﺣﺬف از اﻧﺘﻬﺎ‪ :‬اﮔﺮ ﻣﻌﻴﺎر ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﺣﺬف ‪ ،‬ﺑﺰرگﺗﺮﻳﻦ اﻧﺪﻳﺲ )‪ (key‬ﺑﺎﺷﺪ‪ .‬آنﮔﺎه ﻋﻤﻞ ﺣﺬف از اﻧﺘﻬﺎ )ﮔﺮه آﺧﺮ( اﻧﺠﺎم ﻣﻲﺷﻮد‬
‫‪42‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪.‬‬
‫در اﻳﻦ ﺳﻮال از آنﺟﺎ ﻛﻪ ﻣﻌﻴﺎر ﻣﻘﺎﻳﺴﻪ ‪ key‬اﺳﺖ ﺑﻨﺎﺑﺮاﻳﻦ ﭘﻴﺎدهﺳﺎزي ﻣﺮﺑﻮط ﺑﻪ ﭘﺸﺘﻪ اﺳﺖ‪.‬‬
‫‪ .21‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ ﻳﻚ آراﻳﻪ ﺑﻪ ﻳﻚ ‪ minheap‬ﺑﺎﻳﺪ ﺑﺮاي ﻫﺮ ﻳﻚ از ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از روال ‪ heapify‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﻳﻦ ﻋﻤﻞ ﺑﺎﻳﺪ از ﭘـﺎﻳﻴﻦ ﺑـﻪ ﺑـﺎﻻ و ﺳـﻄﺢ ﺑـﻪ‬
‫ﺳﻄﺢ اﻧﺠﺎم ﺷﻮد‪) .‬از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮﺑﺮگ ﺗﺎ ﮔﺮه رﻳﺸﻪ(‬
‫‪ .22‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺮاي ﺗﺒﺪﻳﻞ ﻳﻚ آراﻳﻪ ﺑﻪ ﻳﻚ ‪ maxheap‬درﺟﺎ ﺑﺎﻳﺪ ﺑﺮاي ﻫﺮ ﻳﻚ از ﮔﺮهﻫﺎي ﻏﻴﺮﺑﺮگ از روال ‪ heapify‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﻳﻦ ﻋﻤﻞ ﺑﺎﻳﺪ از ﭘﺎﻳﻴﻦ ﺑﻪ ﺑﺎﻻ و ﺳـﻄﺢ‬
‫ﺑﻪ ﺳﻄﺢ اﻧﺠﺎم ﺷﻮد )از آﺧﺮﻳﻦ ﮔﺮه ﻏﻴﺮﺑﺮگ ﺗﺎ ﮔﺮه رﻳﺸﻪ(‬
‫‪HEAP‬‬
‫‪43‬‬
‫‪ .23‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﺻﻮرﺗﻲﻛﻪ ﻛﻠﻴﺪﻫﺎي ‪ 2,50, 45, 70, 75, 22, 40,55, 45‬را ﺑﻪ ﺗﺮﺗﻴﺐ از راﺳﺖ ﺑﻪ ﭼﭗ در ﻳﻚ درﺧﺖ ﺗﻬﻲ ‪ minheap‬درج ﻛﻨﻴﻢ آنﮔﺎه ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫‪ .24‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﺑﺘﺪا ﻛﻠﻴﺪﻫﺎي ‪ 75, 40,55, 45, 42,50, 45, 70‬را ﺑﻪ ﺗﺮﺗﻴﺐ از راﺳﺖ ﺑﻪ ﭼﭗ در ﻳﻚ درﺧﺖ ﺗﻬﻲ ‪ minheap‬درج ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫‪44‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫ﺳﭙﺲ ﺳﻪ ﺑﺎر ﻋﻤﻞ ﺣﺬف را روي رﻳﺸﻪ درﺧﺖ اﻧﺠﺎم ﻣﻲدﻫﻴﻢ‬
‫‪ .25‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻛﺎراﺗﺮﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑﺮاي ﺑﺮرﺳﻲ ‪ heap‬ﺑﻮدن ﻳﻚ درﺧﺖ دودوﻳﻲ آن اﺳﺖ ﻛﻪ ﻫﺮ ﮔﺮه ﻏﻴﺮﺑﺮگ را ﺑـﺎ دو ﻓﺮزﻧـﺪش ﻣﻘﺎﻳـﺴﻪ ﻛﻨـﻴﻢ اﻳـﻦ ﻋﻤﻠﻴـﺎت ﺑـﻪ ﺣـﺪاﻛﺜﺮ‬
‫‪n‬‬
‫‪    2‬ﻣﻘﺎﻳﺴﻪ ﻧﻴﺎز داﺷﺘﻪ و در زﻣﺎن ﺧﻄﻲ ‪ O  n ‬اﻧﺠﺎم ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫‪2‬‬
‫‪‬‬
‫‪ n ‬‬
‫ﻳﺎدآوري‪ :‬زﻳﺮ آراﻳﻪ ‪ A 1, ,   ‬در ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﻫﻤﮕﻲ ﻏﻴﺮﺑﺮگ ﻫﺴﺘﻨﺪ‪.‬‬
‫‪ 2 ‬‬
‫‪‬‬
‫‪ .26‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻛﺎراﺗﺮﻳﻦ ﺳﺎﺧﺘﺎر ﺑﺮاي ادﻏﺎم ﻟﻴﺴﺖﻫﺎي ﻣﺮﺗﺐ اﺳﺘﻔﺎده از درﺧﺖ ‪ minheap‬اﺳﺖ‪ ،‬اﻳﻦ ﻣﻮﺿﻮع ﻳﻜﻲ از ﻛﺎرﺑﺮدﻫﺎي درﺧﺖ ‪ heap‬اﺳﺖ ﻛﻪ در ﻣـﺘﻦ درس ﺑـﻪ‬
‫ﺗﻔﻀﻴﻞ آن را ﺷﺮح دادﻳﻢ‪.‬‬
‫‪ .27‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫در اﻳﻦ ﺳﻮال از آنﺟﺎ ﻛﻪ ﮔﺮه رﻳﺸﻪ ‪  T 1  75 ‬ﺑﺰرگﺗﺮﻳﻦ ﻣﻘﺪار اﺳﺖ ﺑﻨﺎﺑﺮاﻳﻦ درﺧﺖ ﻣﻮردﻧﻈﺮ ‪ maxheap‬ﺑﻮده و ﻣﻘﺪار ﻛﻠﻴﺪ ﻫﺮ ﮔﺮه در آن ﺑﺎﻳﺪ از دو‬
‫ﻓﺮزﻧﺪش ﺑﺰرگﺗﺮ ﻳﺎ ﻣﺴﺎوي ﺑﺎﺷﺪ‪.‬‬
‫در ﺻﻮرﺗﻲﻛﻪ اﻳﻦ وﻳﮋﮔﻲ را ﺑﺮاي ﺧﺎﻧﻪﻫﺎي آراﻳﻪ ﻛﻨﺘﺮل ﻛﻨﻴﻢ ﺧﻮاﻫﻴﻢ دﻳﺪ ﻛﻪ ﻓﻘﻂ ﮔﺰﻳﻨﻪ ‪ 4‬اﻳﻦ ﺷﺮاﻳﻂ را دارد‪.‬‬
‫‪HEAP‬‬
‫]‪T[2i] , T[2i  1‬‬
‫‪10‬‬
‫‪9‬‬
‫‪45‬‬
‫‪‬‬
‫]‪T[i‬‬
‫‪i‬‬
‫]‪T[2] , T[3‬‬
‫‪‬‬
‫]‪T[1‬‬
‫‪1‬‬
‫]‪T[4] , T[5‬‬
‫‪‬‬
‫]‪T[2‬‬
‫‪2‬‬
‫]‪T[6] , T[7‬‬
‫‪‬‬
‫]‪T[3‬‬
‫‪3‬‬
‫]‪T[8] , T[9‬‬
‫‪‬‬
‫]‪T[4‬‬
‫‪4‬‬
‫]‪T[10] , T[11‬‬
‫‪‬‬
‫]‪T[5‬‬
‫‪3‬‬
‫‪8‬‬
‫‪7‬‬
‫‪6‬‬
‫‪28 20 7‬‬
‫‪5‬‬
‫‪17‬‬
‫‪4‬‬
‫‪3‬‬
‫‪30‬‬
‫‪2‬‬
‫‪1‬‬
‫‪75‬‬
‫‪T‬‬
‫‪ : T  2  21 ; T  4  14 ; T 9  0 ; T 10  16‬ﮔﺰﻳﻨﻪ‪4‬‬
‫‪ .28‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﺮ ﻳﻚ از ﻋﻤﻠﻴﺎت ﺣﺬف ‪  D ‬و درج ‪  I ‬ﺑﻪ ﺷﺮح زﻳﺮ در درﺧﺖ ‪ heap‬اﻧﺠﺎم ﻣﻲﭘﺬﻳﺮد‪.‬‬
‫‪ : D‬اﺑﺘﺪا ﻛﻮﭼﻚﺗﺮﻳﻦ ﻛﻠﻴﺪ از رﻳﺸﻪ درﺧﺖ ﺣﺬف ﻣﻲﺷﻮد‪ ،‬ﺳﭙﺲ ﮔﺮه آﺧﺮ ﺟﺎﻳﮕﺰﻳﻦ آن ﻣﻲﺷﻮد در اﻧﺘﻬﺎ روال ‪ heapify‬ﺑﺮاي ﮔﺮه رﻳﺸﻪ ﺑﺎ ﻣﻘﺪار ﺟـﺎﻳﮕﺰﻳﻦ‬
‫ﺷﺪه اﺟﺮا ﻣﻲﺷﻮد‪.‬‬
‫‪ : i  X ‬ﮔﺮه ﺟﺪﻳﺪي ﺑﺎ ﻣﻘﺪار ﻛﻠﻴﺪ ‪ X‬ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ اﺿﺎﻓﻪ ﻣﻲﺷﻮد‪ ،‬ﺳﭙﺲ ﺑﺎ ﻣﻘﺎﻳﺴﻪ و در ﺻﻮرت ﻧﻴﺎز ﺟﺎﺑﺠﺎﻳﻲ ﺑﺎ اﺟﺪادش )از ﭘﺪر ﺗﺎ ﺣـﺪاﻛﺜﺮ رﻳـﺸﻪ(‬
‫در ﻣﻜﺎن ﻣﻨﺎﺳﺒﺶ ﻗﺮار ﻣﻲﮔﻴﺮد‪.‬‬
‫‪46‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ .29‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﺑﺘﺪا ﮔﺮه ﺟﺪﻳﺪ ﺑﺎ ﺷﻤﺎره اﻧﺪﻳﺲ ‪ n‬ﺑﻪ ﻋﻨـﻮان ﺑﺮﮔـﻲ در اﻧﺘﻬـﺎي درﺧـﺖ درج ﻣـﻲﺷـﻮد ﺳـﭙﺲ ﺑـﺮاي ﺣﻔـﻆ وﻳﮋﮔـﻲ ‪ Maxheap‬ﺑﺎﻳـﺪ ﻛﻠﻴـﺪ ﮔـﺮه ﺟﺪﻳـﺪ‬
‫))‪ (temp A(n‬را ﺑﺎﻳﺪ و در ﺻﻮرت ﻧﻴﺎز اﺟﺪادش ﺟﺎﺑﺠﺎ ﻛﻨﻴﻢ ﺗﺎ در ﻣﻜﺎن ﻣﻨﺎﺳﺒﻲ ﻗﺮار ﮔﻴﺮد اﻳﻦ ﻛﺎر ﺗﻮﺳﻂ ﺣﻠﻘﻪ ‪ While‬اﻧﺠﺎم ﻣﻲﮔﻴﺮد‪ .‬در ﺣﻠﻘﻪ ‪ while‬ﺗـﺎ‬
‫زﻣﺎﻧﻲﻛﻪ ﻛﻠﻴﻪ ﮔﺮه ﺟﺪﻳﺪ از اﺟﺪادش ﺑﺰرگﺗﺮ ﺑﺎﺷﺪ ‪  A  i   temp ‬آنﻫﺎ را ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﻣﻨﺘﻘﻞ ﻣﻲﻛﻨﺪ اﻳﻦ ﻋﻤﻠﻴﺎت ﺣـﺪاﻛﺜﺮ ﺗـﺎ رﺳـﻴﺪن ﺑـﻪ رﻳـﺸﻪ‬
‫درﺧﺖ ‪  i  1‬ﻣﻲﺗﻮاﻧﺪ ﺗﻜﺮار ﺷﻮد‪.‬‬
‫ﺑﻌﺪ از اﺗﻤﺎم ﺣﻠﻘﻪ ﻛﻠﻴﺪ ﺟﺪﻳﺪ در ﻣﻜﺎن ﻣﻨﺎﺳﺒﺶ ﻗﺮار ﻣﻲﮔﻴﺮد‪.‬‬
‫‪ .30‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻤﺎنﻃﻮر ﻛﻪ در ﺷﻜﻞ ﻣﻲﺑﻴﻨﻴﻢ ﺑﻌﺪ از درج ﻋﺪد ‪ 95‬ﺑﻪ ﻋﻨﻮان ﮔﺮه آﺧﺮ در اﻧﺘﻬﺎي درﺧﺖ ﺑﺎﻳﺪ آن را در ﻣﺴﻴﺮ اﺟﺪادش اﺑﺘﺪا ﺑﺎ ‪ 74‬و ﺳﭙﺲ ﺑﺎ ‪ 90‬ﺟﺎﺑﺠـﺎ‬
‫ﻛﻨﻴﻢ ﺗﺎ وﻳﮋﮔﻲ ‪ maxheap‬ﺣﻔﻆ ﺷﻮد‪.‬‬
‫‪ .31‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺮاي آﻧﻜﻪ ﺧﺎﻧﻪ ﻫﺎي ﻳﻚ آراﻳﻪ ﻧﺸﺎن دﻫﻨﺪه ﻳﻚ ‪ maxheap‬ﺑﺎﺷﻨﺪ ﺑﺎﻳﺪ وﺿﻌﻴﺖ زﻳﺮ ﺑﺮاي آﻧﻬﺎ ﺑﺮﻗﺮار ﺑﺎﺷﺪ‪:‬‬
‫‪HEAP‬‬
‫‪47‬‬
‫ﺑﺎ ﺑﺮرﺳﻲ ﮔﺰﻳﻨﻪ ﻫﺎ ﻓﻘﻂ در ﮔﺰﻳﻨﻪ ‪ ، 1‬ﻣﻘﺪار ﺧﺎﻧﻪ ﺑﺎ اﻧﺪﻳﺲِ ‪ 2‬ﺷﺮط ﻣﻮرد ﻧﻈﺮ را ﻧﺪارد‬
‫]‪A[2i] , A[2i  1‬‬
‫‪‬‬
‫]‪A[i‬‬
‫‪i‬‬
‫‪10‬‬
‫‪,‬‬
‫‪5‬‬
‫‪‬‬
‫‪20‬‬
‫‪1‬‬
‫‪3‬‬
‫‪,‬‬
‫‪6‬‬
‫‪‬‬
‫‪5‬‬
‫‪‬‬
‫‪ 2‬‬
‫‪1‬‬
‫‪,‬‬
‫‪4‬‬
‫‪‬‬
‫‪10‬‬
‫‪3‬‬
‫‪7‬‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪1‬‬
‫‪4‬‬
‫‪3‬‬
‫‪6‬‬
‫‪10‬‬
‫‪5‬‬
‫‪20‬‬
‫‪ .32‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫!‪6‬‬
‫اﺑﺘﺪا ﺑﻌﺪ از ﻛﻨﺎرﮔﺬاﺷﺘﻦ ﻛﻠﻴﺪ ﻣﻴﻨﻴﻤﻢ )ﻋﺪد ‪ ( 1‬ﺑﺮاي رﻳﺸﺔ درﺧﺖ‪ ، min heap ‬ﺑﻘﻴﻪ ﻛﻠﻴﺪﻫﺎ ) ‪ 2‬ﺗـﺎ ‪ ( 6‬را ﺑـﻪ‬
‫!‪3!3‬‬
‫راﺳﺖ ﺗﻮزﻳﻊ ﻣﻲﻛﻨﻴﻢ ﺳﭙﺲ اﻳﻦ ﻋﻤﻠﻴﺎت را ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﺑﺮاي دو زﻳﺮ درﺧﺖ ﭼﭗ و راﺳﺖ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫زﻳﺮ درﺧﺖ راﺳﺖ‪:‬‬
‫زﻳﺮ درﺧﺖ ﭼﭗ‪:‬‬
‫از ﺳﻪ ﻛﻠﻴﺪ‪ ،‬ﻛﻠﻴﺪ ﻣﻴﻨﻴﻤﻢ را ﺑﺮاي رﻳﺸﻪ ﻛﻨﺎر ﮔﺬاﺷﺘﻪ و دو ﻛﻠﻴـﺪ از ﺳﻪ ﻛﻠﻴﺪ‪ ،‬ﻛﻠﻴﺪ ﻣﻴﻨﻴﻤﻢ را ﺑﺮاي رﻳﺸﻪ ﻛﻨـﺎر ﮔﺬاﺷـﺘﻪ و دو ﻛﻠﻴـﺪ‬
‫!‪2‬‬
‫!‪2‬‬
‫در دو زﻳﺮ درﺧﺖ ﺗﻮزﻳﻊ ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﺑﺎﻗﻴﻤﺎﻧﺪه را ﺑﻪ‬
‫در دو زﻳﺮ درﺧﺖ ﺗﻮزﻳﻊ ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﺑﺎﻗﻴﻤﺎﻧﺪه را ﺑﻪ‬
‫!‪1!1‬‬
‫!‪1!1‬‬
‫ﺣﺎﻟـﺖ در دو زﻳـﺮ درﺧـﺖ ﭼـﭗ و‬
‫‪‬‬
‫‪ 6!   2!   2! ‬‬
‫‪  ‬ﺗﻌﺪاد ﻛﻞ ﺣﺎﻻت‬
‫‪‬‬
‫‪‬‬
‫‪  80‬‬
‫‪ 3!3!   1!1!   1!1! ‬‬
‫‪.33‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫!‪10‬‬
‫اﺑﺘﺪا ﺑﻌﺪ از ﻛﻨﺎرﮔﺬاﺷﺘﻦ ﻛﻠﻴﺪ ﻣﺎﻛﺰﻳﻤﻢ )ﻋﺪد ‪ ( 11‬ﺑﺮاي رﻳﺸﺔ درﺧﺖ‪ ، max heap ‬ﺑﻘﻴﻪ ﻛﻠﻴﺪﻫﺎ ) ‪ 1‬ﺗﺎ ‪ ( 10‬را ﺑﻪ‬
‫!‪7!3‬‬
‫ﺣﺎﻟﺖ در دو زﻳﺮ درﺧـﺖ ﭼـﭗ و‬
‫راﺳﺖ ﺗﻮزﻳﻊ ﻣﻲﻛﻨﻴﻢ ﺳﭙﺲ اﻳﻦ ﻋﻤﻠﻴﺎت را ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﺑﺮاي دو زﻳﺮ درﺧﺖ ﭼﭗ و راﺳﺖ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‬
‫‪‬‬
‫‪ 10!   6!   4!   2!    2! ‬‬
‫‪  ‬ﺗﻌﺪاد درﺧﺖ‬
‫‪  ‬‬
‫‪‬‬
‫‪‬‬
‫‪  ‬‬
‫‪  11520‬‬
‫‪ 7!3!   1!5!   3!1!   1!1!    1!1! ‬‬
‫‪48‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ .34‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻣﺮﺗﺒﻪ زﻣﺎﻧﻲ اﻟﮕﻮرﻳﺘﻢ ﺣﺬف ﻋﻨﺼﺮ دﻟﺨﻮاه ‪ i‬ام ‪ 1  i  n ‬از ﻳﻚ ‪ Max Heap‬ﺑﻪ ﮔﻮﻧﻪاي ﻛﻪ ﺳﺎﺧﺘﺎرِ آﻧﺮا ﺣﻔﻆ ﻛﻨﺪ ﻫﻤﻮاره ﺑﺮاﺑﺮ ﺑﺎ ‪ O  lg n ‬اﺳﺖ‪.‬‬
‫‪ .35‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﻟﮕﻮرﻳﺘﻢ داده ﺷﺪه ﻫﻤﺎن روال ‪ BUILD  MAX  HEAP‬اﺳﺖ ﻛﻪ ﺑﺼﻮرت درﺟﺎ آراﻳﻪ ‪ T 1..n ‬را ﺗﺒﺪﻳﻞ ﺑـﻪ ﻳـﻚ ‪ maxheap‬ﻣـﻲ ﻛﻨـﺪ‪ .‬در اﻳـﻦ‬
‫اﻟﮕﻮرﻳﺘﻢ ‪ ،‬ﺣﻠﻘﻪ ‪ repeat‬ﻋﻤﻠﻴﺎت ﻣﺮﺑﻮط ﺑﻪ ﺗﺎﺑﻊ ‪ max-heapify‬را ﺑﺮاي ﻋﻨﺎﺻﺮِ ﻏﻴﺮ ﺑﺮگ از اﻧﺘﻬﺎ ﺗﺎ اﺑﺘﺪا )ﮔﺮه رﻳﺸﻪ ﺑﺎ اﻧﺪﻳﺲ ‪ (1‬اﻧﺠﺎم ﻣﻲ دﻫـﺪ ‪ .‬اﮔـﺮ ‪t‬‬
‫ﺗﻌﺪاد دﻓﻌﺎت اﺟﺮاي ﺣﻠﻘﻪ ‪ repeat‬ﺑﺎﺷﺪ ‪ ،‬آﻧﮕﺎه ‪ t‬ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺑﻮد ﺑﺎ ﻣﺠﻤﻮع ارﺗﻔﺎع ﻋﻨﺎﺻﺮ ﻏﻴﺮ ﺑﺮگ ﻛـﻪ در ﻃـﻲ اﺟـﺮاي ﺗـﺎﺑﻊ ‪ max-heapify‬ﺑـﺮاي اﻳـﻦ‬
‫ﻋﻨﺎﺻﺮ رخ ﻣﻲ دﻫﺪ‪ .‬از آﻧﺠﺎ ﻛﻪ ﮔﺰﻳﻨﻪ ﻫﺎ ﻛﺮانِ ﺑﺎﻻي ﻣﻘﺪار ‪ t‬را ﻣﻮرد ﺑﺮرﺳﻲ ﻗﺮار داده اﻧﺪ ﺑﻨﺎﺑﺮاﻳﻦ ﺳﻪ ﺷﺮط زﻳﺮ وﺟﻮد ﺧﻮاﻫﺪ داﺷﺖ‪ -1:‬درﺧﺖ ﻣﻮرد ﻧﻈﺮ ﭘﺮ‬
‫اﺳﺖ ‪2‬ـ آراﻳﻪ اوﻟﻴﻪ ‪ minheap‬اﺳﺖ ‪ -3‬ﺗﻜﺮار ﺣﻠﻘﻪ ‪) reapeat‬ﺗﺎﺑﻊ ‪ (max-heapify‬ﺑﺮاي ﻫﺮ ﻋﻨﺼﺮِ ﻏﻴﺮ ﺑﺮگ ﻳﻚ واﺣﺪ ﺑﻴﺸﺘﺮ از ارﺗﻔﺎع ﮔـﺮه ﻋﻨـﺼﺮ ﻣـﻮرد‬
‫ﻧﻈﺮ اﺳﺖ‬
‫ﻳﺎد آوري‪ :‬ﺗﺎﺑﻊ ‪ max-heapify‬در ﺑﻬﺘﺮﻳﻦ ﺣﺎﻟﺖ )آراﻳﻪ اوﻟﻴﻪ ‪ (maxheap‬ﺑﺎ ﻳﻜﺒﺎر اﺟﺮا ﺑﺮاي ﻫﺮ ﮔﺮه ﺑﻪ ﻛﺎر ﺧﻮد ﭘﺎﻳﺎن ﻣﻲ دﻫﺪ اﻣﺎ در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ)آراﻳـﻪ‬
‫اوﻟﻴﻪ‪ (minheap‬ﺑﺎ ﺷﺮوع از ﻫﺮ ﮔﺮه در ﻣﺴﻴﺮ ارﺗﻔﺎعِ ﮔﺮه ﭘﺎﻳﻴﻦ آﻣﺪه و ﺑﺎ رﺳﻴﺪن ﺑﻪ ﻳﻚ ﺑﺮگ ﺑﻪ ﻛﺎر ﺧﻮد ﺧﺎﺗﻤﻪ ﻣﻲ دﻫﺪ‪.‬‬
‫‪‬‬
‫‪begin‬‬
‫‪‬‬
‫‪procedure M T 1..n ‬‬
‫‪n ‬‬
‫‪for i    downto 1 do‬‬
‫‪2‬‬
‫‪R i‬‬
‫‪repeat‬‬
‫‪j R‬‬
‫‪if 2 j  n and T  2 j  T  R  then‬‬
‫‪‬‬
‫‪ BUILD  MAX  HEAP‬‬
‫‪‬‬
‫‪ MAX  HEAPIFY‬‬
‫‪R 2j‬‬
‫‪if 2 j  1  n and T  2 j  1  T  R  then‬‬
‫‪R  2 j 1‬‬
‫‪swap T  j , T  R ‬‬
‫‪until j  R‬‬
‫‪end‬‬
‫ﻧﺘﻴﺠﻪ‪:‬‬
‫ﺑﻄﻮر ﻛﻠﻲ اﮔﺮ ‪ t‬ﺗﻌﺪاد اﺟﺮاي ﺗﺎﺑﻊ ‪ heapify‬ﺑﺮاي ﮔﺮه ﻫﺎي ﻏﻴﺮ ﺑﺮگ ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ ﺑﺎﺷﺪ ‪ ،‬آﻧﮕﺎه ﻣﻘﺪار آن در ﺑﺎزه زﻳﺮ ﻗﺮار ﺧﻮاﻫﺪ داﺷﺖ‪:‬‬
‫‪k k‬‬
‫‪ ...   k  1  2‬‬
‫‪k 2‬‬
‫‪3  2‬‬
‫‪k 1‬‬
‫‪22‬‬
‫‪ t ‬‬
‫‪1  2 k 1  1 2k  2  ...  1 2k  k‬‬
‫‪‬‬
‫‪k  lg n ‬‬
‫‪ .36‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻴﭻ اﻟﮕﻮرﻳﺘﻤﻲ ﻣﺒﺘﻨﻲ ﺑﺮ ﻣﻘﺎﻳﺴﻪ ﻧﻤﻲﺗﻮاﻧﺪ ﻛﻢﺗﺮ از زﻣﺎن ‪ n log n‬ﻳﻚ درﺧﺖ ‪ Heap‬را ﺑﻪ درﺧﺖ ﺟﺴﺘﺠﻮي دودوﻳﻲ ‪  BST ‬ﺗﺒﺪﻳﻞ ﻛﻨﺪ‪ ،‬ﺑﻪ اﻟﮕـﻮرﻳﺘﻢ‬
‫زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ‪:‬‬
‫ورودي‪ :‬آراﻳﻪ دﻟﺨﻮاه‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫÷‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ (1‬ﺳﺎﺧﺘﻦ درﺧﺖ ‪ Heap‬از آراﻳﻪ داده ﺷﺪه ﺑﻪ ﺻﻮرت درﺟﺎ‬
‫‪ (2‬ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ درﺧﺖ ‪BST‬‬
‫‪ (3‬ﭘﻴﻤﺎﻳﺶ ﻣﻴﺎنﺗﺮﺗﻴﺐ ‪  LVR ‬ﺑﺮاي درﺧﺖ ‪BST‬‬
‫‪‬‬
‫ﺧﺮوﺟﻲ‪ :‬آراﻳﻪ ﻣﺮﺗﺐ‬
‫‪On‬‬
‫؟‬
‫‪On‬‬
‫‪HEAP‬‬
‫‪49‬‬
‫اﮔﺮ ﺗﺒﺪﻳﻞ درﺧﺖ ‪ Heap‬ﺑﻪ درﺧﺖ ‪ BST‬ﻛﻢﺗﺮ از زﻣﺎن ‪ n log n‬اﻧﺠﺎم ﺷﻮد‪ .‬آﻧﮕﺎه ﻣﺎ ﺗﻮاﻧﺴﺘﻪاﻳﻢ ﻛﻢﺗﺮ از زﻣـﺎن ‪ n log n‬ﻳـﻚ آراﻳـﻪ دﻟﺨـﻮاه را ﻣﺮﺗـﺐ‬
‫ﻛﻨﻴﻢ در ﺣﺎﻟﻴﻜﻪ ﺣﺪاﻗﻞ زﻣﺎن ﻣﺮﺗﺐﺳﺎزي ﺑﺮاي اﻟﮕﻮرﻳﺘﻢﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ﻣﻘﺎﻳﺴﻪ ﻣﺎﻧﻨﺪ ‪ ... ، merge sort ، Quick sort :‬ﺑﺮاﺑﺮ ﺑﺎ ‪ n log n‬اﺳﺖ‪.‬‬
‫‪ .37‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺎ اﻳﻦ ﭘﻴﺶ ﻓﺮض ﻛﻪ ﺻﻒ اوﻟﻮﻳﺖ ﻣﺎﻛﺰﻳﻤﻢ ﺑﺎ ﻳﻚ ‪ maxheap‬ﭘﻴﺎده ﺳﺎزي ﺷﺪه ﺑﺎﺷﺪ ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ﻋﻤﻠﻴﺎت ﻣﺨﺘﻠﻒ ﺑﻪ ﺷﺮح زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫ ﻋﻤﻠﮕﺮ »ﭘﻴﺪا ﻛﺮدن ﻣﺎﻛﺰﻳﻤﻢ« داراي ﭘﻴﭽﻴﺪﮔﻲ ‪ O 1‬اﺳﺖ‪ .‬ﭼﺮاﻛﻪ ﮔﺮه ﻣﻮرد ﻧﻈﺮ در رﻳﺸﻪ اﺳﺖ‪.‬‬‫ ﻋﻤﻠﮕﺮ »اﺿﺎﻓﻪ ﻛﺮدن« ﻳﻚ ﻗﻠﻢ ﺟﺪﻳﺪ ﺑﻪ ﺻﻒ اوﻟﻮﻳﺖ داراي ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ‪ O  lg n ‬اﺳﺖ‪.‬‬‫ ﻋﻤﻠﮕﺮ »ﺣﺬف« ﻳﻚ ﻗﻠﻢ از ﺻﻒ اوﻟﻮﻳﺖ داراي ﭘﻴﭽﻴﺪﮔﻲ زﻣﺎﻧﻲ ‪ O  lg n ‬اﺳﺖ‪.‬‬‫‪.38‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻳﻚ درﺧﺖ ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﻫﺮ ﻳﻚ از ﻋﻤﻠﻴﺎت زﻳﺮ در زﻣﺎن ‪ O  lg n ‬اﻧﺠﺎم ﻣﻲ ﺷﻮد‪:‬‬
‫ﺣﺬف ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه ‪ ،‬درج ﻳﻚ ﻋﻨﺼﺮ دﻟﺨﻮاه ‪ ،‬ﻛﺎﻫﺶ ﻣﻘﺪار ﻳﻚ ﻋﻨﺼﺮ ‪ ،‬اﻓﺰاﻳﺶ ﻣﻘﺪار ﻳﻚ ﻋﻨﺼﺮ ‪ ،‬ﺗﻐﻴﻴﺮ ﻣﻘﺪار ﻳﻚ ﻋﻨﺼﺮ‬
‫‪ .39‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫روش اول‪:‬‬
‫ﻳﺎ ﻋﻨﺎﺻﺮ را ﻳﻜﻲ ﻳﻜﻲ از ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ ﺧﺎرج ﻛﺮده و در ‪ heap‬ﺑﺎ ‪ m‬ﻋﻨﺼﺮ درج ﻣﻲﻛﻨﻴﻢ ‪ ،‬زﻣﺎن ﻻزم ‪ O  m lg m  m lg n  m lg mn ‬ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫ﻳﺎ ﻋﻨﺎﺻﺮ را ﻳﻜﻲ ﻳﻜﻲ از ‪ heap‬ﺑﺎ ‪ m‬ﻋﻨﺼﺮ ﺧﺎرج ﻛﺮده و در ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ درج ﻣﻲﻛﻨﻴﻢ ‪ ،‬زﻣﺎن ﻻزم ‪ O  n lg n  n lg m  n lg mn ‬ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫روش دوم‪:‬‬
‫‪‬‬
‫‪‬‬
‫ﻋﻨﺎﺻﺮ دو ‪ heap‬را در آراﻳﻪ اي ﺑﻪ ﻃﻮل ‪ m+n‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ و اﻟﮕﻮرﻳﺘﻢ ‪ BUILD-MAX-HEAP‬را ﺑﺮاي آن در زﻣﺎن ‪ O m  n‬اﺟﺮا ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫‪ .40‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :1‬در ﻳﻚ ‪ minheap‬ﻣﺎﻛﺰﻳﻤﻢ اول)ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ( ﺣﺘﻤﺎ در ﻳﻜﻲ از ﺑﺮﮔﻬﺎ اﺳﺖ‬
‫‪ ‬ﮔﺰﻳﻨﻪ ‪ :2‬در ﻳﻚ ‪ minheap‬ﻣﻴﻨﻴﻤﻢ اول ﻫﻤﻮاره در رﻳﺸﻪ ﻗﺮار دارد اﻣﺎ ﻣﻴﻨﻴﻤﻢ ﺳﻮم ﻣﻤﻜﻦ اﺳﺖ ﻓﺮزﻧﺪ ﻣﻴﻨﻴﻤﻢ دوم ﺑﻮده وﻓﺮزﻧﺪ رﻳﺸﻪ ﻧﺒﺎﺷﺪ‪.‬‬
‫‪ ‬ﮔﺰﻳﻨﻪ‪: 3‬درﻳﻚ ‪ minheap‬ﻣﺎﻛﺰﻳﻤﻢ دوم ﻣﻤﻜﻦ اﺳﺖ واﻟﺪ ﻣﺎﻛﺰﻳﻤﻢ اول ﺑﻮد و ﺑﺮگ ﻧﺒﺎﺷﺪ‪.‬‬
‫‪ .41‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫اﮔﺮ ﭼﻪ ﺑﺮاي ادﻏﺎم دو ﻫﻴﭗ ﻛﺎﻓﻲ اﺳﺖ اﻟﮕﻮرﻳﺘﻢ ‪ BUILD-MAX-HEAP‬را در زﻣﺎن ‪ O  n  n   O  n ‬ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﻴﻢ اﻣﺎ از آﻧﺠﺎ ﻛﻪ آراﻳـﻪ ﻧﻬـﺎﻳﻲ‬
‫ﺑﺎﻳﺪ ﻣﺮﺗﺐ ﺑﺎﺷﺪ ﺑﺎﻳﺪ از ﻳﻚ اﻟﮕﻮرﻳﺘﻢ ﻣﺮﺗﺐ ﺳﺎزي ﻣﺎﻧﻨﺪ ‪ heapsort‬در زﻣﺎن ‪ O  n lg n ‬ﺑﺮاي آن اﺳﺘﻔﺎده ﻛﻨﻴﻢ ‪.‬‬
‫‪ .42‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﻫﻨﮕﺎم درج ﻋﻨﺼﺮ ﺟﺪﻳﺪ ﺑﻪ درﺧﺖ ‪ heap‬اﺑﺘﺪا ﮔﺮه ﺟﺪﻳﺪ ﺑﻪ اﻧﺘﻬﺎي درﺧﺖ اﺿﺎﻓﻪ ﺷﺪه ﺳﭙﺲ ﻣﺴﻴﺮ اﺟﺪاد ﺧﻮد ﺑﻄﻮل ‪ O  lg n ‬را ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻣﻜـﺎن‬
‫ﻣﻨﺎﺳﺐ ﺣﺪاﻛﺜﺮ ﺗﺎ رﻳﺸﻪ ﻃﻲ ﻣﻲ ﻛﻨﺪ ‪ ،‬در ﺻﻮرﺗﻴﻜﻪ ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻣﻜﺎن ﻣﻨﺎﺳﺐ ﻋﻨﺼﺮ ﺟﺪﻳﺪ از ﺟﺴﺘﺠﻮي دودوﻳﻲ در ﻣﺴﻴﺮ اﺟﺪاد اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﮔﺮﭼـﻪ‬
‫ﺗﻌﺪاد ﻣﻘﺎﻳﺴﻪ ﻛﻤﺘﺮ ﻣﻲ ﺷﻮد ‪  O  lg lg n  ‬اﻣﺎ از آﻧﺠﺎ ﻛﻪ ﺑﻌﺪ از ﭘﻴﺪا ﻛﺮدن ﻣﻜﺎن ﻣﻨﺎﺳﺐ ﺑﺎﻳﺪ ﺟﺎﺑﺠﺎﻳﻲ ﻻزم ﺗﺎ ﻣﺤﻞ ﻣﻮرد ﻧﻈﺮ )ﺣﺪاﻛﺜﺮ از رﻳﺸﻪ ﺗﺎ آﺧﺮﻳﻦ‬
‫ﺑﺮگ( اﺗﻔﺎق ﺑﻴﺎﻓﺘﺪ زﻣﺎن اﻟﮕﻮرﻳﺘﻢ ﺗﻐﻴﻴﺮي ﻧﻜﺮده و ﻫﻤﺎن ‪ O  lg n ‬ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫‪ .43‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪ n  1  n ‬‬
‫‪ ‬اﺳﺖ‬
‫از آﻧﺠﺎ ﻛﻪ ﻫﺮ درﺧﺖ ‪ heap‬ﺑﺎ ‪ n‬ﮔﺮه ﻳﻚ درﺧﺖ دودوﻳﻲ ﻛﺎﻣﻞ اﺳﺖ ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﺗﻌﺪاد ﺑﺮﮔﻬﺎ در آن ﺑﺮاﺑﺮ ﺑﺎ ‪   ‬‬
‫‪ 2  2‬‬
‫‪ .44‬ﮔﺰﻳﻨﻪ ‪ 2‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﻨﺎﺑﺮ اﻟﮕﻮرﻳﺘﻢ ﺑﺮاي ﺣﺬف ﻳﻚ ﮔﺮه دﻟﺨﻮاه اﺑﺘﺪا ﮔﺮه ﻣﻮرد ﻧﻈﺮ ﺑﺎ واﻟﺪ ﺧﻮدش ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮد در ﺻﻮرﺗﻴﻜﻪ ﻛﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ در ﻣـﺴﻴﺮ اﺟـﺪاد ﺑـﻪ ﺳـﻤﺖ ﺑـﺎﻻو‬
‫درﺻﻮرﺗﻴﻜﻪ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ ﺑﻪ ﻛﻤﻚ اﻟﮕﻮرﻳﺘﻢ ‪ heapify‬در ﻣﺴﻴﺮ ﻓﺮزﻧﺪاﻧﺶ ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد‬
‫از آﻧﺠﺎ ﻛﻪ ﻋﻨﺼﺮ ﺑﺎ اﻧﺪﻳﺲ ‪ 10‬ﺑﻪ رﻳﺸﻪ ﻧﺰدﻳﻚ اﺳﺖ در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﺑﻌﺪ از ﻣﻘﺎﻳﺴﻪ ﺑﺎ واﻟﺪش ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ ﻣﻨﺘﻘﻞ ﺷﺪه و در ﻣﺠﻤﻮع ﺑﺎ ﺣﺪاﻛﺜﺮ ‪ 7‬ﻣﻘﺎﻳﺴﻪ‬
‫ﺑﻪ ﻳﻜﻲ از ﺑﺮﮔﻬﺎ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد ﺷﻜﻞ زﻳﺮ ﻧﺸﺎن دﻫﻨﺪه ﭼﮕﻮﻧﮕﻲ اﻳﻦ وﺿﻌﻴﺖ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪50‬‬
‫ﺳﺎﺧﺘﻤﺎن داده‬
‫‪ .45‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪K‬اُﻣﻴﻦ ﻛﻮﭼﻜﺘﺮ در ﻳﻚ ‪ minheap‬ﻳﺎ ‪k‬اُﻣﻴﻦ ﺑﺰرﮔﺘﺮ در ﻳﻚ ‪ maxheap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ را ﻣـﻲ ﺗـﻮان ﺑـﺼﻮرت ﻛـﺎرا در زﻣـﺎن ‪ O  k lg k ‬ﭘﻴـﺪا ﻛـﺮد ‪).‬ﺑـﺮاي‬
‫ﺗﻮﺿﻴﺤﺎت ﺑﻴﺸﺘﺮ ﺑﻪ ﻣﺘﻦ درس ﻣﺮاﺟﻌﻪ ﺷﻮد(‬
‫‪ .46‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫درﺻﻮرﺗﻴﻜﻪ ﻋﻨﺎﺻﺮ ورودي ﻳﻚ آراﻳﻪ ﺑﺎ ﻛﻠﻴﺪﻫﺎي ﻣﺴﺎوي ﺑﺎﺷﺪ آﻧﮕﺎه ﻫﺮﻳﻚ از ‪ n  1‬ﺑﺎر ﻓﺮﺧﻮاﻧﻲ روال ‪ MAX  HEAPIFY‬ﺑـﺮاي رﻳـﺸﻪ زﻣـﺎﻧﻲ ﺑـﻪ‬
‫ﺟﺎي زﻣﺎن ‪ ، O  lg n ‬زﻣﺎﻧﻲ ﻣﻌﺎدل ﺑﺎ ‪ O 1‬را ﺻﺮف ﻣﻲﻛﻨﺪ زﻳﺮا ﻫﻴﭻ اﻧﺘﻘﺎﻟﻲ ﺑﻪ ﺳﻤﺖ ﭘﺎﻳﻴﻦ اﻧﺠﺎم ﻧﻤﻲ ﺷﻮد و درﻧﻬﺎﻳـﺖ زﻣـﺎن اﺟـﺮاي ﻣﺮﺗـﺐﺳـﺎزي‬
‫ﺑﺼﻮرت زﻳﺮ ﺑﺮاﺑﺮ ﺑﺎ ‪ O  n ‬ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬
‫‪O1‬‬
‫‪O  n    n  1 O  lg n   O  n ‬‬
‫‪ .47‬ﮔﺰﻳﻨﻪ ‪ 3‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﺻﻮرﺗﻴﻜﻪ ﺑﻌﺪ از اﻧﺠﺎم ﻫﻤﻪ ﺗﻐﻴﻴﺮات ‪ ،‬اﻟﮕﻮرﻳﺘﻢ ‪) BUILD-MAX-HEAP‬ﺗﺒﺪﻳﻞ آرﻳﻪ ﺑﻪ ﻫﻴﭗ ﺑﺼﻮرت درﺟﺎ( را ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﻴﻢ ‪ ،‬در زﻣـﺎن )‪ O(n‬ﺗﻤـﺎم‬
‫ﺗﻐﻴﻴﺮات اﻧﺠﺎم ﺷﺪه و درﺧﺖ ﺑﺼﻮرت ﻫﻴﭗ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‬
‫‪ .48‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪k 1‬‬
‫اوﻟﻴﻦ اﻧﺘﻘﺎل ﻫﺰﻳﻨﻪ اي ﻣﻌﺎدل ﺑﺎ‬
‫‪ 2‬را دارد ﺗﺎ اﻧﺘﻘﺎل ‪ i‬اُم ﻛﻪ ﻫﺰﻳﻨﻪ اي ﻣﻌﺎدل ﺑﺎ‬
‫ﻛﻞ ﻫﺰﻳﻨﻪ ﻫﺎي اﻧﺘﻘﺎل ﺑﺮاﺑﺮ ﺧﻮاﻫﺪ ﺑﻮد ﺑﺎ ‪:‬‬
‫‪k i‬‬
‫‪ 2‬را ﺧﻮاﻫﺪ داﺷﺖ و ﻫﻤﻴﻨﻄﻮر ﺗﺎ اﻧﺘﻘﺎل آﺧﺮ ‪ ...‬ﺑﻨـﺎﺑﺮاﻳﻦ ﻣﺠﻤـﻮع‬
‫‪k 1‬‬
‫‪   2 j   20  21  ...  2k 2  2k 1  2k  1    2k     n ‬‬
‫‪j0‬‬
‫‪ .49‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫‪ n‬‬
‫در ﻳﻚ ‪ heap‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ اﮔﺮ اﻟﮕﻮرﻳﺘﻢ ‪ heapify‬ﺑﺮاي ﻋﻨﺼﺮي ﺑﺎ اﻧﺪﻳﺲ ‪ i‬ﻛﻪ در ﻋﻤﻖ ‪ lg i ‬و ارﺗﻔﺎع ‪ lg ‬ﻗﺮار دارد اﺟﺮا ﺷﻮد ‪ ،‬ﺣـﺪاﻛﺜﺮ ﺗﻌـﺪاد‬
‫‪ i‬‬
‫‪ n‬‬
‫ﻣﻘﺎﻳﺴﻪ ﺑﺮاي ﮔﻨﺠﺎﻧﺪن اﻳﻦ ﻋﻨﺼﺮ در ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ زﻣﺎﻧﻴﻜﻪ ﺗﺎ ﭘﺎﻳﻴﻦ ﺗﺮﻳﻦ ﺑﺮگ اداﻣﻪ ﭘﻴﺪا ﻛﻨﺪ ﺣﺪاﻛﺜﺮ ‪ 2 lg ‬ﺧﻮاﻫﺪ ﺑﻮد‪).‬ﻇﺎﻫﺮا ﻣﻨﻈﻮر ﻃﺮاح ﺳـﻮال از‬
‫‪ i‬‬
‫ﻋﻤﻖ ﮔﺮه ﻫﻤﺎن ارﺗﻔﺎع ﮔﺮه ﺑﻮده اﺳﺖ !!(‬
‫‪ .50‬ﮔﺰﻳﻨﻪ ‪ 1‬درﺳﺖ اﺳﺖ‪.‬‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ وﺿﻌﻴﺖ ﮔﺮه ﻫﺎي درﺧﺖ ﺑﻪ ﺻﻮرت زﻳﺮ ﻓﻘﻂ ﮔﺰﻳﻨﻪ ‪ 1‬ﻣﻲ ﺗﻮاﻧﺪ ﺷﺮاﻳﻂ درﺧﺖ ‪ heap‬را ﺑﺮآورده ﻛﻨﺪ‬
‫‪HEAP‬‬
‫‪51‬‬
‫‪ .51‬ﮔﺰﻳﻨﻪ ‪ 4‬درﺳﺖ اﺳﺖ‪.‬‬
‫در ﻫﺮ درﺧﺖ ‪ Minheap‬ﺑﺎ ‪ n‬ﻋﺪد ﻣﺘﻤﺎﻳﺰ ﻫﻤﻮاره ﻣﻲﺗﻮاﻧﻴﻢ ‪ i‬اﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ را از ﺳﻄﺢ دوم ﺗـﺎ ﺳـﻄﺢ ‪ i‬ام در ﺧﺎﻧـﻪﻫـﺎي ‪ 2‬ﺗـﺎ ‪ 2i  1‬ﻗـﺮار‬
‫دﻫﻴﻢ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ‪:‬‬
‫ﭘﻨﺠﻤﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﻨﺼﺮ ﻣﻲﺗﻮاﻧﺪ در ﺧﺎﻧﻪﻫﺎي ‪ 2‬ﺗﺎ ‪ 25  1‬از ﺳﻄﺢ دوم ﺗﺎ ﺳﻄﺢ ﭘﻨﺠﻢ ﻗﺮار ﮔﻴﺮد ﻛﻪ ﺧﺎﻧﻪﻫﺎي ‪ 2‬و ‪ 3‬در ﺳﻄﺢ دوم‪ ،‬ﺧﺎﻧﻪﻫﺎي ‪ 4‬ﺗـﺎ‬
‫‪ 7‬در ﺳﻄﺢ ﺳﻮم ‪ ،‬ﺧﺎﻧﻪ ﻫﺎي ‪ 8‬ﺗﺎ ‪ 15‬در ﺳﻄﺢ ﭼﻬﺎرم و ﺧﺎﻧﻪﻫﺎي ‪ 16‬ﺗﺎ ‪ 31‬در ﺳﻄﺢ ﭘﻨﺠﻢ ﻗﺮار دارد‪ .‬در ﺣﺎﻟﻴﻜﻪ ﺧﺎﻧﻪ ﻫﺎي ‪ 32‬ﺗﺎ ‪ 63‬در ﺳﻄﺢ ﺷـﺸﻢ‬
‫ﻗﺮار دارد ﺑﻨﺎﺑﺮاﻳﻦ ﭘﻨﺠﻤﻴﻦ ﻛﻮﭼﻜﺘﺮﺗﺮﻳﻦ ﻧﻤﻲﺗﻮاﻧﺪ در اﻳﻦ ﺧﺎﻧﻪﻫﺎ ﻗﺮار ﮔﻴﺮد‪.‬‬
‫دﻗﺖ ﻛﻨﻴﺪ ‪ :‬ﻇﺎﻫﺮا ﻃﺮاح ﺳﻮال در ﮔﺰﻳﻨﻪ ‪ 1‬ﻣﺮﺗﻜﺐ اﺷﺘﺒﺎه ﺳﻬﻮي ﺷﺪه اﺳﺖ ﭼﺮاﻛﻪ ﺧﺎﻧﻪ ﺷﻤﺎره ‪ 1‬ﻣﻨﺤﺼﺮا ﻣﺮﺑﻮط ﺑﻪ اوﻟﻴﻦ ﻛﻮﭼﻜﺘﺮ )ﻋﻨﺼﺮ ﻣﻴﻨﻴﻤﻢ( درﺧﺖ‬
‫ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ اﺣﺘﻤﺎﻻ ﻣﻨﻈﻮر ﻃﺮاح ﺳﻮال در اﻳﻦ ﮔﺰﻳﻨﻪ ﺧﺎﻧﻪ ﻫﺎي ‪ 2‬ﺗﺎ ‪ 5‬ﺑﻮده اﺳﺖ‪.‬‬
Download