‫ﺑﺎﺳﻤﻪ ﺗﻌﺎﻟﻲ‬
‫ﭘﺎﺳﺨﻨﺎﻣﻪ اﻣﺘﺤﺎن ﭘﺎﻳﺎن ﺗﺮم درس داده ﺳﺎﺧﺘﺎرﻫﺎ و اﻟﮕﻮرﻳﺘﻢﻫﺎ‬
‫ﻗﺴﻤﺖ اول‪ :‬داده ﺳﺎﺧﺘﺎرﻫﺎ و اﻟﮕﻮرﻳﺘﻢﻫﺎ در ﺗﺌﻮري‬
‫‪ .1‬ﺑﻪ آراﻳﻪي ]‪ A[1..n‬ﻳﻚ آراﻳﻪي ‪ wiggly‬ﮔﻔﺘﻪ ﻣﻲﺷﻮد اﮔﺮ‬
‫‪ሾ2݊ + 1ሿ‬ܣ ≥ ‪ሾ2݊ሿ‬ܣ ∧ ‪ሾ2݊ሿ‬ܣ ≤ ‪ሾ2݊ − 1ሿ‬ܣ … ‪ሾ5ሿ‬ܣ ≥ ‪ሾ4ሿ‬ܣ ∧ ‪ሾ4ሿ‬ܣ ≤ ‪ሾ3ሿ‬ܣ ∧ ‪ሾ3ሿ‬ܣ ≥ ‪ሾ2ሿ‬ܣ ∧ ‪ሾ2ሿ‬ܣ ≤ ‪ሾ1ሿ‬ܣ‬
‫اﻟﮕﻮرﻳﺘﻤﻲ ﻛﺎرآﻣﺪ اراﻳﻪ دﻫﻴﺪ ﻛﻪ ﺑﺎ ﮔﺮﻓﺘﻦ ﻳﻚ آراﻳﻪ ﻣﺮﺗﺐ ﺷﺪه ﺑﻪ ﻋﻨﻮان ورودي‪ ،‬آراﻳﻪاي ﺑﺎ ﺧﺎﺻﻴﺖ ذﻛﺮﺷﺪه را ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ‬
‫ﺑﺮﮔﺮداﻧﺪ‪ .‬زﻣﺎن اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ ﺧﻮد را ﺗﺤﻠﻴﻞ ﻛﻨﻴﺪ‪.‬‬
‫ﻛﺎﻓﻲ اﺳﺖ رﺷﺘﻪ دﺳﺘﻮرات زﻳﺮ را ﺑﺎ )‪ O(n‬زﻣﺎن اﺟﺮا و )‪ O(1‬ﺣﺎﻓﻈﻪي اﺿﺎﻓﻲ اﺟﺮا ﻛﻨﻴﻢ‪:‬‬
‫)‪for (i = 1; i < n – 1; i += 2‬‬
‫;)]‪swap(A[i],A[i+1‬‬
‫‪ .2‬ﻧﺸﺎن دﻫﻴﺪ دوﻣﻴﻦ ﻋﻨﺼﺮ ﻳﻚ آراﻳﻪ از ﻧﻈﺮ ﺑﺰرﮔﻲ ﻣﻘﺪار ﻛﻠﻴﺪ را ﻣﻲﺗﻮان ﺑﺎ ‪ − 2‬ۀ‪lgn‬ڿ ‪ n +‬ﻣﻘﺎﻳﺴﻪ ﻳﺎﻓﺖ‪.‬‬
‫ﺑﺎ روﻳﻪاي ﻣﺸﺎﺑﻪ ﺟﺎم ﺣﺬﻓﻲ ﻋﻤﻞ ﻣﻲﻛﻨﻴﻢ‪ :‬ﻋﻨﺎﺻﺮ را ﺑﻪ دﺳﺘﻪﻫﺎي دوﺗﺎﻳﻲ ﺗﻘﺴﻴﻢ ﻣﻲﻛﻨﻴﻢ‪ ،‬از ﻫﺮ دﺳﺘﻪ ﺑﺎ ﻳﻚ ﻣﻘﺎﻳﺴﻪ ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ را‬
‫ﺑﻪ دور ﺑﻌﺪ ﻣﻲﻓﺮﺳﺘﻴﻢ‪ ،‬ﺑﺎز در دور ﺑﻌﺪ ﻋﻨﺎﺻﺮ را ﺑﻪ دﺳﺘﻪﻫﺎي دوﺗﺎﻳﻲ ﺗﻘﺴﻴﻢ و ﻫﻤﻴﻦ روﻳﻪ را ﺑﺮاي ﻳﺎﻓﺘﻦ ﺑﻴﺸﻴﻨﻪ ﻋﻨﺼﺮ ﺗﻜﺮار ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﺑﺎ ﻳﻚ درﺧﺖ دودوﻳﻲ‪ ،‬ﻋﻨﺼﺮ ﺑﻴﺸﻴﻨﻪ را ﺑﺎ ‪ n – 1‬ﻣﻘﺎﻳﺴﻪ ﻣﻲﻳﺎﺑﻴﻢ‪ .‬دوﻣﻴﻦ ﻋﻨﺼﺮ ﺑﻪ ﻟﺤﺎظ ﺑﺰرﮔﻲ در اﻳﻦ درﺧﺖ ﻓﻘﻂ ﻣﻲﺗﻮاﻧﺪ‬
‫ﺗﻮﺳﻂ ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ ﺣﺬف ﺷﻮد‪ ،‬ﭘﺲ ﺣﺘﻤﺎ ﺑﺎ آن ﻣﻘﺎﻳﺴﻪ ﺷﺪه‪ ،‬ﻳﻌﻨﻲ ﻣﻴﺘﻮان ﺑﺎ ﻳﺎﻓﺘﻦ ﺑﺰرﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ از ﺑﻴﻦ ﻋﻨﺎﺻﺮي ﻛﻪ ﺑﺎ ﺑﺰرﮔﺘﺮﻳﻦ‬
‫ﻋﻨﺼﺮ ﻣﻘﺎﻳﺴﻪ ﺷﺪه اﻧﺪ )ﻛﻪ ﺗﻌﺪاد آﻧﻬﺎ ﺑﺮاﺑﺮ ارﺗﻔﺎع درﺧﺖ ﻳﻌﻨﻲ )‪ log(n‬اﺳﺖ( دوﻣﻴﻦ ﻋﻨﺼﺮ را ﺑﻴﺎﺑﻴﻢ ﻛﻪ اﻳﻦ ﻛﺎر ﻫﻢ ﺑﺎ ‪ log(n)-1‬ﻣﻘﺎﻳﺴﻪ‬
‫ﻣﻤﻜﻦ اﺳﺖ‪.‬‬
‫‪ .3‬اﮔﺮ ﻋﻨﺼﺮ دﻟﺨﻮاﻫﻲ را در ﻳﻚ درﺧﺖ ﻗﺮﻣﺰ‪-‬ﺳﻴﺎه دﻟﺨﻮاه ‪ insert‬ﻛﺮده و ﺳﭙﺲ ﻫﻤﺎن ﻋﻨﺼﺮ را ‪ delete‬ﻛﻨﻴﻢ‪ ،‬آﻳﺎ درﺧﺖ ﺣﺎﺻﻞ‬
‫ﻫﻤﻮاره ﻫﻤﺎن درﺧﺖ اوﻟﻴﻪ ﺧﻮاﻫﺪ ﺑﻮد؟ ﭼﺮا؟‬
‫ﺧﻴﺮ‪ .‬ﻣﺜﺎل ﻧﻘﺾ‪:‬‬
‫‪٣‬‬
‫‪٢‬‬
‫‪٢‬‬
‫‪٣‬‬
‫‪Delete 1‬‬
‫‪٣‬‬
‫‪١‬‬
‫‪Rotation‬‬
‫‪٢‬‬
‫‪Insert 1‬‬
‫‪٣‬‬
‫‪٢‬‬
‫‪١‬‬
‫‪ .4‬ﻳﻚ ﺻﻒ را ﺑﺎ اﺳﺘﻔﺎده از دو ﭘﺸﺘﻪ ﺑﻪ ﻧﺤﻮي ﭘﻴﺎده ﺳﺎزي ﻛﻨﻴﺪ ﻛﻪ ﻫﺰﻳﻨﻪي ﺳﺮﺷﻜﻦ ﻋﻤﻠﻴﺎت ‪ enqueue‬و ‪ dequeue‬از )‪θ(1‬‬
‫ﺑﺎﺷﺪ‪ .‬ﻋﻼوه ﺑﺮ ﺗﺸﺮﻳﺢ ﻛﺎﻣﻞ ﭘﻴﺎده ﺳﺎزي‪ ،‬ﻫﺰﻳﻨﻪي ﺳﺮﺷﻜﻦ را ﻧﻴﺰ ﻣﺤﺎﺳﺒﻪ ﻧﻤﺎﻳﻴﺪ‪.‬‬
‫ﺑﺮاي ﻫﺮ ﻋﻤﻞ ‪ enqueue‬ﻋﻨﺼﺮ ﺟﺪﻳﺪ را در ﭘﺸﺘﻪي اول ‪ Push‬ﻣﻲﻛﻨﻴﻢ‪ .‬ﺑﺮاي ﻫﺮ ﻋﻤﻞ ‪ dequeue‬اﮔﺮ ﭘﺸﺘﻪي دوم ﺧﺎﻟﻲ ﻧﺒﻮد‬
‫ﻋﻨﺼﺮ ﺑﺎﻻي آن را ‪ Pop‬ﻣﻲﻛﻨﻴﻢ و ﺑﻪ ﻋﻨﻮان ﭘﺎﺳﺦ ﺑﺮﻣﻲﮔﺮداﻧﻴﻢ‪ ،‬و اﮔﺮ ﺧﺎﻟﻲ ﺑﻮد ﻗﺒﻞ از اﻳﻦ ﻛﺎر اﺑﺘﺪا ﻫﻤﻪي ﻋﻨﺎﺻﺮ ﻣﻮﺟﻮد در ﭘﺸﺘﻪ‬
‫اول را ﻳﻜﻲ ﻳﻜﻲ از آن ‪ Pop‬ﻛﺮده و در ﭘﺸﺘﻪي دوم ‪ Push‬ﻣﻲﻛﻨﻴﻢ‪ .‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻫﻴﭻ ﮔﺎه ﻋﻨﺎﺻﺮ را از ﭘﺸﺘﻪي دوم ﺑﻪ اول ﺑﺮ ﻧﻤﻲ‪-‬‬
‫ﮔﺮداﻧﻴﻢ‪ .‬در اﻳﻦ ﻓﺮاﻳﻨﺪ ﻫﺮ ﻋﻨﺼﺮ دﻗﻴﻘﺎ ﻳﻚ ﺑﺎر ﺑﻪ ﭘﺸﺘﻪي اول ‪ Push‬ﻣﻴﺸﻮد‪ ،‬ﻳﻚ ﺑﺎر از آن ‪ Pop‬ﻣﻲﺷﻮد‪ ،‬ﻳﻚ ﺑﺎر در ﭘﺸﺘﻪي دوم‬
‫‪ Push‬ﻣﻲﺷﻮد و ﻳﻚ ﺑﺎر از آن ‪ Pop‬ﻣﻲﺷﻮد‪ ،‬ﻳﻌﻨﻲ ﺑﺮاي ﻫﺮ ﻋﻨﺼﺮ ‪ 4‬واﺣﺪ ﻫﺰﻳﻨﻪ ﻣﻲﻛﻨﻴﻢ‪ ،‬ﭘﺲ ﺳﺮﺷﻜﻦ ﻫﺰﻳﻨﻪي ﻫﺮ ﻋﻤﻞ )‪O(1‬‬
‫اﺳﺖ‪.‬‬
‫‪ .5‬آراﻳﻪاي از اﻋﺪاد ﻃﺒﻴﻌﻲ دارﻳﻢ‪ .‬اﻟﮕﻮرﻳﺘﻤﻲ ﭘﻴﺸﻨﻬﺎد ﻛﻨﻴﺪ ﻛﻪ در ) ‪ θ(݊ଶ‬ﻛﻨﺘﺮل ﻛﻨﺪ ﻛﻪ آﻳﺎ ﺳﻪ ﻋﺪد در آراﻳﻪ وﺟﻮد دارﻧﺪ ﻛﻪ ﻣﻘﺎدﻳﺮ‬
‫آنﻫﺎ ﻧﺸﺎندﻫﻨﺪهي ﻃﻮل اﺿﻼع ﻣﺜﻠﺚ ﻗﺎﻳﻢ اﻟﺰاوﻳﻪ ﺑﺎﺷﻨﺪ‪ ،‬و در ﺻﻮرت وﺟﻮد آنﻫﺎ را ﺑﺮﮔﺮداﻧﺪ‪.‬‬
‫اﺑﺘﺪا ﻫﺮ ﻋﻨﺼﺮ را ﺑﺎ ﻣﺮﺑﻊ آن ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲﻛﻨﻴﻢ‪ .‬ﻛﺎﻓﻲ اﺳﺖ در آراﻳﻪي ﺟﺪﻳﺪ ﺳﻪ ﻋﻨﺼﺮ را ﺑﻴﺎﺑﻴﻢ ﻛﻪ ﻋﻨﺼﺮ اول ﺑﺮاﺑﺮ ﻣﺠﻤﻮع دو ﻋﻨﺼﺮ‬
‫ﺑﻌﺪ ﺷﻮد‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر ﻋﻨﺎﺻﺮ آراﻳﻪ را ﻣﺮﺗﺐ ﻣﻲﻛﻨﻴﻢ و آن را آراﻳﻪي ‪ A‬ﻣﻲﻧﺎﻣﻴﻢ‪ .‬ﺳﭙﺲ روﻳﻪي زﻳﺮ را ﺑﺮ روي آن اﺟﺮا ﻣﻲﻛﻨﻴﻢ‪:‬‬
‫{ )‪for (i = 0; i < n; i++‬‬
‫;‪int p1 = 0, p2 = i – 1‬‬
‫)‪while (p1 < i && p2 > p1‬‬
‫;‪if (A[p1] + A[p2] > A[i]) p2--‬‬
‫‪else‬‬
‫;‪if (A[p1] + A[p2] < A[i]) p1++‬‬
‫‪else‬‬
‫;)]‪return (A[p1], A[p2], A[i‬‬
‫}‬
‫‪ .6‬ﻓﺮض ﻛﻨﻴﺪ ﻳﻚ درﺧﺖ دودوﻳﻲ ﺟﺴﺘﺠﻮ ﻣﺜﻞ ‪ T‬ﺑﺎ ‪ n‬راس داده ﺷﺪه اﺳﺖ‪ .‬در اﻳﻦ ﻟﺤﻈﻪ ﭼﻨﺪ ‪ Rotation‬در ‪ T‬اﻣﻜﺎن ﭘﺬﻳﺮ اﺳﺖ؟‬
‫ﭼﺮا؟ )ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻛﻪ ﻣﻲﺧﻮاﻫﻴﻢ ﻓﻘﻂ ﻳﻚ ‪ Rotation‬اﻧﺠﺎم دﻫﻴﻢ ﻧﻪ دﻧﺒﺎﻟﻪاي از ‪ Rotation‬ﻫﺎ(‪.‬‬
‫ﺑﺮ روي ﻫﺮ ﻳﺎل درﺧﺖ ﻛﻪ ﮔﺮه ﭘﺪر را ﺑﻪ ﻓﺮزﻧﺪ ﺳﻤﺖ ﭼﭙﺶ وﺻﻞ ﻣﻴﻜﻨﺪ ﻓﻘﻂ ﻣﻲﺗﻮان ﭼﺮﺧﺶ ﺑﻪ راﺳﺖ اﻧﺠﺎم داد‪ ،‬و ﺑﺮ روي ﻳﺎﻟﻬﺎﻳﻲ‬
‫ﻛﻪ ﮔﺮه ﭘﺪر را ﺑﻪ ﻓﺮزﻧﺪ ﺳﻤﺖ راﺳﺖ وﺻﻞ ﻣﻴﻜﻨﻨﺪ ﻓﻘﻂ ﻣﻴﺘﻮان ﭼﺮﺧﺶ ﺑﻪ ﭼﭗ اﻧﺠﺎم داد‪ .‬ﭘﺲ ﺗﻌﺪاد ﻛﻞ ﭼﺮﺧﺶﻫﺎي ﻣﻤﻜﻦ ﺑﺮاﺑﺮ‬
‫اﺳﺖ ﺑﺎ ﺗﻌﺪاد ﻳﺎﻟﻬﺎ ﻳﻌﻨﻲ ‪n-1‬‬
‫‪ .7‬ﻫﺮ ﻳﻚ از ﻛﺪﻫﺎي زﻳﺮ ﺑﻪ زﺑﺎن ‪ Java‬ﺑﺮاي اﺟﺮاي اﻟﮕﻮرﻳﺘﻢﻫﺎي ﻣﺘﻔﺎوﺗﻲ ﻧﻮﺷﺘﻪ ﺷﺪهاﻧﺪ ﻛﻪ ﻋﺪد ﻃﺒﻴﻌﻲ ‪ n‬را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ‬
‫ﻛﺮده و ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ رﺷﺘﻪاي ﺑﺎ ﻃﻮل ‪ 2௡‬ﺷﺎﻣﻞ ﻛﺎراﻛﺘﺮﻫﺎي ‪ a‬را ﺑﺮ ﻣﻲﮔﺮداﻧﺪ‪ .‬زﻣﺎن اﺟﺮاي ﻫﺮﻳﻚ را ﻣﺤﺎﺳﺒﻪ و ﻣﻘﺎﻳﺴﻪ ﻛﻨﻴﺪ‪.‬‬
‫)ﻳﺎدآوري‪ :‬ﭼﺴﺒﺎﻧﺪن دو رﺷﺘﻪ ﺑﻪ ﻫﻢ در ‪ Java‬ﻧﻴﺎزﻣﻨﺪ زﻣﺎﻧﻲ ﻣﺘﻨﺎﺳﺐ ﺑﺎ ﻣﺠﻤﻮع ﻃﻮل دو رﺷﺘﻪ اﺳﺖ(‬
‫{ )‪public String m1(int n‬‬
‫;"‪String s = "a‬‬
‫)‪for (int i = 0; i < n; i++‬‬
‫;‪s = s + s‬‬
‫;‪return s‬‬
‫}‬
‫‪I.‬‬
‫‪ି૚‬ܖ‬
‫) ܖ‪(૛‬۽ = ‪ା૚ − ૛‬ܖ‪෍ ૛ܑା૚ = ૛‬‬
‫‪࢏ୀ૙‬‬
‫{ )‪public String m2(int n‬‬
‫;"" = ‪String s‬‬
‫‪int N = 1 << n; // 2^n‬‬
‫)‪for (int i = 0; i < N; i++‬‬
‫;"‪s = s + "a‬‬
‫;‪return s‬‬
‫}‬
‫ܖ‪ + ૚)૛‬ܖ‪ (૛‬ۼ)‪ + ૚‬ۼ(‬
‫=‬
‫‪ ൯‬ܖ‪൫૛૛‬۽ =‬
‫‪૛‬‬
‫‪૛‬‬
‫ۼ‬
‫‪ି૚‬ۼ‬
‫‪࢏ୀ૚‬‬
‫‪࢏ୀ૙‬‬
‫‪II.‬‬
‫= ܑ ‪෍(ܑ + ૚) = ෍‬‬
‫{ )‪public String m3(int n‬‬
‫;"‪if (n == 0) return "a‬‬
‫;)‪else return m3(n-1) + m3(n-1‬‬
‫}‬
‫ܖ ‪ − ૚) + ૛‬ܖ(܂‪) = ૛‬ܖ(܂‬
‫‪III.‬‬
‫ﺑﻨﺎﺑﺮ ﺗﺤﻠﻴﻞ درﺧﺘﻲ‪ ،‬ﻣﻴﺪاﻧﻴﻢ اﻳﻦ درﺧﺖ ‪ n‬ﺳﻄﺢ دارد و در ﻫﺮ ﺳﻄﺢ ﻣﺠﻤﻮع ﻫﺰﻳﻨﻪﻫﺎ ܖ ‪ ૛‬ﺧﻮاﻫﺪ ﺑﻮد‪ ،‬ﭘﺲ ﭘﺎﺳﺦ ) ܖ ‪૛‬ܖ(۽ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﻗﺴﻤﺖ دوم‪ :‬داده ﺳﺎﺧﺘﺎرﻫﺎ و اﻟﮕﻮرﻳﺘﻢﻫﺎ در ﻛﺎرﺑﺮد‬
‫ﺗﻮﺿﻴﺢ‬
‫ﺳﺎﻳﺖ ‪ facebook‬ﻳﻚ ﺧﺪﻣﺖ ﻧﺴﺒﺘﺎ ﺟﺪﻳﺪ اﻳﻨﺘﺮﻧﺘﻲ اﺳﺖ ﻛﻪ در آن ﻫﺮ ﻛﺎرﺑﺮ ﻣﻲﺗﻮاﻧﺪ ﭘﺲ از ﺛﺒﺖ ﻧﺎم ﻳﻚ ﺣﺴﺎب ﻛﺎرﺑﺮي ﺑﻪ ﻧﺎم ﺧﻮد ﺑﺎز‬
‫ﻛﻨﺪ و از ﻃﺮﻳﻖ آن ﻣﻄﺎﻟﺐ ﺟﺎﻟﺐ و ﻣﻮرد ﻋﻼﻗﻪاش را ﺑﺮاي دوﺳﺘﺎﻧﺶ ﺑﻪ اﺷﺘﺮاك ﺑﮕﺬارد‪ ،‬ﺑﺮاي دوﺳﺘﺎﻧﺶ ﭘﻴﺎم ﺑﻔﺮﺳﺘﺪ ﻳﺎ ﺑﺎ دﻳﺪن ﺷﺒﻜﻪ‬
‫دوﺳﺘﺎن ﺧﻮد‪ ،‬دوﺳﺘﺎن دوﺳﺘﺎن ﺧﻮد‪ ،‬و ‪ ...‬در ﺷﺒﻜﻪي دوﺳﺘﻲﻫﺎ ﺑﻪ ﺟﺴﺘﺠﻮ ﺑﭙﺮدازد‪ .‬اﻳﺪهي اﻳﻦ ﺳﺎﻳﺖ ﺗﻘﺮﻳﺒﺎ ﻣﺸﺎﺑﻪ ﺳﺮوﻳﺲ ﻗﺒﻠﻲ ﮔﻮﮔﻞ‬
‫ﺑﻪ ﻧﺎم ‪ Orkut‬اﺳﺖ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ اﻳﺪهﻫﺎي ﻣﺘﻨﻮﻋﻲ از ﺟﻤﻠﻪ اﺑﺰارﻫﺎي ﺳﺎدهاي ﺑﺮاي ﺑﺎزيﻫﺎ ﻳﺎ ﺳﺮﮔﺮﻣﻲﻫﺎي ﮔﺮوﻫﻲ ﺑﻪ آن اﺿﺎﻓﻪ ﺷﺪه‪،‬‬
‫ﺳﺮﻋﺖ ﺑﻪ اﺷﺘﺮاك ﮔﺬاري و ﺳﻬﻮﻟﺖ در درﻳﺎﻓﺖ اﻧﻮاع ﺗﺼﺎوﻳﺮ و ﻓﻴﻠﻢ و ﺻﺪا اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ و آن را ﺑﺮاي ﻛﺎرﺑﺮان ﺟﺬابﺗﺮ ﻧﻤﻮده اﺳﺖ‪.‬‬
‫‪ .1‬در ﺳﺎﻳﺖ ‪ facebook‬ﺗﻌﺪادي ﻛﺎرﺑﺮ ﺛﺒﺖ ﻧﺎم ﻣﻲﻛﻨﻨﺪ‪ .‬ورود ﻛﺎرﺑﺮان از ﻃﺮﻳﻖ وارد ﻛﺮدن آدرس اﻳﻤﻴﻞ و ﻛﻠﻤﻪي ﻋﺒﻮر اﻧﺠﺎم ﻣﻲﮔﻴﺮد‪.‬‬
‫روش ﻣﻨﺎﺳﺒﻲ ﭘﻴﺸﻨﻬﺎد ﻛﻨﻴﺪ ﻛﻪ ﺑﺎ اﺳﺘﻔﺎده از آن ﺑﺘﻮاﻧﻴﻢ ﻋﻤﻞ ﻛﻨﺘﺮل ﺗﻄﺎﺑﻖ آدرس اﻳﻤﻴﻞ و ﻛﻠﻤﻪي ﻋﺒﻮر ﻛﺎرﺑﺮان را در زﻣﺎن اﺟﺮا و‬
‫ﺑﺎ ﺣﺎﻓﻈﻪي ﻛﺎرآﻣﺪي اﻧﺠﺎم دﻫﻴﻢ‪ .‬روش ﺧﻮد را ﺑﻪ ﻃﻮر ﻛﺎﻣﻞ ﺗﺤﻠﻴﻞ ﻛﻨﻴﺪ‪ .‬دﻗﺖ ﻛﻨﻴﺪ ﻛﻪ از اﺑﺘﺪا ﺗﻌﺪاد ﻛﺎرﺑﺮان ﻣﺸﺨﺺ ﻧﻴﺴﺖ و ﻫﺮ‬
‫ﻟﺤﻈﻪ ﺑﻪ ﺗﻌﺪاد آﻧﺎن اﻓﺰوده ﻣﻲﺷﻮد‪ ،‬و روش ﺷﻤﺎ ﺑﺎﻳﺪ اﻳﻦ اﻣﺮ را ﻧﻴﺰ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻛﻨﺪ‪.‬‬
‫ﺑﺮاي آنﻛﻪ اﻳﻦ ﻛﺎر در ﺣﺎﻟﺖ ﻛﺎرآﻣﺪ اﻧﺠﺎم ﺷﻮد ﺑﺎﻳﺪ رواﻟﻲ اﺳﺘﻔﺎده ﺷﻮد ﻛﻪ اﮔﺮ ﻣﺠﻤﻮع ﻃﻮل ﻳﻚ آدرس اﻳﻤﻴﻞ و ﻛﻠﻤﻪ ﻋﺒﻮر را ﺑﻪ ﻃﻮل ‪n‬‬
‫ﺣﺮف در ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‪ ،‬ﻛﻨﺘﺮل ﺗﻄﺎﺑﻖ ﺣﺘﻲاﻻﻣﻜﺎن ﻧﺰدﻳﻚ ﺑﻪ )‪ O(n‬ﺑﻪ ﻃﻮل اﻧﺠﺎﻣﺪ‪ .‬اﻳﻦ ﻛﺎر ﺑﺎ اﺳﺘﻔﺎده از دو ﻧﻮع داده ﺳﺎﺧﺘﺎر اﻣﻜﺎن ﭘﺬﻳﺮ‬
‫اﺳﺖ‪ Hash Table :‬و ﻳﺎ ‪ .Trie‬اﺳﺘﻔﺎده از ‪ Trie‬در اﻳﻦ ﺧﺼﻮص ﺟﺰﺋﻴﺎت ﺧﺎﺻﻲ ﻧﺪارد وﻟﻲ در ﻫﻨﮕﺎم اﺳﺘﻔﺎده از ‪ Hash Table‬ﺑﺎﻳﺪ دﻗﺖ‬
‫ﻛﻨﻴﻢ ﻛﻪ ﻣﺮﺗﺒﺎ ﺑﻪ ﺗﻌﺪاد ﻛﺎرﺑﺮان اﻓﺰوده ﻣﻲﺷﻮد‪ ،‬ﻟﺬا ﺑﺎﻳﺪ از ﻳﻚ ﺟﺪول ﺑﺎ اﻧﺪازهي ﭘﻮﻳﺎ اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ ،‬ﺑﺪﻳﻦ ﻣﻨﻈﻮر ﻫﺮﮔﺎه ﺿﺮﻳﺐ ﭘﺮ ﺑﻮدن‬
‫ﺟﺪول از ﻳﻚ ﺣﺪ آﺳﺘﺎﻧﻪ ﮔﺬﺷﺖ ﺑﺎﻳﺪ اﻧﺪازهي ﺟﺪول را دوﺑﺮاﺑﺮ ﻛﻨﻴﻢ‪ ،‬ﻛﻪ اﻟﺒﺘﻪ ﺑﺎ اﻳﻦ ﻛﺎر ﺗﺎﺑﻊ ‪ Hashing‬ﻧﻴﺰ ﻋﻮض ﻣﻲﺷﻮد‪.‬‬
‫‪ .2‬در ﺳﺎﻳﺖ ‪ facebook‬ﻫﺮ زوج از ﻛﺎرﺑﺮان ﺛﺒﺖ ﻧﺎم ﺷﺪه ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺎ ﺗﻮاﻓﻖ دو ﻃﺮﻓﻪ‪ ،‬ﻳﻜﺪﻳﮕﺮ را ﺑﻪ ﻋﻨﻮان دوﺳﺖ ﺧﻮد اﺿﺎﻓﻪ ﻛﻨﻨﺪ‪.‬‬
‫اﺿﺎﻓﻪ ﺷﺪن ﻛﺎرﺑﺮان ﺟﺪﻳﺪ ﻳﺎ اﻳﺠﺎد ﭘﻴﻮﻧﺪ دوﺳﺘﻲ ﺟﺪﻳﺪ ﺑﻴﻦ دو ﻛﺎرﺑﺮ ﻣﻤﻜﻦ اﺳﺖ در ﻫﺮ ﻟﺤﻈﻪ رخ دﻫﺪ‪ .‬از ﺷﻤﺎ ﺧﻮاﺳﺘﻪ ﺷﺪه ﻳﻚ‬
‫ﺑﺮﻧﺎﻣﻪ ﻛﺎرآﻣﺪ در اﺧﺘﻴﺎر اﻳﻦ ﺳﺎﻳﺖ ﻗﺮار دﻫﻴﺪ ﻛﻪ ﻫﺮ ﻟﺤﻈﻪ ﺑﺎ ﮔﺮﻓﺘﻦ دو ﻛﺎرﺑﺮ ﺑﺘﻮاﻧﺪ ﺗﺸﺨﻴﺺ دﻫﺪ آﻳﺎ آنﻫﺎ در ﻳﻚ ﺷﺒﻜﻪي دوﺳﺘﻲ‬
‫ﻗﺮار دارﻧﺪ ﻳﺎ ﺧﻴﺮ‪ .‬دو ﻛﺎرﺑﺮ در ﻳﻚ ﺷﺒﻜﻪي دوﺳﺘﻲ ﻗﺮار دارﻧﺪ اﮔﺮ ﻣﺴﺘﻘﻴﻤﺎ ﺑﺎ ﻳﻜﺪﻳﮕﺮ دوﺳﺖ ﺑﺎﺷﻨﺪ ﻳﺎ زﻧﺠﻴﺮهاي از دوﺳﺘﺎن ﻣﻴﺎﻧﻲ‬
‫ﺑﻴﻦ آنﻫﺎ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬روﺷﻲ ﺑﺮاي اﻳﻦ ﻛﺎر اراﺋﻪ دﻫﻴﺪ ﻛﻪ ﻋﻼوه ﺑﺮ ﭘﺎﺳﺦ ﺑﻪ اﻳﻦ ﭘﺮﺳﺶ ﺑﺘﻮاﻧﺪ اﻓﺰوده ﺷﺪن ﻛﺎرﺑﺮان ﻳﺎ ﭘﻴﻮﻧﺪﻫﺎي‬
‫دوﺳﺘﻲ ﺟﺪﻳﺪ را ﻧﻴﺰ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻛﻨﺪ‪ .‬ﺳﭙﺲ آن را ﺗﺤﻠﻴﻞ ﻛﻨﻴﺪ‪.‬‬
‫اﻧﺠﺎم اﻳﻦ ﻓﺮاﻳﻨﺪ ﺑﻪ ﻧﺤﻮ ﻛﺎرآﻣﺪ ﺗﻨﻬﺎ ﺑﺎ اﺳﺘﻔﺎده از ‪ Disjoint Sets‬اﻣﻜﺎن ﭘﺬﻳﺮ اﺳﺖ‪ .‬ﺛﺒﺖ ﻧﺎم ﻫﺮ ﻛﺎرﺑﺮ ﺟﺪﻳﺪ ﺑﻪ ﻣﻨﺰﻟﻪ ﻳﻚ ﻋﻤﻞ‬
‫‪ MakeSet‬اﺳﺖ‪ ،‬اﻳﺠﺎد دوﺳﺘﻲ ﺑﻴﻦ دو ﻛﺎرﺑﺮ ﺑﻪ ﻣﻨﺰﻟﻪي ‪ Union‬ﺑﻴﻦ ﻣﺠﻤﻮﻋﻪي آن دو اﺳﺖ‪ ،‬و در ﺻﻮرﺗﻲ دو ﻛﺎرﺑﺮ در ﻳﻚ ﺷﺒﻜﻪي‬
‫دوﺳﺘﻲ ﻗﺮار دارﻧﺪ ﻛﻪ ‪ FindSet‬ﻫﺮ دوي آنﻫﺎ ﻳﻜﺴﺎن ﺑﺎﺷﺪ‪ .‬دﻗﺖ ﻛﻨﻴﺪ ﺗﻨﻬﺎ ﺑﻪ ﺣﺪاﻛﺜﺮ ﻛﺎرآﻣﺪي ﻣﻲرﺳﻴﻢ ﻛﻪ از روش ﻓﺸﺮدهﺳﺎزي ﻣﺴﻴﺮ‬
‫اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ ،‬ﻛﻪ در اﻳﻦ ﺻﻮرت اﻧﺠﺎم ‪ n‬ﻋﻤﻞ ﺑﺮ روي ﻣﺠﻤﻮﻋﻪﻫﺎ ﺑﻪ )‪ O(n‬ﺑﺴﻴﺎر ﻧﺰدﻳﻚ ﺧﻮاﻫﺪ ﺑﻮد )در واﻗﻊ ﻋﺪد دﻗﻴﻖ آن ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‬
‫))‪ O(n α(n‬ﻛﻪ ﻣﻘﺪار )‪ α(n‬در ﻋﻤﻞ ﺑﺴﻴﺎر ﻧﺰدﻳﻚ ﺑﻪ ‪ 1‬و ﻣﺮﺗﺒﻂ ﺑﺎ )‪ log*(n‬اﺳﺖ(‪.‬‬
‫‪ .3‬ﺳﺎﻳﺖ ‪ facebook‬در ﻫﺮ ﻟﺤﻈﻪ ﺑﻪ ﺷﻤﺎ ﺑﻪ ﻋﻨﻮان ﻳﻚ ﻛﺎرﺑﺮ‪ ،‬ﻳﻚ ﻛﺎرﺑﺮ دﻳﮕﺮ را ﻛﻪ ﺗﺎﻛﻨﻮن ﺑﺎ وي ﭘﻴﻮﻧﺪ دوﺳﺘﻲ ﺑﺮﻗﺮار ﻧﻜﺮدهاﻳﺪ اﻣﺎ ﺑﻪ‬
‫اﺣﺘﻤﺎل زﻳﺎد در واﻗﻌﻴﺖ ﺑﺎ ﺷﻤﺎ دوﺳﺖ اﺳﺖ را ﺑﺮاي اﻓﺰودن ﺑﻪ ﻓﻬﺮﺳﺖ دوﺳﺘﺎﻧﺘﺎن ﭘﻴﺸﻨﻬﺎد ﻣﻲﻛﻨﺪ‪ .‬ﻳﻚ ﻓﺮاﻳﻨﺪ ﺑﺮاي اﻧﺠﺎم اﻳﻦ اﻣﺮ‬
‫ﺑﺪﻳﻦ ﺻﻮرت اﺳﺖ ﻛﻪ ‪ facebook‬در ﻫﺮ ﻟﺤﻈﻪ ﺑﺮاي ﺷﻤﺎ‪ ،‬ﻣﺠﻤﻮﻋﻪاي از ﻛﺎرﺑﺮان ﻛﻪ ﺗﺎﻛﻨﻮن دوﺳﺘﺘﺎن ﻧﺸﺪهاﻧﺪ وﻟﻲ اﺣﺘﻤﺎل دوﺳﺘﻲ‬
‫دارﻧﺪ را ﻧﮕﺎه ﻣﻲدارد و ﺑﻪ ﻫﺮ ﻳﻚ از آنﻫﺎ ﻳﻚ ﻋﺪد ﺑﻪ ﻋﻨﻮان »اﺣﺘﻤﺎل دوﺳﺘﻲ« ﻧﺴﺒﺖ ﻣﻲدﻫﺪ‪ .‬ﻣﻘﺪار اﺣﺘﻤﺎل دوﺳﺘﻲ ﺑﺮاي ﻫﺮ ﻳﻚ از‬
‫اﻳﻦ اﻓﺮاد در ﻃﻮل زﻣﺎن ﻣﻲﺗﻮاﻧﺪ اﻓﺰاﻳﺶ ﻳﺎﺑﺪ‪ .‬از ﺑﻴﻦ ﻛﺎرﺑﺮان اﻳﻦ ﻣﺠﻤﻮﻋﻪ‪ facebook ،‬ﻛﺴﻲ را ﺑﻪ ﺷﻤﺎ ﭘﻴﺸﻨﻬﺎد ﻣﻲﻛﻨﺪ ﻛﻪ اﺣﺘﻤﺎل‬
‫دوﺳﺘﻲ ﺑﺎﻻﺗﺮي دارد‪ .‬اﮔﺮ ﺷﻤﺎ اﻳﻦ ﭘﻴﺸﻨﻬﺎد را ﻗﺒﻮل ﻛﺮدﻳﺪ‪ ،‬ﻛﺎرﺑﺮ ﭘﻴﺸﻨﻬﺎد ﺷﺪه ﺑﻪ ﻓﻬﺮﺳﺖ دوﺳﺘﺎﻧﺘﺎن اﺿﺎﻓﻪ ﻣﻲﺷﻮد و در ﺻﻮرت ﻋﺪم‬
‫ﻗﺒﻮل‪ ،‬ﻛﺎرﺑﺮ ﭘﻴﺸﻨﻬﺎدي از ﻣﺠﻤﻮﻋﻪ ﺣﺬف ﻣﻲﺷﻮد و ﻛﺎرﺑﺮ ﺑﺎ اﺣﺘﻤﺎل دوﺳﺘﻲ ﺑﺎﻻﺗﺮ ﺑﻌﺪي ﺑﻪ ﺷﻤﺎ ﭘﻴﺸﻨﻬﺎد ﻣﻲﺷﻮد‪ .‬روﺷﻲ ﺑﺮاي اﻳﻦ‬
‫ﻛﺎر ﭘﻴﺸﻨﻬﺎد دﻫﻴﺪ و آن را ﺗﺤﻠﻴﻞ ﻛﻨﻴﺪ‪ .‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ اﻳﻦ روش ﺑﺎﻳﺪ ﻋﻤﻞ اﻓﺰاﻳﺶ اﺣﺘﻤﺎل دوﺳﺘﻲ ﻳﻚ ﻛﺎرﺑﺮ را ﻧﻴﺰ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻛﻨﺪ‪.‬‬
‫ﺑﺮاي اﻳﻦ ﻛﺎر از دو داده ﺳﺎﺧﺘﺎر ‪ Treap‬ﻳﺎ ‪ Priority Queue‬ﻛﻪ ﻫﺮ دو ﺧﺼﻮﺻﻴﺎت ‪ MaxHeap‬را دارﻧﺪ ﻣﻲﺗﻮاﻧﻴﻢ اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ .‬ﻣﺰﻳﺖ‬
‫اﺳﺘﻔﺎده از ‪ Treap‬آن اﺳﺖ ﻛﻪ ﺟﺴﺘﺠﻮي ﻳﻚ ﻋﻨﺼﺮ ﺑﺮاي اﻓﺰاﻳﺶ اﺣﺘﻤﺎل دوﺳﺘﻲ ﻧﻴﺰ ﺑﻪ ﺧﺎﻃﺮ آن ﻛﻪ وﻳﮋﮔﻲﻫﺎي درﺧﺖ دودوﻳﻲ ﺟﺴﺘﺠﻮ‬
‫را ﻧﻴﺰ در ﺑﺮ دارد از )‪ O(log n‬ﺧﻮاﻫﺪ ﺑﻮد‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ در ‪ Priority Queue‬ﻳﻚ ﻋﻨﺼﺮ را ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ﺑﺎﻳﺪ از ﻳﻚ‬
‫ﻟﻴﺴﺖ اﺿﺎﻓﻪ اﺳﺘﻔﺎده ﻛﻨﻴﻢ ﻛﻪ آدرس ﻋﻨﺼﺮ در ‪ Priority Queue‬را ﺑﺮﮔﺮداﻧﺪ‪ .‬در ﻫﺮ دو داده ﺳﺎﺧﺘﺎر ﭘﻴﺪا ﻛﺮدن ﻋﻨﺼﺮي ﺑﺎ ﺑﺎﻻﺗﺮﻳﻦ‬
‫اﺣﺘﻤﺎل دوﺳﺘﻲ ﺑﺎ )‪ O(1‬اﻣﻜﺎن ﭘﺬﻳﺮ اﺳﺖ‪ ،‬و درج ﻋﻨﺼﺮ ﺟﺪﻳﺪ ﻳﺎ اﻓﺰاﻳﺶ اﺣﺘﻤﺎل دوﺳﺘﻲ ﺑﺎ )‪ O(log n‬ﻣﻤﻜﻦ ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪ .4‬از دﻳﮕﺮ ﻗﺎﺑﻠﻴﺖﻫﺎي ‪ facebook‬ﻧﻤﺎﻳﺶ ﺗﻌﺪاد دوﺳﺘﺎن ﻣﺸﺘﺮك ﺑﻴﻦ ﻫﺮ زوج ﻛﺎرﺑﺮ اﺳﺖ‪ .‬روﺷﻲ اراﺋﻪ دﻫﻴﺪ ﻛﻪ اﻳﻦ ﺳﺎﻳﺖ ﺑﺘﻮاﻧﺪ در‬
‫ﻳﻚ داده ﺳﺎﺧﺘﺎر ﻛﻪ ﺑﻪ ﻟﺤﺎظ ﺣﺎﻓﻈﻪ ﻛﺎرآﻣﺪ اﺳﺖ‪ ،‬دوﺳﺘﺎن ﻫﺮ ﻛﺎرﺑﺮ را ذﺧﻴﺮه ﺳﺎزي ﻛﻨﺪ و ﻫﺮ ﻟﺤﻈﻪ ﺑﺘﻮاﻧﺪ ﺗﻌﺪاد دوﺳﺘﺎن ﻣﺸﺘﺮك‬
‫ﻫﺮ دو ﻛﺎرﺑﺮ دﻟﺨﻮاه را اﻋﻼم ﻛﻨﺪ‪ .‬اﻳﻦ روش ﺑﺎﻳﺪ اﻳﺠﺎد ﻳﺎ ﺣﺬف ﭘﻴﻮﻧﺪﻫﺎي دوﺳﺘﻲ و اﺿﺎﻓﻪ ﻳﺎ ﻛﻢ ﺷﺪن ﻛﺎرﺑﺮان را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻛﻨﺪ‪ .‬روش‬
‫ﺧﻮد را ﺑﻪ ﺻﻮرت ﻛﺎﻣﻞ ﺑﻪ ﻟﺤﺎظ زﻣﺎن و ﺣﺎﻓﻈﻪ ﺗﺤﻠﻴﻞ ﻛﻨﻴﺪ‪.‬‬
‫اﺑﺘﺪا ﺑﺎﻳﺪ دﻗﺖ ﻛﻨﻴﻢ ﻛﻪ اﺣﺘﻤﺎﻻ ﺗﻌﺪاد دﻓﻌﺎﺗﻲ ﻛﻪ ﺑﺮاي ﻳﻚ ﻛﺎرﺑﺮ دوﺳﺖ ﺟﺪﻳﺪ اﺿﺎﻓﻪ ﻳﺎ از دوﺳﺘﺎن وي ﻛﻢ ﻣﻲﺷﻮد ﺑﺴﻴﺎر ﻛﻤﺘﺮ از ﺗﻌﺪاد‬
‫ﭘﺮﺳﺸﻬﺎ در ﻣﻮرد دوﺳﺘﺎن ﻣﺸﺘﺮك وي ﺑﺎ ﻳﻚ ﻛﺎرﺑﺮ دﻳﮕﺮ رخ ﻣﻲدﻫﺪ‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﻬﺘﺮ اﺳﺖ ﻛﻪ ﺗﻤﺮﻛﺰ ﻣﺎ ﻃﺮاﺣﻲ داده ﺳﺎﺧﺘﺎري ﺑﺎﺷﺪ ﻛﻪ‬
‫ﺑﺘﻮاﻧﺪ ﭘﺮﺳﺶ در ﻣﻮرد دوﺳﺘﺎن ﻣﺸﺘﺮك دو ﻛﺎرﺑﺮ را ﺑﻪ ﻧﺤﻮ ﺑﻬﻴﻨﻪاي ﭘﺎﺳﺦ ﮔﻮﻳﺪ‪ .‬ﻳﻚ راه ﺳﺎده ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﻓﺮاﻳﻨﺪ آن اﺳﺖ ﻛﻪ ﺑﺮاي ﻫﺮ‬
‫ﻛﺎرﺑﺮ‪ ،‬ﻓﻬﺮﺳﺖ دوﺳﺘﺎﻧﺶ ﺑﻪ ﺻﻮرت ﻳﻚ ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي ذﺧﻴﺮه ﺷﻮد‪ ،‬اﻟﺒﺘﻪ ﻫﻤﻮاره اﻳﻦ ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي را ﺑﻪ ﺻﻮرت ﻣﺮﺗﺐ ﻧﮕﻬﺪاري ﻣﻴﻜﻨﻴﻢ‪.‬‬
‫اﮔﺮ ﺗﻌﺪاد دوﺳﺘﺎن ﻳﻚ ﻛﺎرﺑﺮ ‪ n‬ﻧﻔﺮ ﺑﺎﺷﺪ‪ ،‬اﻓﺰودن ﻳﺎ ﺣﺬف ﭘﻴﻮﻧﺪ دوﺳﺘﻲ ﺑﺮاي وي )‪ O(n‬ﺑﻪ ﻃﻮل ﺧﻮاﻫﺪ اﻧﺠﺎﻣﻴﺪ‪ .‬ﺣﺎل اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﺗﻌﺪاد‬
‫دوﺳﺘﺎن ﻣﺸﺘﺮك دو ﻛﺎرﺑﺮ را ﭘﻴﺪا ﻛﻨﻴﻢ ﻛﺎﻓﻲ اﺳﺖ ﻣﺎﻧﻨﺪ ‪ ،Merge Sort‬ﻓﻬﺮﺳﺖ دوﺳﺘﺎن آن دو را ﺑﺎ )‪ O(n‬ادﻏﺎم ﻛﻨﻴﻢ و ﺗﻤﺎم اﻓﺮاد‬
‫ﺗﻜﺮاري در اﻳﻦ ادﻏﺎم را ﺑﻪ ﻋﻨﻮان دوﺳﺖ ﻣﺸﺘﺮك اﻋﻼم ﻛﻨﻴﻢ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ اﻧﺠﺎم اﻳﻦ ﻓﺮاﻳﻨﺪ ﻛﺎرآﻣﺪ ﺧﻮاﻫﺪ ﺑﻮد‪ .‬ﺑﺮاي ﺑﻬﺒﻮد زﻣﺎن ﺣﺬف ﻳﺎ‬
‫درج دوﺳﺘﺎن ﻛﺎرﺑﺮ‪ ،‬ﻣﻲﺗﻮاﻧﻴﻢ ﺑﻪ ﺟﺎي اﺳﺘﻔﺎده از ﻟﻴﺴﺖ ﭘﻴﻮﻧﺪي‪ ،‬از درﺧﺖ ﻗﺮﻣﺰ‪-‬ﺳﻴﺎه ﻛﻤﻚ ﺑﮕﻴﺮﻳﻢ‪ .‬در اﻳﻦ ﺻﻮرت درج و ﺣﺬف ﭘﻴﻮﻧﺪﻫﺎي‬
‫دوﺳﺘﻲ از )‪ O(log n‬زﻣﺎن ﻣﻲﺑﺮد‪ ،‬و ﺑﺎزﻫﻢ ﻣﻲﺗﻮاﻧﻴﻢ ﺑﺎ ﭘﻴﻤﺎﻳﺶ ‪ In-Order‬درﺧﺖ‪ ،‬ﻟﻴﺴﺖ ﻣﺮﺗﺐ ﺷﺪهي دوﺳﺘﺎن ﻫﺮ ﻛﺎرﺑﺮ را ﺑﺮاي ﻋﻤﻞ‬
‫ادﻏﺎم داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪.‬‬
‫»ﻫﻤﭽﻮن ﺳﭙﻴﺪار‪ ،‬ﺳﺒﺰ و ﺳﺮﻓﺮاز ﺑﺎﺷﻴﺪ«‬