جاوا ڊولپر پوزيشن لاءِ نوڪري جي انٽرويو کان سوالن ۽ جوابن جي ڳولا. حصو 9

هڪ پروگرامر هجڻ آسان ناهي. اتي هميشه ڪجهه نئين سکڻ لاء آهي. ۽، جيئن ڪنهن ٻئي ڪوشش ۾، سڀ کان ڏکيو ڪم شروع ڪرڻ آهي، پنهنجي مقصد ڏانهن پهريون قدم کڻڻ. پر جيئن ته توهان هتي آهيو ۽ هي مضمون پڙهي رهيا آهيو، توهان پهريون قدم مڪمل ڪيو آهي. هن جو مطلب اهو آهي ته هاڻي توهان کي عمدي طور تي پنهنجي مقصد ڏانهن وڌڻ جي ضرورت آهي، بغير سست ٿيڻ يا پاسي کان پري ٿيڻ جي. مان سمجهان ٿو ته توهان جو مقصد هڪ جاوا ڊولپر بڻجڻ آهي يا توهان جي ڄاڻ کي وڌايو جيڪڏهن توهان اڳ ۾ ئي هڪ ڊولپر آهيو. جيڪڏهن ائين آهي، اچو ته جاوا ڊولپر انٽرويو سوالن جي هڪ وسيع فهرست کي حل ڪرڻ جاري رکون. اچو ته جاري رکون!

مجموعو

84. اسان کي ٻڌاءِ اِيٽرٽرز بابت ۽ اُھي ڪھڙيءَ ريت استعمال ٿين ٿا

جاوا ڊولپر جي ڪنهن به انٽرويو ۾ مجموعا هڪ پسنديده موضوع آهي. جڏهن گڏ ڪرڻ واري ترتيب بابت سوالن جا جواب ڏين ٿا، اميدوار اڪثر چون ٿا ته اهو گڏ ڪرڻ واري انٽرفيس سان شروع ٿئي ٿو. پر ائين ناهي. ھڪڙو ٻيو انٽرفيس آھي ھڪڙي سطح مٿان: Iterable . هي انٽرفيس iterator() طريقو تي مشتمل آهي، جيڪو توهان کي موجوده ڪليڪشن لاءِ Iterator اعتراض تائين رسائي ڏئي ٿو. ۽ ڇا واقعي هن Iterator اعتراض آهي؟ Iterator اعتراض هڪ مجموعو ذريعي منتقل ڪرڻ جي صلاحيت فراهم ڪري ٿو ۽ ان جي عناصر تي ٻيهر ورجائي ٿو، ۽ استعمال ڪندڙ کي گڏ ڪرڻ جي مخصوص عمل درآمد جي تفصيل کي ڄاڻڻ جي ضرورت ناهي . ٻين لفظن ۾، اھو ھڪڙي قسم جو اشارو آھي مجموعي جي عناصر ڏانھن، ڄڻڪ اھو انھن مان ھڪڙي اندر اندر جھلي رھيو آھي. آئٽرٽر جا طريقا آھن جھڙوڪ:

• hasNext() — واپسي صحيح آھي جيڪڏھن iteration ۾ ڪو ٻيو عنصر ھجي (ھي طريقو توھان کي ٻڌائي ٿو ته جڏھن توھان مجموعي جي پڄاڻي تي پھچي ويا آھيو)؛

• next() - ورجائي ۾ ايندڙ شيون واپس آڻيندو. جيڪڏهن ڪو نه آهي، ته پوء هڪ NoSuchElementException اڇلايو ويو آهي. ان جو مطلب اهو آهي ته توهان هن طريقي کي استعمال ڪرڻ کان اڳ، اهو بهترين آهي hasNext() طريقو استعمال ڪرڻ لاء يقيني بڻائڻ لاء ايندڙ عنصر موجود آهي؛

