Heap Data Structure: Study Guide Chapter

‫‪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‬ﺑﻮده اﺳﺖ‪.‬‬

Heap Data Structure: Study Guide Chapter

Products

Support

Heap Data Structure: Study Guide Chapter

Add this document to collection(s)

Add this document to saved

Suggest us how to improve StudyLib