‫ﺳﺎﺧﺘﻤﺎن داده ﻫﺎ و ﻣﺒﺎﻧ اﻟ ﻮرﯾﺘﻢ‬
‫ﻧﯿﻢﺳﺎل دوم ‪٩۵-٩۴‬‬
‫ﻣﺪرس ‪ :‬ﻋﻠ ﺷﺮﯾﻔ زارﭼ‬
‫داﻧﺸ ﺪهی ﻣﻬﻨﺪﺳ ﮐﺎﻣﭙﯿﻮﺗﺮ‬
‫ﭘﺸﺘﻪ و ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی‬
‫ﺗﻤﺮﯾﻦ ﻧﻈﺮی ﭼﻬﺎرم‬
‫ﭘﺎرﺳﻮآ ﺧﻮرﺳﻨﺪ رﺣﯿﻢ زاده‬
‫ﻣﺴﺌﻠﻪی ‪ .١‬ﮐﺎﻣﭙﯿﻮﺗﺮ دو ﭘﺮدازه ای‬
‫ﮐﺎﻣﭙﯿﻮﺗﺮی دارﯾﻢ ﮐﻪ از ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ‪ ( Double DOS ) DDOS‬اﺳﺘﻔﺎده ﻣ ﮐﻨﺪ‪ .‬اﯾﻦ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻧﺴﺨﻪ ﺑﻬﺒﻮد‬
‫ﯾﺎﻓﺘﻪ ‪ DOS‬اﺳﺖ ﮐﻪ ﺗﻮاﻧﺎﯾﯽ اﺟﺮای دو ﭘﺮدازه را ﺑﻪ ﺻﻮرت ﻫﻤﺰﻣﺎن ‪ ١‬دارد‪ DDOS .‬ﺣﺎﻓﻈﻪ ‪ RAM‬را ﺑﻪ دو ﭘﺸﺘﻪ‬
‫ﺗﻘﺴﯿﻢ ﻣ ﮐﻨﺪ ﮐﻪ ﯾ از اﺑﺘﺪای ﺣﺎﻓﻈﻪ و دﯾ ﺮی از اﻧﺘﻬﺎی آن ﺷﺮوع ﻣ ﺷﻮد و ﻫﺮﮐﺪام ﺑﺮای ﻧﮕﻬﺪاری وﺿﻌﯿﺖ ﯾ‬
‫از ﭘﺮدازه ﻫﺎ اﺳﺘﻔﺎده ﻣ ﺷﻮد‪ .‬اﮔﺮ ﺣﺎﻓﻈﻪ ‪ RAM‬را ﯾ آراﯾﻪ ﻓﺮض ﮐﻨﯿﻢ‪ ،‬اﻟ ﻮرﯾﺘﻤ ﺑﺮای ﻣﺪﯾﺮﯾﺖ دو ﭘﺸﺘﻪ ﻓﻮق‬
‫اراﺋﻪ دﻫﯿﺪ ﺑﻪ ﻃﻮرﯾ ﻪ ﻫﯿﭻ ﮐﺪام از ﭘﺸﺘﻪ ﻫﺎ ﺟﺰ در ﺣﺎﻟﺘ ﮐﻪ ﻣﺠﻤﻮﻋﻪ ﺗﻌﺪاد ﻋﻨﺎﺻﺮ آﻧﻬﺎ از ﻇﺮﻓﯿﺖ ﺣﺎﻓﻈﻪ ﺗﺠﺎوز ﮐﻨﺪ‬
‫‪ Overflow‬ﻧﮑﻨﻨﺪ‪.‬‬
‫ﺣﻞ‪ .‬در اﺑﺘﺪا اﻧﺪازه ﯾ از ﭘﺸﺘﻪ ﻫﺎ را ﯾ و اﻧﺪازه دﯾ ﺮی را ‪ n − ١‬ﻓﺮض ﮐﻨﯿﺪ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﯾ اﺷﺎره ﮔﺮ ﮐﻪ ﺑﻪ‬
‫▷‬
‫ﺧﺎﻧﻪ ﺑﺎﻻﯾﯽ ﭘﺸﺘﻪ ﮐﻮﭼ ﺘﺮ اﺷﺎره ﻣ ﮐﻨﺪ و ﺗﻐﯿﯿﺮ ﻣﻘﺪار آن‪ ،‬ﭘﺸﺘﻪ ﮐﻮﭼ ﺘﺮ ﻣ ﺗﻮاﻧﺪ ﺑﺮ ﺣﺴﺐ ﻧﯿﺎز رﺷﺪ ﮐﻨﺪ‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪Queue .٢‬‬
‫‪ Queue‬داده ﺳﺎﺧﺘﺎر ﺳﺎده اﯾﺴﺖ ﮐﻪ اﻋﻤﺎل زﯾﺮ را ﭘﺸﺘﯿﺒﺎﻧ ﻣ ﮐﻨﺪ ‪:‬‬
‫• ‪ : Enqueue‬اﺿﺎﻓﻪ ﮐﺮدن ﯾ‬
‫• ‪ : Dequeue‬ﺣﺬف ﯾ‬
‫ﻋﻨﺼﺮ ﺑﻪ اﺑﺘﺪای ﺻﻒ‬
‫ﻋﻨﺼﺮ از اﻧﺘﻬﺎی ﺻﻒ‬
‫ﺑﺎ اﺳﺘﻔﺎده از داده ﺳﺎﺧﺘﺎر ﭘﺸﺘﻪ ‪ Queue‬را ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﺪ‪ .‬ﺗﻨﻬﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﯿﺎت ﻫﺎی اﺳﺘﺎﻧﺪارد ‪Pop ، Push‬‬
‫و ‪ isEmpty‬در ﭘﺸﺘﻪ اﻣ ﺎن ﭘﺬﯾﺮ اﺳﺖ‪.‬‬
‫ﺣﻞ‪ .‬اﯾﻦ ﭘﯿﺎده ﺳﺎزی ﺑﻪ ﮐﻤ دو ﭘﺸﺘﻪ اﻣ ﺎن ﭘﺬﯾﺮ اﺳﺖ‪ .‬ﻓﺮض ﮐﻨﯿﻢ ﺑﺎﻻی ﭘﺸﺘﻪ ﻫﻤﺎن اﺑﺘﺪای ﺻﻒ و اﻧﺘﻬﺎی ﭘﺸﺘﻪ‬
‫ﻧﯿﺰ اﻧﺘﻬﺎی ﺻﻒ ﺑﺎﺷﺪ‪ .‬ﻋﻤﻠﯿﺎت ‪ Enqueue‬ﻣﻌﺎدل ﻫﻤﺎن ‪ Push‬ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺑﺮای ‪ Dequeue‬ﺑﺎﯾﺪ ﺗﻤﺎم ﻋﻨﺎﺻﺮ ﭘﺸﺘﻪ‬
‫اﺻﻠ را ‪ Pop‬ﮐﺮد و در ﭘﺸﺘﻪ ﺛﺎﻧﻮﯾﻪ ‪ Push‬ﮐﺮد‪ .‬ﺳﭙﺲ اوﻟﯿﻦ ﻋﻨﺼﺮ ﭘﺸﺘﻪ ﺛﺎﻧﻮﯾﻪ ﮐﻪ ﻫﻤﺎن آﺧﺮﯾﻦ ﻋﻨﺼﺮ ﭘﺸﺘﻪ اﺻﻠ‬
‫▷‬
‫اﺳﺖ را ‪ Pop‬ﻣ ﮐﻨﯿﻢ و ﺑﺎﻗ ﻋﻨﺎﺻﺮ را ﺑﻪ ﭘﺸﺘﻪ اﺻﻠ ‪ Push‬ﻣ ﮐﻨﯿﻢ‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪ .٣‬ﭘﺸﺘﻪ ﭘﯿﺸﺮﻓﺘﻪ‬
‫داده ﺳﺎﺧﺘﺎر ﭘﺸﺘﻪ را ﺑﻪ ﺷ ﻠ ﮔﺴﺘﺮش دﻫﯿﺪ ﮐﻪ اﻣ ﺎن ﺑﺮﮔﺮداﻧﺪن ﻋﻨﺼﺮ ﮐﻤﯿﻨﻪ را در زﻣﺎن )‪ O(1‬داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻋﻤﻠﯿﺎت‬
‫ﻫﺎی اﺳﺘﺎﻧﺪارد ‪ Push‬و ‪ Pop‬ﺑﺎﯾﺪ ﻫﻤﭽﻨﺎن در زﻣﺎن )‪ O(1‬ﻗﺎﺑﻞ اﻧﺠﺎم ﺑﺎﺷﻨﺪ‪.‬‬
‫ﺣﻞ‪ .‬ﻫﺮ ﻋﻨﺼﺮ ﭘﺸﺘﻪ ﻣ ﺗﻮاﻧﺪ ﻣﻘﺪار ﮐﻤﯿﻨﻪ در ﻋﻨﺎﺻﺮ زﯾﺮﯾﻦ ﺧﻮد را ﻧﮕﺎه دارد‪ .‬ﺑﻪ اﺳﺘﻘﺮا ﻋﻨﺼﺮ ﺑﺎﻻﯾﯽ ﭘﺸﺘﻪ ﮐﻤﯿﻨﻪ‬
‫ﺗﻤﺎم ﻋﻨﺎﺻﺮ را ﻣ داﻧﺪ‪ .‬اﯾﻦ ﻣﻘﺪار را ﻣ ﺗﻮان ﻫﻨﮕﺎم ‪ Push‬ﺑﺮای ﻫﺮ ﻋﻨﺼﺮ ﻣﺤﺎﺳﺒﻪ ﮐﺮد ﮐﻪ ﺑﺮاﺑﺮ ﮐﻤﯿﻨﻪ ﻣﻘﺪار ﺧﻮد‬
‫▷‬
‫آن ﻋﻨﺼﺮ و ﻣﻘﺪار ﮐﻤﯿﻨﻪ ﻋﻨﺎﺻﺮ زﯾﺮﯾﻦ ﺑﺮای ‪ Head‬ﻗﺒﻠ ﭘﺸﺘﻪ اﺳﺖ‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪ .۴‬ادﻏﺎم ﭘﺸﺘﻪ و ﺻﻒ‬
‫‪Concurrent١‬‬
‫‪١‬‬
‫ﺑﺎ ادﻏﺎم داده ﺳﺎﺧﺘﺎر ﻫﺎی ‪ Stack‬و ‪ Queue‬داده ﺳﺎﺧﺘﺎر ﻣﺠﺎزی ‪ Leverage‬را ﺳﺎﺧﺘﻪ اﯾﻢ‪ .‬اﯾﻦ داده ﺳﺎﺧﺘﺎر اﻋﻤﺎل‬
‫زﯾﺮ را ﭘﺸﺘﯿﺒﺎﻧ ﻣ ﮐﻨﺪ ‪:‬‬
‫• ‪ : Pop‬ﺣﺬف ﯾ‬
‫ﻋﻨﺼﺮ از اﺑﺘﺪای ﺳﻤﺖ راﺳﺖ ﻟﯿﺴﺖ‬
‫• ‪ : Enqueue‬اﺿﺎﻓﻪ ﮐﺮدن ﯾ‬
‫• ‪ : Dequeue‬ﺣﺬف ﯾ‬
‫ﻋﻨﺼﺮ ﺑﻪ اﺑﺘﺪای ﺳﻤﺖ ﺳﻤﺖ راﺳﺖ ﻟﯿﺴﺖ‬
‫ﻋﻨﺼﺮ از اﻧﺘﻬﺎی ﭼﭗ ﻟﯿﺴﺖ‬
‫ﺑﺎ اﺳﺘﻔﺎده از ‪ ٣‬ﭘﺸﺘﻪ و )‪ O(1‬ﺣﺎﻓﻈﻪ اﺿﺎﻓ داده ﺳﺎﺧﺘﺎر ﻓﻮق را ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﺪ ﺑﻪ ﻃﻮری ﮐﻪ اﻋﻤﺎل ﻓﻮق در زﻣﺎن‬
‫ﺳﺮﺷ ﻦ )‪ O(1‬ﻗﺎﺑﻞ اﻧﺠﺎم ﺑﺎﺷﻨﺪ‪ .‬ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ ﺗﻨﻬﺎ اﻋﻤﺎل ﻣﺠﺎز روی ﭘﺸﺘﻪ ﻫﺎ ﻫﻤﺎن ‪ Push‬و ‪ Pop‬ﻋﺎدی ﻫﺴﺘﻨﺪ‪.‬‬
‫ﺣﻞ‪ .‬ﺳﻮال ﺳﺨﺘ اﺳﺖ ‪(:‬‬
‫ﺑﺮای اﯾﻦ داده ﺳﺎﺧﺘﺎر از ﭘﺸﺘﻪ ای از ﭘﺸﺘﻪ ﻫﺎی اﺳﺘﻔﺎده ﻣ ﮐﻨﯿﻢ‪ .‬در ﺣﻘﯿﻘﺖ ‪ ٣‬اﺷﺎره ﮔﺮ دارﯾﻢ ﮐﻪ ﻫﺮ ﮐﺪام ﺑﻪ ﯾ‬
‫داده ﺳﺎﺧﺘﺎر ﭘﺸﺘﻪ اﺷﺎره ﻣ ﮐﻨﻨﺪ‪ .‬اﺷﺎره ﮔﺮ ‪ Stack١‬ﭘﺸﺘﻪ اﺻﻠ اﺳﺖ‪ Stack٢ .‬آﺧﺮﯾﻦ ﻋﻨﺼﺮ ﭘﺸﺘﻪ اﺻﻠ اﺳﺖ ﮐﻪ‬
‫ﺧﻮد ﯾ ﭘﺸﺘﻪ ﺗﮏ ﻋﻨﺼﺮی اﺳﺖ‪ .‬ﻧﻬﺎﯾﺘﺎ ‪ Stack٣‬ﻫﻢ ﻋﻨﺼﺮ ﺑﺎﻻﯾﯽ ‪ Stack٢‬اﺳﺖ ﮐﻪ ﺧﻮد ﭘﺸﺘﻪ ای از ﭘﺸﺘﻪ ﻫﺎی ﺑﺎ‬
‫ﺳﺎﺧﺘﺎر ﻣﺸﺎﺑﻪ ‪Stack١‬‬
‫اﺳﺖ‪ .‬ﭘﺲ ﯾ‬
‫داده ﺳﺎﺧﺘﺎر ﺑﺎزﮔﺸ دارﯾﻢ‪ .‬ﺷﻤﺎی ﮐﻠ ﺑﻪ اﯾﻦ ﺗﺮﺗﯿﺐ اﺳﺖ‪:‬‬
‫ﺣﺎل ﻋﻤﻠﯿﺎت ﻫﺎی ﺧﻮاﺳﺖ ﺷﺪه ﺑﻪ ﺷ ﻞ زﯾﺮ ﻗﺎﺑﻞ ﭘﯿﺎده ﺳﺎزی ﻫﺴﺘﻨﺪ‪.‬‬
‫اﺑﺘﺪا آﻣﺎده ﺳﺎزی اوﻟﯿﻪ داده ﺳﺎﺧﺘﺎر‪:‬‬
‫‪begin‬‬
‫; )>‪Leverage.new() : Stack1 = Stack.new(<Stack‬‬
‫; ‪Stack2 = Stack1‬‬
‫‪end‬‬
‫ﺣﺎل ﻋﻤﻠﯿﺎت ‪ Enqueue‬ﺑﻪ ﺷ ﻞ زﯾﺮ ﻗﺎﺑﻞ ﭘﯿﺎده ﺳﺎزی اﺳﺖ‪.‬‬
‫ﺗﮑﻪ ﮐﺪ زﯾﺮ ﻋﻨﺼﺮ ﺧﻮاﺳﺘﻪ ﺷﺪه را در ‪ Stack٢‬درج ﻣ ﮐﻨﺪ‪ ،‬ﺳﭙﺲ ﭘﺸﺘﻪ ﺟﺪﯾﺪی روی آن ‪ Push‬ﻣ ﮐﻨﺪ و اﺷﺎره ﮔﺮ‬
‫‪ Stack٢‬را ﺑﻪ اﯾﻦ ﭘﺸﺘﻪ ﺗﻐﯿﯿﺮ ﻣ دﻫﺪ‪.‬‬
‫‪٢‬‬
‫‪begin‬‬
‫; )>‪enqueue(element): Stack3 = Stack.new(<Type of element‬‬
‫; )‪Stack3.push(element‬‬
‫; )‪Stack2.push(Stack3‬‬
‫; )>‪Stack3 = Stack.new(<Stack‬‬
‫; )‪Stack2.push(Stack3‬‬
‫; ‪Stack2 = Stack3‬‬
‫‪end‬‬
‫‪begin‬‬
‫; )(‪dequeue(): Stack3 = Stack1.pop‬‬
‫; )(‪Stack1 = Stack1.pop‬‬
‫; )(‪dequeue() = Stack1.pop‬‬
‫; ‪Stack1 = Stack3‬‬
‫‪end‬‬
‫ﺑﺮای ‪ Dequeue‬ﺑﻪ اﯾﻦ ﺗﺮﺗﯿﺐ ﻋﻤﻞ ﻣ ﮐﻨﯿﻢ‪:‬‬
‫اﯾﻦ روﯾﻪ اﺑﺘﺪا داﺧﻠ ﺗﺮﯾﻦ ﭘﺸﺘﻪ در ‪ Stack١‬را ‪ Pop‬ﻣ ﮐﻨﺪ‪ ،‬ﺣﺎل در ‪ Stack١‬ﺗﻨﻬﺎ ﻫﻤﺎن آﺧﺮﯾﻦ ﻋﻨﺼﺮ ﺻﻒ ﺑﺎﻗ‬
‫ﻣﺎﻧﺪه اﺳﺖ ﮐﻪ آن را ‪ Pop‬ﻣ ﮐﻨﯿﻢ و اﺷﺎره ﮔﺮ ‪ Stack١‬را ﺑﻪ ﭘﺸﺘﻪ ‪ Pop‬ﺷﺪه ﺑﺮ ﻣ ﮔﺮداﻧﯿﻢ ﮐﻪ از اﯾﻦ ﭘﺲ ﭘﺸﺘﻪ‬
‫اﺻﻠ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫در ﺗﻤﺎم ﻋﻤﻠﯿﺎت ﻫﺎ‪ ،‬اﺷﺎره ﮔﺮ ‪ Stack١‬ﺑﻪ ﺧﺎرﺟ ﺗﺮﯾﻦ ﭘﺸﺘﻪ اﺷﺎره ﻣ ﮐﻨﺪ‪.‬‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻮﺿﯿﺤﺎت ﻓﻮق ‪ Pop‬را )ﻣﻄﺎﺑﻖ ﺑﺎ ﺻﻮرت ﺗﻤﺮﯾﻦ( ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﺪ‪.‬‬
‫▷‬
‫ﻣﺴﺌﻠﻪی ‪ .۵‬ﻣﺎﺷﯿﻦ ﺟﺎﯾ ﺸﺖ ﺳﺎز‬
‫ﺑﺮای ﺗﻮﻟﯿﺪ ﺟﺎﯾ ﺸﺖ ﻫﺎی ﻣﺠﻤﻮﻋﻪ ای از ﮐﺎراﮐﺘﺮﻫﺎ از ﻣﺎﺷﯿﻦ ﺳﺎﺧﺘﮕ ‪ Artemis‬اﺳﺘﻔﺎده ﻣ ﮐﻨﯿﻢ ﮐﻪ ﺑﻪ ﺷ ﻞ زﯾﺮ‬
‫ﻋﻤﻞ ﻣ ﮐﻨﺪ‪:‬‬
‫اﯾﻦ ﻣﺎﺷﯿﻦ ﯾ رﯾﻞ ورودی‪ ،‬ﯾ رﯾﻞ ﺧﺮوﺟ و ﯾ رﯾﻞ اﺿﺎﻓ ﺑﺮای ذﺧﯿﺮه ﻣﯿﺎﻧ ﮐﺎراﮐﺘﺮﻫﺎ دارد‪ .‬ﮐﺎراﮐﺘﺮی ﮐﻪ از‬
‫ﺳﻤﺖ ﭼﭗ وارد ﻣﺎﺷﯿﻦ ﻣ ﺷﻮد ﻣ ﺗﻮاﻧﺪ ﻣﺴﺘﻘﯿﻢ از ﺳﻤﺖ راﺳﺖ ﺧﺎرج ﺷﻮد و ﯾﺎ وارد رﯾﻞ ﻣﯿﺎﻧ ﺷﻮد‪ .‬رﯾﻞ ﻣﯿﺎﻧ‬
‫ﻣﺎﻧﻨﺪ ﯾ ﭘﺸﺘﻪ ﻋﻤﻞ ﻣ ﮐﻨﺪ ﺑﻨﺎﺑﺮاﯾﻦ ﺗﻨﻬﺎ ﻋﻨﺼﺮ ﺑﺎﻻﯾﯽ آن ﻣ ﺗﻮاﻧﺪ ﺧﺎرج ﺷﻮد‪ Artemis .‬ﻣﺠﻤﻮﻋﻪ ای از ﮐﺎراﮐﺘﺮﻫﺎ‬
‫را ﺑﻪ ﻋﻨﻮان ورودی درﯾﺎﻓﺖ ﻣ ﮐﻨﺪ و ﺟﺎﯾ ﺸﺘ از آﻧﻬﺎ را ﺧﺮوﺟ ﻣ دﻫﺪ‪ .‬ﺗﻤﺎم ﮐﺎراﮐﺘﺮﻫﺎی ورودی در ﺟﺎﯾ ﺸﺖ‬
‫ﺧﺮوﺟ اﺳﺘﻔﺎده ﻣ ﺷﻮﻧﺪ و ﭘﺸﺘﻪ ﻣﯿﺎﻧ در ﻧﻬﺎﯾﺖ ﺧﺎﻟ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫دﻗﺖ ﮐﻨﯿﻢ ﮐﻪ ﻣﺎﺷﯿﻦ ﺗﻮﺻﯿﻒ ﺷﺪه ﻧﻤ ﺗﻮاﻧﺪ ﺗﻤﺎم ﺟﺎﯾ ﺸﺖ ﻫﺎی ﻣﻤ ﻦ را ﺗﻮﻟﯿﺪ ﮐﻨﺪ‪ .‬ﺑﺮای ﻣﺜﺎل اﮔﺮ ﮐﺎراﮐﺘﺮ ﻫﺎی‬
‫ورودی ‪) 8, 7, 6, 5, 4, 3, 2, 1‬ﮐﺎراﮐﺘﺮ ﻫﺎ از راﺳﺖ ﺑﻪ ﭼﭗ وارد ﻣﺎﺷﯿﻦ ﻣ ﺷﻮﻧﺪ( ﺑﺎﺷﺪ رﺷﺘﻪ ‪1, 5, 2, 6, 8, 7, 3, 4‬‬
‫)ﮐﺎراﮐﺘﺮ از ﭼﭗ ﺑﻪ راﺳﺖ از ﻣﺎﺷﯿﻦ ﺧﺎرج ﺷﺪه اﻧﺪ( ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟ ﻗﺎﺑﻞ ﺗﻮﻟﯿﺪ ﻧﯿﺴﺖ‪.‬‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺳﺎﺧﺘﺎر ﻓﻮق ﺑﻪ ﺳﻮاﻻت زﯾﺮ ﭘﺎﺳﺦ دﻫﯿﺪ ‪:‬‬
‫‪ .١‬ﺗﻌﺪاد ﺟﺎﯾ ﺸﺖ ﻫﺎی ﻗﺎﺑﻞ ﺗﻮﻟﯿﺪ ﺑﺎ ﻣﺎﺷﯿﻦ ‪ Artemis‬ﺑﺮای ‪ n‬ﮐﺎراﮐﺘﺮ ورودی ﭼﻨﺪﺗﺎ اﺳﺖ ؟ ﻓﺮض ﮐﻨﯿﺪ ﮐﻪ‬
‫ﮐﺎراﮐﺘﺮﻫﺎی ورودی ﻫﻤﻪ ﻣﺘﻤﺎﯾﺰ ﻫﺴﺘﻨﺪ‪ .‬ﺑﺮای ﺳﺎدﮔ ﮐﺎر ﺳﻌ ﮐﻨﯿﺪ ﺑﺎ ﺗﺸ ﯿﻞ ﯾ راﺑﻄﻪ ﺑﺎزﮔﺸﺘ و ﺣﻞ آن‬
‫ﺗﻌﺪاد ﺧﺮوﺟ ﻫﺎ را ﻣﺤﺎﺳﺒﻪ ﮐﻨﯿﺪ‪.‬‬
‫‪ .٢‬ﺷﺮط ﻻزم و ﮐﺎﻓ ﺑﺮای اﯾﻨﮑﻪ ﯾ‬
‫دﻧﺒﺎﻟﻪ ﻗﺎﺑﻞ ﺗﻮﻟﯿﺪ ﺑﺎﺷﺪ ﭼﯿﺴﺖ ؟‬
‫‪ .٣‬اﻟ ﻮرﯾﺘﻤ از )‪ O(n‬اراﺋﻪ دﻫﯿﺪ ﮐﻪ ﺑﺎ درﯾﺎﻓﺖ ﯾ‬
‫رﺷﺘﻪ ورودی ﻗﺎﺑﻞ ﺗﻮﻟﯿﺪ ﺑﻮدن آن را ﺑﺮرﺳ ﮐﻨﺪ‪.‬‬
‫‪٣‬‬
‫ﺣﻞ‪ .‬ﺗﻌﺪاد اﯾﻦ ﺟﺎﯾ ﺸﺖ ﻫﺎ ﻋﺪد ﮐﺎﺗﺎﻻن ‪ n‬ام اﺳﺖ‪:‬‬
‫∑‬
‫‪Cn = ni=٠ Ci × Cn−i‬‬
‫ﺳﻌ ﮐﻨﯿﺪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻤﺎﯾﺶ ﻓﻮق ﺑﺮای اﯾﻦ اﻋﺪاد‪ ،‬اﯾﻦ ﺧﺎﺻﯿﺖ را اﺛﺒﺎت ﮐﻨﯿﺪ‪.‬‬
‫در ﺣﺎﻟﺖ ﮐﻠ دﻧﺒﺎﻟﻪ ﻫﺎﯾﯽ ﻗﺎﺑﻞ ﺗﻮﻟﯿﺪ ﻫﺴﺘﻨﺪ ﮐﻪ دارای اﻟ ﻮی ‪ ٢١٣‬ﻧﺒﺎﺷﻨﺪ‪) .‬ﺗﺮﺗﯿﺐ ورودی ﻫﺎ را ‪ ٣٢١‬ﺑ ﯿﺮﯾﺪ(‬
‫▷‬
‫ﻣﺴﺌﻠﻪی ‪ .۶‬ﺗﻮﻗﻒ ﻧﺎﭘﺬﯾﺮ‬
‫ﺑﺮای آﻧﮑﻪ ﺛﺎﺑﺖ ﮐﻨﯿﻢ ﻫﯿﭻ ﭼﯿﺰ ﺟﻠﻮدار ﻣﺎ ﻧﯿﺴﺖ داده ﺳﺎﺧﺘﺎر ‪ Crater‬را ﺑﻪ ﺷ ﻞ زﯾﺮ ﺗﻌﺮﯾﻒ ﻣ ﮐﻨﯿﻢ ‪:‬‬
‫ﯾ ‪ Crater‬ﻣﺘﺸ ﻞ از ﺗﻌﺪاد ﻧﺎﻣﺘﻨﺎﻫ ﭘﺸﺘﻪ ‪ S0 , S1 , S2 ...‬اﺳﺖ ﮐﻪ ﭘﺸﺘﻪ ‪ i‬ام ﺗﻮاﻧﺎﯾﯽ ذﺧﯿﺮه ﺣﺪاﮐﺜﺮ ‪ 3i‬ﻋﻨﺼﺮ را‬
‫دارد‪ Push .‬و ‪ Pop‬ﻫﻤﻮاره از ﮐﻮﭼ ﺗﺮﯾﻦ ﭘﺸﺘﻪ ﯾﻌﻨ ‪ S0‬اﻧﺠﺎم ﻣ ﺷﻮد‪ .‬ﻗﺒﻞ از آﻧﮑﻪ ﻋﻨﺼﺮ ﺟﺪﯾﺪی ﺑﻪ ﭘﺸﺘﻪ ﭘﺮ‬
‫‪ Si‬وارد ﺷﻮد ﺑﺎﯾﺪ ﺗﻤﺎم ﻋﻨﺎﺻﺮ ‪ Si‬را ‪ Pop‬ﮐﻨﯿﻢ و ﺑﻪ ﭘﺸﺘﻪ ‪ Push Si+1‬ﮐﻨﯿﻢ )اﮔﺮ ‪ Si+1‬ﻫﻢ ﭘﺮ ﺑﺎﺷﺪ اﯾﻦ ﮐﺎر ﺑﻪ ﻃﻮر‬
‫ﺑﺎزﮔﺸﺘ اداﻣﻪ ﭘﯿﺪا ﻣ ﮐﻨﺪ ﺗﺎ ﺑﻪ ﯾ ﭘﺸﺘﻪ ﺧﺎﻟ ﺑﺮﺳﯿﻢ(‪ .‬ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﻗﺒﻞ از آﻧﮑﻪ ﯾ ﻋﻨﺼﺮ ﺑﺘﻮاﻧﺪ از ﭘﺸﺘﻪ ﺧﺎﻟ ‪Si‬‬
‫‪ Pop‬ﺷﻮد ﺑﺎﯾﺪ اﺑﺘﺪا ‪ 3i‬ﻋﻨﺼﺮ از ﭘﺸﺘﻪ ‪ Pop Si+1‬ﮐﻨﯿﻢ و آﻧﻬﺎ را در ‪ Push Si‬ﮐﻨﯿﻢ )اﮔﺮ ‪ Si+1‬ﺧﺎﻟ ﺑﺎﺷﺪ اﺑﺘﺪا ﺑﺎﯾﺪ‬
‫آن را ﺑﺎ ‪ si+1‬ﻋﻨﺼﺮ از ‪ Si+2‬ﭘﺮ ﮐﻨﯿﻢ(‪.‬‬
‫ﺣﺎل ﺑﻪ ﺳﻮاﻻت زﯾﺮ در ﻣﻮرد داده ﺳﺎﺧﺘﺎر ‪ Crater‬ﭘﺎﺳﺦ دﻫﯿﺪ ‪:‬‬
‫• زﻣﺎن ﻣﻮرد ﻧﯿﺎز ﺑﺮای ‪ Push‬ﮐﺮدن ﯾ‬
‫ﮐﻨﯿﺪ‪.‬‬
‫ﻋﻨﺼﺮ ﺟﺪﯾﺪ ﺑﻪ ﯾ‬
‫‪ Crater‬ﺑﺎ ‪ n‬ﻋﻨﺼﺮ را در ﺑﺪﺗﺮﯾﻦ ﺣﺎﻟﺖ ﻣﺤﺎﺳﺒﻪ‬
‫• ﻧﺸﺎن دﻫﯿﺪ ﮐﻪ اﮔﺮ ﻫﯿﭻ ﮔﺎه ﻋﻤﻞ ‪ Pop‬اﻧﺠﺎم ﻧﺸﻮد ﻫﺰﯾﻨﻪ ﺳﺮﺷ ﻦ ‪ Push‬ﮐﺮدن ﯾ‬
‫ﺣﺎوی ‪ n‬ﻋﻨﺼﺮ از )‪ O(log n‬اﺳﺖ‪.‬‬
‫ﻋﻨﺼﺮ ﺟﺪﯾﺪ ﺑﻪ ‪Crater‬‬
‫• ﻧﺸﺎن دﻫﯿﺪ ﮐﻪ ﺑﺮای ﻫﺮ ﺗﺮﮐﯿﺒﯽ از اﻋﻤﺎل ‪ Push‬و ‪ Pop‬زﻣﺎن ﺳﺮﺷ ﻦ ﻫﺮ ﻋﻤﻠﯿﺎت از )‪ O(log n‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﺣﻞ‪ .‬ﺑﺪﺗﺮﯾﻦ ﺣﺎﻟﺖ زﻣﺎﻧ اﺳﺖ ﮐﻪ ﺗﻤﺎم ﭘﺸﺘﻪ ﻫﺎی ﻣﻮﺟﻮد ﭘﺮ ﺑﺎﺷﻨﺪ و ﺑﺮای ﺟﺎ ﺑﺎز ﮐﺮدن ﻧﯿﺎز ﺑﺎﺷﺪ ﺗﻤﺎم ﭘﺸﺘﻪ ﻫﺎ ﺑﻪ‬
‫ﭘﺸﺘﻪ ﺑﻌﺪی ﻣﻨﺘﻘﻞ ﺷﻮﻧﺪ‪ .‬ﮐﻪ از )‪ O(n‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﻓﺮض ﮐﻨﯿﻢ داده ﺳﺎﺧﺘﺎر ﻣﺎ در اﺑﺘﺪا ﺧﺎﻟ ﺑﺎﺷﺪ‪ .‬ﺳﭙﺲ ‪ n‬ﻋﻨﺼﺮ ﺑﻪ ﺗﺮﺗﯿﺐ در آن ‪ push‬ﻣ ﮐﻨﯿﻢ‪ .‬ﻣﺸﺎﻫﺪه ﻣ ﺷﻮد ﮐﻪ‬
‫ﺗﻌﺪاد ﭘﺸﺘﻪ ﻫﺎ ﺣﺪاﮐﺜﺮ ‪ log٣ n‬اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ ﺣﺪاﮐﺜﺮ ‪ log٣ n‬ﺑﺎر ﺗﻤﺎم ﭘﺸﺘﻪ ﻫﺎ ﭘﺮ ﺑﻮده اﻧﺪ و ﻧﯿﺎز ﺑﻪ ﺣﺮﮐﺖ دادن ﺗﻤﺎم‬
‫ﻋﻨﺎﺻﺮ ﺑﻮده اﺳﺖ‪ .‬ﻣ ﺗﻮان ﻧﺸﺎن داد ﻫﺰﯾﻨﻪ ﺳﺮﺷ ﻦ ﺑﺮای ﺳﺎﯾﺮ ﻣﻮارد ﻣﻘﺪاری ﺛﺎﺑﺖ اﺳﺖ‪ .‬ﺑﻪ اﯾﻦ ﻣﻨﻈﻮر ‪ n‬را ﻣﻘﺪاری‬
‫▷‬
‫ﺑﻪ ﺷ ﻞ ‪ ٣٠ + ٣١ + ... + ٣k‬ﺑ ﯿﺮﯾﺪ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ ﻫﺰﯾﻨﻪ ﺳﺮﺷ ﻦ ﮐﻠ ﻟ ﺎرﯾﺘﻤ ﻣ ﺷﻮد‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪ .٧‬ﻟﯿﺴﺖ دور دار‬
‫اﮔﺮ در ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی ﻟﻮپ اﯾﺠﺎد ﺷﻮد ﺑﻪ ﺳﺎﺧﺘﺎر ﺣﺎﺻﻞ ‪ Circular Linked List‬اﺗﻼق ﻣ ﺷﻮد‪ .‬ﻟﻮپ زﻣﺎﻧ‬
‫اﯾﺠﺎد ﻣ ﺷﻮد ﮐﻪ اﺷﺎره ﮔﺮ ‪ next‬ﯾ ﻋﻨﺼﺮ ﺑﻪ ﻋﻨﺼﺮی ﮐﻪ ﻗﺒﻼ در ﻟﯿﺴﺖ آﻣﺪه اﺳﺖ اﺷﺎره ﮐﻨﺪ‪ .‬اﻟ ﻮرﯾﺘﻤ ﺑﺎ زﻣﺎن‬
‫اﺟﺮای )‪ O(n‬اراﺋﻪ دﻫﯿﺪ ﮐﻪ وﺟﻮد ﻟﻮپ را در ﯾ ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی ﺗﺸﺨﯿﺺ دﻫﺪ‪.‬‬
‫ﺣﻞ‪ .‬اﯾﻦ ﺳﻮال ﺑﺎ اﺳﺘﻔﺎده از ‪ Hash‬در زﻣﺎن ﺧﻄ ﻗﺎﺑﻞ ﺣﻞ اﺳﺖ‪ .‬ﮐﺎﻓ اﺳﺖ ﯾ ﺗﺎﺑﻊ در ﻫﻢ ﺳﺎزی روی ﻋﻨﺎﺻﺮ‬
‫ﻟﯿﺴﺖ اﻋﻤﺎل ﮐﻨﯿﺪ و ﺳﭙﺲ ﺷﺮوع ﺑﻪ ﭘﯿﻤﺎﯾﺶ ﻟﯿﺴﺖ از اﺑﺘﺪای آن ﮐﻨﯿﺪ‪ .‬ﺑﺮای ﻫﺮ ﻋﻨﺼﺮ ﻣﺸﺎﻫﺪه ﺷﺪه ﻣﻘﺪار ﻣﺘﻨﺎﻇﺮ ﺑﺎ‬
‫آن در ‪ Hashtable‬را ﻋﻼﻣﺖ ﻣ زﻧﯿﻢ‪ .‬اﮔﺮ دور وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ ﺣﺘﻤﺎ ﻋﻨﺼﺮی دارﯾﻢ ﮐﻪ ﺑﯿﺸﺘﺮ از ﯾ ﺑﺎر ﺗﮑﺮار‬
‫▷‬
‫ﺷﺪه اﺳﺖ‪ ،‬ﺑﻨﺎﺑﺮاﯾﻦ ﻫﻨﮕﺎم ﻋﻼﻣﺖ زدن آن در ‪ Hashtable‬ﻣ ﺗﻮاﻧﯿﻢ ﺗﮑﺮاری ﺑﻮدن ﻋﻨﺼﺮ را ﺗﺸﺨﯿﺺ دﻫﯿﻢ‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪ .٨‬ﺟﻤﻊ ﮐﻨﻨﺪه اﻟ‬
‫ﭘﯿﭽﯿﺪه‬
‫‪۴‬‬
‫ﻓﺮض ﮐﻨﯿﺪ ﺑﺮای ﻧﻤﺎﯾﺶ اﻋﺪاد از ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی اﺳﺘﻔﺎده ﻣ ﮐﻨﯿﻢ ﺑﻪ ﻃﻮری ﮐﻪ ﻫﺮ ﻋﻨﺼﺮ ﻟﯿﺴﺖ ﯾ رﻗﻢ را ذﺧﯿﺮه‬
‫ﻣ ﮐﻨﺪ و ﮐﻢ ارزش ﺗﺮﯾﻦ رﻗﻢ در اﺑﺘﺪای ﻟﯿﺴﺖ ﻗﺮار دارد‪ .‬اﻟ ﻮرﯾﺘﻤ اراﺋﻪ دﻫﯿﺪ ﮐﻪ ﺑﺎ درﯾﺎﻓﺖ دو ﻋﺪد ﺑﻪ ﺷ ﻞ ﻓﻮق‬
‫ﺣﺎﺻﻞ ﺟﻤﻊ آﻧﻬﺎ را در ﻗﺎﻟﺐ ﯾ ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی ﺑﺎزﮔﺮداﻧﺪ‪.‬‬
‫ﺣﻞ‪ .‬ﭘﯿﺎده ﺳﺎزی ﻣﺸﺎﺑﻪ ﺳﺎﺧﺘﺎر ﺟﻤﻊ ﮐﻨﻨﺪه ﻫﺎی ﺳﺨﺖ اﻓﺰاری اﺳﺖ ﮐﻪ در درس ﻣﺪار ﻣﻨﻄﻘ دﯾﺪه اﯾﻢ‪ .‬ﺑﺎﯾﺪ ﺑﻪ اﯾﻦ‬
‫ﻧﮑﺘﻪ ﺗﻮﺟﻪ ﮐﻨﯿﻢ ﮐﻪ اﮔﺮ ﻃﻮل ﺗﻮ ﻟﯿﺴﺖ ورودی ﯾ ﺴﺎن ﻧﺒﺎﺷﺪ ﺑﺎﯾﺪ در ﺻﻮرت رﺳﯿﺪن ﺑﻪ ﭘﺎﯾﺎن ﻟﯿﺴﺖ ﮐﻮﺗﺎﻫﺘﺮ‪ ،‬از آن‬
‫▷‬
‫ﻧﻘﻄﻪ ﺑﻪ ﺑﻌﺪ ﻣﻘﺎدﯾﺮ آن را ﺻﻔﺮ ﻓﺮض ﮐﻨﯿﻢ‪.‬‬
‫ﻣﺴﺌﻠﻪی ‪ TA .٩‬ﻫﺎی ﺿﺮﺑﺪری‬
‫از ﭘﺪﯾﺪه ﻫﺎﯾﯽ ﮐﻪ ﺗﻨﻬﺎ در داﻧﺸ ﺪه ﮐﺎﻣﭙﯿﻮﺗﺮ رخ ﻣ دﻫﺪ ‪ TA‬ﺑﻮدن ﺑﺮای درﺳ اﺳﺖ ﮐﻪ ﺑﺮﺧ از داﻧﺸﺠﻮﯾﺎن آن ‪TA‬‬
‫ﺷﻤﺎ در درس دﯾ ﺮی در ﻃﻮل ﻫﻤﺎن ﺗﺮم ﺑﺎﺷﻨﺪ! ﺑﻪ ﭼﻨﯿﻦ ﭘﺪﯾﺪه ﻧﺎﺑﺴﺎﻣﺎﻧ ‪ TA ،‬ﺿﺮﺑﺪری ﮔﻔﺘﻪ ﻣ ﺷﻮد‪.‬‬
‫ﻓﺮض ﮐﻨﯿﺪ ﺑﻪ دﻻﯾﻞ ﻧﺎﻣﻌﻠﻮﻣ ﻣ ﺧﻮاﻫﯿﻢ ﺗﻤﺎم داﻧﺸﺠﻮﯾﺎن و ‪ TA‬ﻫﺎی ﮐﻼس ﺑﯿﻨﺎﯾﯽ ﻣﺎﺷﯿﻦ را ﺿﻤﻦ رﻋﺎﯾﺖ ﺷﺮاﯾﻂ‬
‫ﺧﺎﺻ در ﯾ ﺳﺎﻟﻦ ﻣﺮﺑﻊ ﺷ ﻞ ﺑﺎ ﭼﯿﺪﻣﺎن ﺻﻨﺪﻟ در ﻗﺎﻟﺐ ‪ Grid‬ﺑﻨﺸﺎﻧﯿﻢ‪ .‬ﻣ داﻧﯿﻢ اﮔﺮ دو داﻧﺸﺠﻮ ﺑﻪ ﻃﻮر ﺿﺮﺑﺪری‬
‫‪ TA‬ﻫﻢ ﺑﺎﺷﻨﺪ ﺷﺮوع ﺑﻪ ﭼﺸﻢ ﻏﺮه رﻓﺘﻦ ﺑﻪ ﻫﻢ ﻣ ﮐﻨﻨﺪ‪ .‬ﺷﻌﺎع دﯾﺪ ﯾ داﻧﺸﺠﻮی را ﺑﺮاﺑﺮ ﺗﻤﺎم ﺻﻨﺪﻟ ﻫﺎﯾﯽ ﮐﻪ در‬
‫ﻫﻤﺎن ردﯾﻒ ﯾﺎ ﺳﺘﻮن وی و ﯾﺎ روی ﯾ از ﻗﻄﺮﻫﺎی ﮔﺬرا از ﻣﺨﺘﺼﺎت او ﺑﺎﺷﻨﺪ ﺗﻌﺮﯾﻒ ﻣ ﮐﻨﯿﻢ‪ .‬ﯾ داﺷﻨﺠﻮ ﺗﻨﻬﺎ‬
‫ﻣ ﺗﻮاﻧﺪ ﺑﻪ اﻓﺮادی ﮐﻪ در ﺷﻌﺎع دﯾﺪش ﺑﺎﺷﻨﺪ ﭼﺸﻢ ﻏﺮه ﺑﺮود‪ .‬ﻣ ﺧﻮاﻫﯿﻢ داﻧﺸﺠﻮﯾﺎن را ﺑﻪ ﮔﻮﻧﻪ ای ﺑﭽﯿﻨﯿﻢ ﮐﻪ ﻫﯿﭻ‬
‫دو داﻧﺸﺠﻮﯾﯽ ﺑﻪ ﻫﻢ ﭼﺸﻢ ﻏﺮه ﻧﺮوﻧﺪ‪.‬‬
‫ﻓﺮض ﮐﻨﯿﺪ ‪ n‬داﻧﺸﺠﻮ و ﺳﺎﻟﻨ ﺑﺎ اﺑﻌﺎد ‪ n × n‬دارﯾﻢ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﭘﺸﺘﻪ اﻟ ﻮرﯾﺘﻤ اراﺋﻪ دﻫﯿﺪ ﮐﻪ ﭼﯿﺪﻣﺎﻧ ﻣﺠﺎز ﺑﺮای‬
‫داﻧﺸﺠﻮﻫﺎ اراﺋﻪ دﻫﺪ‪.‬‬
‫زﻣﺎن اﺟﺮای اﻟ ﻮرﯾﺘﻢ در اﯾﻦ ﺳﻮال اﻫﻤﯿﺘ ﻧﺪارد‪ ،‬اﻣﺎ ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓ ﺷﻤﺎ ﺑﺎﯾﺪ از )‪ O(n‬ﺑﺎﺷﺪ‪.‬‬
‫ﺣﻞ‪ .‬از آﻧﺠﺎ ﮐﻪ ﻣﺤﺪودﯾﺖ زﻣﺎﻧ وﺟﻮد ﻧﺪارد ﻣ ﺗﻮاﻧﯿﻢ ﺑﺎ ‪ backtrack‬روی ﺗﻤﺎم ﺟﺎﯾ ﺸﺖ ﻫﺎی ﻣﻤ ﻦ ﺑﺎ ﯾ‬
‫اﻟ ﻮرﯾﺘﻢ ﺑﺎزﮔﺸﺘ ﻣﺴﺎﻟﻪ را ﺣﻞ ﮐﻨﯿﻢ‪ .‬ﺑﻪ ﮐﻤ ﭘﺸﺘﻪ ﻣ ﺗﻮاﻧﯿﻢ ﯾ اﻟ ﻮرﯾﺘﻢ ﺑﺎزﮔﺸﺘ را ﺑﻪ اﻟ ﻮرﯾﺘﻢ ﻏﯿﺮ ﺑﺎزﮔﺸﺘ‬
‫ﺗﺒﺪﯾﻞ ﮐﻨﯿﻢ‪ .‬ﺑﻪ ﺷ ﻞ زﯾﺮ ﻋﻤﻞ ﻣ ﮐﻨﯿﻢ‪:‬‬
‫‪begin‬‬
‫;‪i←0‬‬
‫; ]‪find the first valid position Pi for student[i‬‬
‫‪if no such position found then‬‬
‫; ‪pop Pi−1 from the stack‬‬
‫; ‪put student[i-1] at Pi−1‬‬
‫; ‪i=i−1‬‬
‫; ‪repeat‬‬
‫‪end‬‬
‫; ‪push Pi to stack‬‬
‫; ‪i++‬‬
‫‪end‬‬
‫▷‬
‫ﻣﺴﺌﻠﻪی ‪ .١٠‬ﺻﻒ ﻃﻮﻻﻧ‬
‫‪ n‬داﻧﺸﺠﻮ در ﯾ ﺻﻒ ﭘﺸﺖ ﺳﺮ ﻫﻢ اﯾﺴﺘﺎده اﻧﺪ و ﻫﺮ ﻧﻔﺮ ﺳﻌ ﻣ ﮐﻨﺪ ﺟﻠﻮی ﺻﻒ را ﺑﺒﯿﻨﺪ‪ .‬ﯾ ﻧﻔﺮ ﺗﻨﻬﺎ در ﺻﻮرﺗ‬
‫ﻣ ﺗﻮاﻧﺪ ﺟﻠﻮی ﺻﻒ را ﺑﺒﯿﻨﺪ ﮐﻪ ﻫﻤﻪ اﻓﺮادی ﮐﻪ ﺟﻠﻮﺗﺮ از او اﯾﺴﺘﺎده اﻧﺪ از وی ﮐﻮﺗﺎﻫﺘﺮ ﺑﺎﺷﻨﺪ‪ .‬ﺗﻨﻬﺎ ﺑﺎ اﺳﺘﻔﺎده از داده‬
‫‪۵‬‬
‫ﺳﺎﺧﺘﺎر ﭘﺸﺘﻪ اﻟ ﻮرﯾﺘﻤ اراﺋﻪ دﻫﯿﺪ ﮐﻪ ﺑﺎ درﯾﺎﻓﺖ ﻗﺪ داﻧﺸﺠﻮﯾﺎن از اﺑﺘﺪای ﺻﻒ ﺗﺎ اﻧﺘﻬﺎی آن ﺗﻌﺪاد داﻧﺸﺠﻮﯾﺎﻧ ﮐﻪ ﻣ‬
‫ﺗﻮاﻧﻨﺪ ﺟﻠﻮ ﺻﻒ را ﺑﺒﯿﻨﻨﺪ ﺑﺎزﮔﺮداﻧﺪ‪.‬‬
‫ﺣﻞ‪ .‬ﺑﺮای اﯾﻨﮑﻪ ﮐﺴ ﺑﺘﻮاﻧﺪ ﺟﻠﻮی ﺻﻒ را ﺑﺒﯿﻨﺪ ﺑﺎﯾﺪ ﻣﺎﮐﺴﯿﻤﻮم ﻗﺪ اﻓﺮاد ﻗﺒﻠ او در ﺻﻒ از ﻗﺪ ﺧﻮدش ﮐﻤﺘﺮ ﺑﺎﺷﺪ‪.‬‬
‫ﻗﺪ اﻓﺮاد را ﺑﻪ ﺗﺮﺗﯿﺐ از اﺑﺘﺪای ﺻﻒ در ﯾ ﭘﺸﺘﻪ ‪ Push‬ﮐﻨﯿﺪ‪ .‬ﺑﺎ اﯾﺪه ﻣﺸﺎﺑﻪ ﺳﻮال ‪ ٣‬ﻣ ﺗﻮان ﺳﻮال را ﺣﻞ ﮐﺮد‪▷ .‬‬
‫ﻣﺴﺌﻠﻪی ‪ .١١‬ﻟﯿﺴﺖ دوﺳﻮﯾﻪ ﺗﮏ اﺷﺎره ﮔﺮ‬
‫ﻣ ﺧﻮاﻫﯿﻢ ﯾ ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی دو ﺳﻮﯾﻪ را ﺗﻨﻬﺎ ﺑﺎ ﯾ اﺷﺎره ﮔﺮ ﺑﻪ ازای ﻫﺮ ﻋﻨﺼﺮ ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﻢ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ اﯾﻦ اﺷﺎره‬
‫ﮔﺮ ﺑﺎﯾﺪ اﻃﻼﻋﺎت ﻣﺮﺑﻮط ﺑﻪ ﻫﺮ دو ﻋﻨﺼﺮ ‪ next‬و ‪ prev‬را ﻧﮕﻬﺪاری ﮐﻨﺪ‪ .‬ﻫﺮ اﺷﺎره ﮔﺮ ﯾ ﻣﻘﺪار ‪ ٣٢ integer‬ﺑﯿﺘ‬
‫اﺳﺖ ﮐﻪ آدرس ﯾ ﻋﻨﺼﺮ ﻟﯿﺴﺖ در ﺣﺎﻓﻈﻪ را ذﺧﯿﺮه ﻣ ﮐﻨﺪ‪ .‬روش ﺑﺮای ﭘﯿﺎده ﺳﺎزی ﻟﯿﺴﺖ ﭘﯿﻮﻧﺪی ﺑﺎ ﺳﺎﺧﺘﺎر ﻓﻮق‬
‫اراﺋﻪ دﻫﯿﺪ‪.‬‬
‫ﺣﻞ‪ .‬از ﻋﻤﻠﯿﺎت ﻫﺎی ﺑﯿﺘ ﺑﺮ روی اﺷﺎره ﮔﺮﻫﺎ اﺳﺘﻔﺎده ﮐﻨﯿﺪ‪.‬‬
‫‪۶‬‬
‫▷‬