• هٽايو () - ايندڙ () طريقو استعمال ڪندي حاصل ڪيل آخري عنصر کي گڏ ڪرڻ مان هٽائي ٿو . جيڪڏهن next() کي ڪڏهن به نه سڏيو ويو آهي، ته پوءِ ڪال ڪرڻ سان remove() هڪ غير قانوني اسٽيٽ ايڪسيپشن اڇلايو ويندو؛

• forEachRemaining(<Consumer>) — جمع جي هر عنصر تي منظور ٿيل عمل تي عمل ڪري ٿو (اهو طريقو جاوا 8 ۾ ظاهر ٿيو).

هتي هڪ فهرست جي ذريعي ٻيهر ورجائڻ جو هڪ ننڍڙو مثال آهي ۽ ان جي سڀني عناصر کي هٽائڻ واري مختلف طريقن جي طريقن کي استعمال ڪندي اسان ڏٺو آهي:

List<String> list = new ArrayList<>();
list.add("Hello ");
list.add("World, ");
list.add("It's ");
list.add("Amigo!");
Iterator iterator = list.iterator();

while(iterator.hasNext()) {
   iterator.next();
   iterator.remove();
}
System.out.println(list.size());

ڪنسول ھيٺ ڏنل ڏيکاريندو: هن جو مطلب آهي ته عناصر ڪاميابي سان هٽايو ويو. هڪ دفعو توهان هڪ آئٽرٽر حاصل ڪيو، توهان اسڪرين تي سڀني عناصر کي ڊسپلي ڪرڻ لاء هڪ طريقو استعمال ڪري سگهو ٿا:

iterator.forEachRemaining(x -> System.out.print(x));

پر هڪ دفعو اسان اهو ڪريون ٿا، ٻيهر استعمال ڪندڙ وڌيڪ استعمال لاءِ نا مناسب ٿي وڃي ٿو: اهو سڄي لسٽ کي پار ڪري چڪو آهي، ۽ هڪ عام ٽريٽر وٽ پوئتي موٽڻ لاءِ ڪو به طريقو ناهي. ۽ اهو هڪ سٺو سيگ ٺاهيندو آهي LinkedList جي بحث ۾ ، خاص طور تي، ان جو listIterator() طريقو، جيڪو موٽائي ٿو هڪ وڌايل قسم جي iterator: ListIterator . هڪ باقاعده (معياري) جي طريقن جي اضافي ۾، هن قسم جا هيٺيان آهن:

• add(<Element>) - لسٽ ۾ نئون عنصر شامل ڪري ٿو؛

• hasPrevious() - واپسي صحيح آھي جيڪڏھن ڪو عنصر موجود آھي ايندڙ عنصر کان اڳ (جيڪڏھن ڪو اڳوڻو عنصر آھي)؛

• nextIndex() - ايندڙ عنصر جي انڊيڪس واپسي؛

• اڳوڻو () - پوئين عنصر کي واپس ڏئي ٿو (ايندڙ عنصر کان اڳ)؛

• اڳوڻو انڊيڪس پوئين عنصر جي انڊيڪس کي واپس ڪري ٿو.

• set(<Element>) - ايندڙ () يا پوئين () پاران موٽايل آخري عنصر کي تبديل ڪري ٿو .

جئين توهان ڏسي سگهو ٿا، هي آئٽرٽر تمام گهڻو دلچسپ ڪارڪردگي آهي: اهو توهان کي ٻنهي طرفن ۾ هلڻ جي اجازت ڏئي ٿو ۽ عناصر سان ڪم ڪرڻ دوران ڪافي آزادي مهيا ڪري ٿي. توهان کي اهو به ڄاڻڻ گهرجي ته جڏهن ماڻهو ڳالهائيندڙن جي باري ۾ ڳالهائيندا آهن، انهن جو مطلب ڪڏهن ڪڏهن ڊزائن جو نمونو آهي.

85. جاوا ڪليڪشن فريم ورڪ ۾ ڪهڙي ڪليڪشن جو درجو موجود آهي؟

جاوا ۾ ٻه مجموعا hierarchies آهن. پهريون درجو آهي مجموعو hierarchy، جنهن جي جوڙجڪ هيٺ ڏنل آهي: اهو هيٺين ذيلي مجموعن ۾ ورهايل آهي:

• سيٽ هڪ انٽرفيس آهي جيڪو بيان ڪري ٿو هڪ سيٽ، هڪ ڊيٽا جي جوڙجڪ جنهن ۾ غير ترتيب ڏنل منفرد (غير ورجائيندڙ) عناصر شامل آهن. ھن انٽرفيس ۾ ڪجھ معياري عمل آھن: TreeSet ، HashSet ، ۽ LinkedHashSet .

• لسٽ هڪ انٽرفيس آهي جيڪو ڊيٽا جي جوڙجڪ کي بيان ڪري ٿو جيڪو شين جي ترتيب ڏنل ترتيب کي محفوظ ڪري ٿو. ھڪڙي لسٽ ۾ شيون داخل ڪري سگھجن ٿيون ۽ لسٽ ۾ انھن جي انڊيڪس ذريعي ختم ڪري سگھجن ٿيون (جهڙوڪ ھڪڙي صف، پر متحرڪ ريزائزنگ سان). ھن انٽرفيس ۾ ڪجھ معياري لاڳو آھن: ArrayList , Vector ( deprecated and not actually use )، ۽ LinkedList .

• قطار هڪ انٽرفيس آهي جيڪو ڊيٽا جي جوڙجڪ کي بيان ڪري ٿو جيڪو شيون ذخيرو ڪري ٿو فرسٽ ان فرسٽ آئوٽ (FIFO) قطار ۾. ھن انٽرفيس ۾ ھيٺ ڏنل معياري عمل آھن: LinkedList (اھو صحيح آھي، اھو پڻ لاڳو ڪري ٿو قطار ) ۽ PriotityQueue .

ٻئين مجموعن جو درجو آھي Map hierarchy، جنھن جو ھيٺيون ڍانچو آھي: ھن مجموعن جي درجي بندي کي ذيلي مجموعن ۾ ڪو به ڀاڱو نه آھي (ڇاڪاڻ ته نقشي جو درجو پاڻ ھڪڙو ذيلي مجموعو آھي جيڪو پاڻ کان الڳ آھي). معياري نقشي تي عملدرآمد Hashtable (منسوخ ٿيل)، LinkedHashMap ، ۽ TreeMap آھن . عملي طور تي، جڏهن ماڻهو مجموعن جي باري ۾ پڇن ٿا ، انهن جو مطلب عام طور تي ٻنهي درجي بندين جو آهي.

86. ArrayList جي اندروني جوڙجڪ ڇا آهي؟

هڪ ArrayList هڪ صف وانگر آهي، پر اهو متحرڪ طور تي وڌائي سگھي ٿو. هن جو مطلب ڇا آهي؟ هود جي تحت، ArrayList هڪ عام صف استعمال ڪري ٿو، يعني اهو پنهنجي عناصر کي اندروني صف ۾ محفوظ ڪري ٿو جنهن جي ڊفالٽ سائيز 10 سيلز آهي. هڪ دفعو اندروني صف مڪمل آهي، هڪ نئين صف ٺاهي وئي آهي. نئين صف جي سائيز هن فارمولا طرفان طئي ڪئي وئي آهي:

<size of the current array> * 3 / 2 + 1

تنهن ڪري، جيڪڏهن اسان جي صف جي سائيز 10 آهي، ته پوء نئين جي سائيز هوندي: 10 * 3 / 2 + 1 = 16. پوء اصل (پراڻي) صف مان سڀئي قيمتون ان ۾ نقل ڪيون وينديون بلٽ ان استعمال ڪندي. System.arraycopy() طريقو، ۽ اصل صف ختم ٿي وئي آهي. مختصر طور تي، اهو ڪيئن آهي ArrayList متحرڪ ريزيزنگ کي لاڳو ڪري ٿو. اچو ته سڀ کان مشهور ArrayList طريقن تي غور ڪريون: 1. add(<Element>) — هڪ عنصر شامل ڪري ٿو صف جي آخر ۾ (آخري خالي سيل ۾)، پهرين چيڪ ڪرڻ کان پوءِ ته ڇا صف ۾ موجود سيل موجود آهي. جيڪڏهن نه، هڪ نئين صف ٺاهي وئي آهي، ۽ عناصر ان ۾ نقل ڪيا ويا آهن. هن آپريشن جي وقت جي پيچيدگي O (1) آهي. اتي ھڪڙو ساڳيو اضافو (<Index>، <Element>) طريقو آھي. اهو هڪ عنصر شامل ڪري ٿو فهرست جي آخر ۾ نه (سري)، پر مخصوص سيل ڏانهن اشارو ڪيو ويو آهي انڊيڪس طرفان جيڪو هڪ دليل طور آيو آهي. انهي صورت ۾، وقت جي پيچيدگي مختلف ٿي ويندي ان جي بنياد تي جتي توهان شامل ڪيو ٿا:

• جيڪڏهن اضافو فهرست جي شروعات جي ويجهو آهي، پوء وقت جي پيچيدگي O (N) جي ويجهو هوندي، ڇاڪاڻ ته نئين جي ساڄي پاسي واقع سڀني عنصرن کي هڪ سيل کي ساڄي طرف منتقل ڪرڻو پوندو؛
• جيڪڏهن عنصر وچ ۾ داخل ڪيو ويو آهي، پوء اهو ٿيندو O (N/2)، ڇو ته اسان کي صرف فهرست جي اڌ شيون هڪ سيل کي ساڄي طرف منتقل ڪرڻ جي ضرورت آهي.

اھو آھي، ھن طريقي جي وقت جي پيچيدگي جي حد O (1) کان O (N) تائين آھي، ان تي منحصر آھي جتي عنصر داخل ڪيو ويو آھي. 2. سيٽ (<Index>, <Element>) - هڪ عنصر کي لسٽ ۾ مخصوص پوزيشن ڏانهن لکندو آهي. جيڪڏهن هڪ عنصر اڳ ۾ ئي موجود آهي انهي پوزيشن تي، طريقو ان کي ختم ڪري ٿو. هن آپريشن جي وقت جي پيچيدگي O(1) آهي، ڇاڪاڻ ته ان ۾ ڪا به شفٽ آپريشن شامل نه آهي: اسان صرف انڊيڪس استعمال ڪريون ٿا سيل جي ايڊريس کي ڳڻڻ لاءِ صف ۾، جنهن جي پيچيدگي O(1) آهي، ۽ پوءِ نئون عنصر لکو. . 3. هٽايو (<index>) - هڪ عنصر کي هٽائي ٿو ان جي انڊيڪس ذريعي اندروني صف ۾. جڏهن هڪ شيءِ کي هٽايو وڃي جيڪا فهرست جي آخر ۾ نه هجي، سڀ شيون ختم ٿيل جي ساڄي طرف هڪ سيل کي کاٻي طرف منتقل ڪيو وڃي ته جيئن حذف ٿيڻ جي نتيجي ۾ خال کي بند ڪيو وڃي. ان جي مطابق، وقت جي پيچيدگي ساڳي ٿي ويندي جيڪا اضافو (<Index>، <Element>) لاء آهي جڏهن هڪ عنصر وچ ۾ شامل ڪيو ويندو آهي: O(N/2). سڀ کان پوء، توهان کي عناصر جي اڌ کي هڪ سيل کي کاٻي پاسي منتقل ڪرڻ جي ضرورت آهي. ۽ جيڪڏهن اسان شروعات جي باري ۾ ڳالهائي رهيا آهيون، پوء O (N). يا جيڪڏهن آخر ۾، پوء اي (1)، ڇو ته توهان کي ڪجهه به منتقل ڪرڻ جي ضرورت ناهي.

87. LinkedList جي اندروني جوڙجڪ ڇا آهي؟

هڪ ArrayList اندروني صف ۾ عناصر تي مشتمل آهي، پر هڪ LinkedList انهن کي ٻيڻو ڳنڍيل فهرست ۾ محفوظ ڪري ٿو. هن جو مطلب اهو آهي ته هر عنصر ۾ هڪ لنڪ شامل آهي پوئين عنصر ۽ ايندڙ عنصر ڏانهن . پهريون عنصر پوئين عنصر سان ڳنڍيل نه آهي (آخرڪار، اهو پهريون آهي). اهو پڻ سمجهيو ويندو آهي فهرست جو سر، ۽ LinkedList اعتراض ان ڏانهن سڌو حوالو آهي. اهڙي طرح، آخري عنصر ۾ ايندڙ عنصر نه آهي، ڇاڪاڻ ته اهو فهرست جي دم آهي. LinkedList اعتراض پڻ سڌو سنئون حوالو ڏئي ٿو . هن جو مطلب آهي ته فهرست جي سر يا دم تائين رسائي جي وقت جي پيچيدگي O (1) آهي. ArrayList ۾ ، جيڪڏهن فهرست وڌندي، پوء اندروني صف وڌندي. هتي سڀ ڪجهه آسان آهي: هڪ حوالو شامل ڪرڻ آسان آهي جيئن ڪجهه لنڪ تبديل ڪرڻ. اچو ته ڏسو ڪجھ سڀ کان وڌيڪ استعمال ٿيل LinkedList طريقن: 1. add(<Element>) - فهرست جي آخر ۾ هڪ عنصر شامل ڪري ٿو، يعني آخري عنصر (5) کان پوءِ، نئين عنصر جي لنڪ شامل ڪئي ويندي . نئين عنصر ۾ اڳوڻو حوالو عنصر ڏانهن اشارو ڪندو (5) جيڪو هاڻي ان کان اڳ لسٽ ۾ آهي. هن آپريشن جي وقت جي پيچيدگي O(1) آهي، ڇاڪاڻ ته اسان کي صرف آخري عنصر سان ڳنڍڻ جي ضرورت آهي، ۽ جيئن توهان کي ياد هوندو، LinkedList شئي جو سڌو حوالو آهي دم ڏانهن، ۽ ان تائين رسائي گهٽ ۾ گهٽ مسلسل وقت جي پيچيدگي آهي. 2. add(<Index>, <Element>) - انڊيڪس ذريعي هڪ عنصر شامل ڪري ٿو. جڏهن هڪ عنصر شامل ڪيو وڃي، اچو ته چوندا آهن، فهرست جي وچ ۾، هي طريقو پهريون ڀيرو سر ۽ دم کان عناصر مٿان (ٻنهي طرفن تي) تيستائين ورجائي ٿو جيستائين گهربل جڳهه نه ملي. جيڪڏهن اسان ٽئين ۽ چوٿين عنصر جي وچ ۾ هڪ عنصر شامل ڪيو (مٿي ڏنل تصوير ۾)، پوء ٽئين عنصر جي ايندڙ لنڪ نئين عنصر ڏانهن اشارو ڪندي. ۽ نئين شامل ڪيل عنصر جي پوئين ٽئين ھڪڙي ڏانھن اشارو ڪندي. موڙ ۾، پراڻي چوٿين عنصر جي پوئين لنڪ هاڻي نئين عنصر ڏانهن اشارو ڪندي، ۽ نئين عنصر جي ايندڙ لنڪ نئين چوٿين عنصر ڏانهن اشارو ڪندي: هن طريقي جي وقت جي پيچيدگي نئين عنصر جي انڊيڪس تي منحصر آهي:

• جيڪڏهن اهو سر يا دم جي ويجهو آهي، آپريشن O (1) جي ويجهو هوندو، ڇاڪاڻ ته اهو اصل ۾ عناصرن کي ٻيهر ڏيڻ جي ضرورت نه هوندي؛
• جيڪڏهن اهو وچ جي ويجهو آهي ته پوءِ اسان وٽ O(N/2) هوندو، ڇاڪاڻ ته طريقو هڪ ئي وقت سر ۽ دم مان ڳوليندو جيستائين گهربل عنصر نه ملي.

3. سيٽ (<Index>, <Element>) - هڪ عنصر کي لسٽ ۾ مخصوص پوزيشن ڏانهن لکندو آهي. هن آپريشن جي وقت جي پيچيدگي O(1) کان O(N/2) تائين هوندي، وري ان تي منحصر آهي ته نئون عنصر سر، دم، يا وچ ۾ ڪيترو ويجهو آهي. 4. Remove(<index>) — هڪ عنصر کي لسٽ مان هٽائي ان کي ٺاهي ٿو ته جيئن حذف ٿيل هڪ ( اڳوڻي ) کان اڳ وارو عنصر هاڻي حذف ٿيل هڪ ( اڳيون ) کان پوءِ عنصر ڏانهن اشارو ڪري . ۽ ان جي برعڪس، يعني حذف ٿيل هڪ کان پوءِ عنصر هاڻي حذف ٿيل هڪ کان اڳ واري ڏانهن اشارو ڪري ٿو: اهو عمل انڊيڪس ( add(<Index>, <Element>) ) شامل ڪرڻ جي برعڪس آهي .

88. HashMap جي اندروني جوڙجڪ ڇا آهي؟

اهو ٿي سگهي ٿو جاوا ڊولپر اميدوارن کان پڇڻ لاءِ سڀ کان مشهور انٽرويو سوالن مان. هڪ HashMap اهم-قدر جوڑوں سان ڪم ڪري ٿو . اهي پاڻ HashMap اندر ڪيئن محفوظ ڪيا ويا آهن ؟ HashMap ۾ نوڊس جي اندروني صف آھي:

Node<K,V>[] table

ڊفالٽ طور، صف جي سائيز 16 آهي، ۽ اهو هر وقت ٻيڻو ٿي ويندو آهي جڏهن اهو عناصر سان ڀريو ويندو آهي (اهو آهي، جڏهن LOAD_FACTOR پهچي ويندو آهي؛ اهو حد بيان ڪري ٿو ته ڪيئن مڪمل ٿي سگهي ٿو صف حاصل ڪري سگھي ٿو - ڊفالٽ طور، اهو 0.75 آهي ) . هر نوڊس کي ذخيرو ڪري ٿو هڪ هيش، ڪي، هڪ قدر، ۽ ايندڙ عنصر ڏانهن هڪ حوالو: هن صورت ۾، "ايندڙ عنصر ڏانهن حوالو" جو مطلب آهي ته اسان هڪ اڪيلو ڳنڍيل فهرست سان معاملو ڪري رهيا آهيون، جتي هر عنصر ۾ ايندڙ جي لنڪ شامل آهي. ٻين لفظن ۾، هڪ HashMap ان جي ڊيٽا کي اڪيلو سان ڳنڍيل فهرستن جي هڪ صف ۾ محفوظ ڪري ٿو. پر مون کي فوري طور تي چوڻ ڏيو ته جڏهن ٽيبل جي هڪ سيل ۾ هڪ اڪيلو ڳنڍيل فهرست آهي جيڪا هڪ کان وڌيڪ عنصرن تي مشتمل آهي، اهو سٺو ناهي. هن رجحان کي تصادم سڏيو ويندو آهي . پر پهرين شيون پهرين. اچو ته ڏسو ته ڪيئن هڪ نئون جوڙو محفوظ ڪيو ويو آهي put method استعمال ڪندي. پهريون، طريقو حاصل ڪري ٿو چاٻي جي hashCode() . انهي جو مطلب اهو آهي ته HashMap صحيح طريقي سان ڪم ڪرڻ لاءِ ، جيڪي توهان استعمال ڪندا آهيو اهي ڪلاس هجڻ گهرجن جيڪي هن طريقي کي اوور رائڊ ڪن. هي هيش ڪوڊ پوءِ استعمال ڪيو ويندو آهي اندروني hash() طريقي سان ٽيبل صف ۾ ڪجهه سيل جي انڊيڪس کي طئي ڪرڻ لاءِ. نتيجو ڪندڙ انڊيڪس اسان کي ٽيبل صف جي مخصوص سيل تائين رسائي جي اجازت ڏئي ٿو. اسان وٽ هتي ٻه ڪيس آهن:

1. سيل خالي آھي - ھن صورت ۾، نئين نوڊ قدر ان ۾ ذخيرو ٿيل آھي.
2. سيل خالي نه آهي - انهي صورت ۾، ڪنجين جي قيمتن جي مقابلي ۾ آهن. جيڪڏهن اهي برابر آهن، ته پوء نئين نوڊ قدر پراڻي هڪ مٿان لکندو آهي؛ جيڪڏهن برابر نه آهي، ته پوءِ ايندڙ تائين پهچبو آهي، ۽ ان جي ڪيئي جو مقابلو ڪيو ويندو آهي... ۽ ائين ئي، جيستائين نئين قيمت يا ته ڪجهه پراڻي قيمت کي ختم ڪري ڇڏي يا اسان اڪيلو ڳنڍيل فهرست جي آخر تائين پهچي وڃون ٿا ۽ پوءِ نئين قيمت کي اتي محفوظ ڪريون ٿا. آخري عنصر.

جڏهن هڪ عنصر کي چاٻي جي ذريعي ڳولهيو (استعمال ڪيو (<key>) طريقو استعمال ڪندي، چاٻي جي hashCode() کي ڳڻيو ويندو آهي، ۽ پوء ان جي انڊيڪس جي اندر اندر حساب ڪيو ويندو آهي hash() استعمال ڪندي . نتيجو وارو نمبر ٽيبل جي صف ۾ سيل جي انڊيڪس آهي ، جنهن کي اسين پوءِ ڳولهيندا آهيون نوڊس تي ٻيهر ورجائيندي ۽ گهربل نوڊ جي ڪيئي کي موجوده نوڊ جي ڪنجي سان موازنہ ڪندي. مثالي طور، نقشي جي عملن ۾ O(1) جي الگورتھمڪ پيچيدگي آهي، ڇاڪاڻ ته اسان هڪ صف تائين رسائي ڪري رهيا آهيون، ۽، جيئن توهان کي ياد هوندو، O (1) آهي، قطع نظر ان ۾ عناصر جي تعداد جي. پر اسان مثالي ڪيس سان معاملو نه ڪري رهيا آهيون. جڏهن سيل خالي نه آهي (2) ۽ اڳ ۾ ئي ڪجهه نوڊس کي ذخيرو ڪري ٿو، ته پوء الورورٿمڪ پيچيدگي O (N) (لڪير) ٿي وڃي ٿي، ڇاڪاڻ ته هاڻي ضروري آهي ته اسان کي درست جڳهه ڳولڻ کان اڳ عناصر تي ٻيهر ورجائي. مان مدد نه ٿو ڪري سگهان پر اهو ذڪر ڪري سگهان ٿو ته جاوا 8 ۾ شروع ٿئي ٿو، جيڪڏهن هڪ نوڊ جي صورت ۾ هڪ اڪيلو ڳنڍيل لسٽ ۾ 8 عنصرن کان وڌيڪ (ٽڪر) آهن، پوء اهو هڪ بائنري وڻ ۾ تبديل ٿي ويندو. انهي صورت ۾، الورورٿمڪ پيچيدگي هاڻي O (N) نه آهي، پر O (log (N)) - ۽ اهو هڪ ٻيو معاملو آهي، ڇا اهو ناهي؟ HashMap ھڪڙو وڏو موضوع آھي، ۽ ماڻھو پسند ڪن ٿا ان بابت سوال پڇڻ لاءِ نوڪريءَ جي انٽرويو ۾. تنهن ڪري، مان مشورو ڏيان ٿو ته توهان ڄاڻو ٿا ته توهان جي هٿ جي پوئتي وانگر. ذاتي طور تي، مون ڪڏهن به هڪ انٽرويو نه ڪيو آهي جنهن ۾ HashMap تي سوال شامل نه آهن . اهو سڀ ڪجهه اڄ لاءِ آهي. جاري رکڻ گهرجي...