CodeGym /جاوا بلاگ /Random-SD /Java LinkedList
John Squirrels
سطح
San Francisco

Java LinkedList

گروپ ۾ شايع ٿيل
سلام سڀ جديد سبق وقف ڪيا ويا آهن ArrayList . هن ڊيٽا جي جوڙجڪ تمام آسان ۽ مفيد آهي. اھو گھڻن ڪمن کي سنڀالي سگھي ٿو. پر جاوا وٽ ڪيتريون ئي ٻيون ڊيٽا جي جوڙجڪ آهن. ڇو؟ سڀ کان وڌيڪ، ڇاڪاڻ ته ڪمن جي حد تمام وڏي آهي، ۽ سڀ کان وڌيڪ موثر ڊيٽا جي جوڙجڪ مختلف ڪمن لاء مختلف آهن. اڄ اسان هڪ نئين جوڙجڪ سان ملنداسين: Java LinkedList ، هڪ ٻيڻو ڳنڍيل فهرست.
ڳنڍيل لسٽ - 1
اچو ته ڏسون ته اهو ڪيئن منظم آهي، ڇو ان کي ڊبل-لنڪڊ سڏيو ويندو آهي، اهو ڪيئن مختلف آهي ArrayList کان . جاوا LinkedList ۾ عناصر اصل ۾ ھڪڙي زنجير ۾ ڳنڍيل آھن. ڊيٽا جي اضافي ۾، هر عنصر اڳوڻو ۽ ايندڙ عناصر جي حوالي سان ذخيرو ڪري ٿو. اهي حوالا توهان کي هڪ عنصر کان ٻئي ڏانهن منتقل ڪرڻ جي اجازت ڏين ٿا. ھي آھي توھان ڪيئن ٺاھيو ھڪڙو:
public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str2);
       earlBio.add(str3);
       earlBio.add(str4);

       System.out.println(earlBio);

   }
}
ٻاھر نڪتو: [هيلو دنيا! منهنجو نالو ارل آهي، مون کي جاوا سان پيار آهي، مان ڪئناڊا ۾ رهندو آهيان] هتي اسان جي لسٽ وانگر ڏسڻ ۾ اچي ٿي: ڳنڍيل لسٽ - 2 اچو ته ڏسو ته هڪ نئون عنصر ڪيئن شامل ڪجي. اهو استعمال ڪيو ويندو آهي add() طريقو.
earlBio.add(str2);
ڪوڊ ۾ پوائنٽ تي، اسان جي لسٽ ھڪڙي عنصر تي مشتمل آھي: String str1 . اچو ته ڏسو ته تصوير ۾ اڳتي ڇا ٿئي ٿو: ڳنڍيل لسٽ - 3 نتيجي طور، str2 ۽ str1 لسٽ جي هن نوڊس ۾ محفوظ ڪيل ايندڙ ۽ پوئين لنڪ ذريعي ڳنڍجي ويا : ڳنڍيل لسٽ - 4 هاڻي توهان کي ٻه ڀيرا ڳنڍيل فهرست جي بنيادي خيال کي سمجهڻ گهرجي. لنڪس جو هي سلسلو خاص طور تي آهي جيڪو LinkedList عناصر کي هڪ واحد فهرست ٺاهي ٿو. ArrayList جي برعڪس ، LinkedList ۾ ڪا به صف يا ڪا به شيءِ نه هوندي آهي جيئن اندر هجي. ArrayList سان ڪو به (سٺو، گھڻا) ڪم اندروني صف سان ڪم ڪرڻ لاء ھيٺ لھي ٿو. جاوا LinkedList سان ڪو به ڪم لنڪن کي تبديل ڪرڻ لاء ھيٺ لھي ٿو. هي فهرست جي وچ ۾ هڪ عنصر شامل ڪندي تمام واضح طور تي ڏسي سگھجي ٿو:
public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       System.out.println(earlBio);

   }
}
جئين توهان ڏسي سگهو ٿا، اوورلوڊ ٿيل اضافو () طريقو توهان کي نئين شيء لاء مخصوص انڊيڪس بيان ڪرڻ جي اجازت ڏئي ٿو. هن حالت ۾، اسان str1 ۽ str3 جي وچ ۾ String str2 شامل ڪرڻ چاهيون ٿا . اھو اھو آھي جيڪو اندروني طور تي ٿيندو: اندروني لنڪ تبديل ڪرڻ کان پوء، str2 ڪاميابيء سان لسٽ ۾ شامل ڪيو ويو آھي: ھاڻي سڀ 3 عناصر ڳنڍيل آھن. توھان منتقل ڪري سگھوٿا ايندڙ لنڪ ذريعي زنجير تي پھرين عنصر کان آخري ۽ واپس وري. تنهن ڪري، اسان داخل ڪرڻ سان ڪافي آرام سان آهيون، پر عناصر کي ختم ڪرڻ بابت ڇا؟ اصول بلڪل ساڳيو آهي. اسان صرف ٻن عنصرن ۾ لنڪس کي اپڊيٽ ڪندا آهيون "کاٻي ۽ ساڄي طرف" عنصر جي هٽايو پيو وڃي: ڳنڍيل لسٽ - 5ڳنڍيل لسٽ - 6
public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       earlBio.remove(1);
       System.out.println(earlBio);
   }
}
هتي ڇا ٿيندو جيڪڏهن اسان انڊيڪس 1 سان شيءِ کي حذف ڪريون (اها فهرست جي وچ ۾ آهي): ڳنڍيل لسٽ - 7 لنڪس کي اپڊيٽ ڪرڻ کان پوءِ، اسان کي گهربل نتيجو ملندو: ArrayListڳنڍيل لسٽ - 8 ۾ هٽائڻ واري عمل جي برعڪس ، هتي صفن جي عناصر کي منتقل ڪرڻ يا ڪرڻ جي ڪا ضرورت ناهي. ڪنهن به قسم جي. اسان صرف str1 ۽ str3 لاءِ لنڪس تازه ڪاري ڪندا آهيون . اھي ھاڻي ھڪٻئي ڏانھن اشارو ڪن ٿا، ۽ str2 ڳنڍين جي زنجير مان ” ڇڏيو “ آھي ۽ ھاڻي لسٽ جو حصو ناھي.

طريقن جو جائزو

LinkedList وٽ ڪيترائي طريقا آھن عام آھن ArrayList سان . مثال طور، ٻنهي طبقن جا طريقا آهن جهڙوڪ add() , remove() , indexOf() , clear() , contains() (ظاهر ڪري ٿو ته ڇا ڪا شيءِ لسٽ ۾ آهي)، set() (موجوده عنصر کي بدلائي ٿو)، ۽ سائيز () . جيتوڻيڪ انھن مان گھڻا اندروني طور تي مختلف ڪم ڪن ٿا (جيئن اسان کي add() ۽ remove() سان مليو آھي ، آخر نتيجو ساڳيو آھي. بهرحال، LinkedList وٽ فهرست جي شروعات ۽ آخر سان ڪم ڪرڻ لاءِ الڳ الڳ طريقا آهن، جيڪي ArrayList وٽ نه آهن:
  • addFirst() , addLast() : اهي طريقا فهرست جي شروعات/آخر ۾ عنصر شامل ڪرڻ لاءِ
public class Car {

   String model;

   public Car(String model) {
       this.model = model;
   }

   public static void main(String[] args) {
       LinkedList<Car> cars = new LinkedList<>();
       Car ferrari = new Car("Ferrari 360 Spider");
       Car bugatti = new Car("Bugatti Veyron");
       Car lambo = new Car("Lamborghini Diablo");
       Car ford = new Car("Ford Mondeo");
       Car fiat = new Car("Fiat Ducato");

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);
       System.out.println(cars);

       cars.addFirst(ford);
       cars.addLast(fiat);
       System.out.println(cars);
   }

   @Override
   public String toString() {
       return "Car{" +
               "model='" + model + '\'' +
               '}';
   }
}
آئوٽ پٽ: [ڪار{ماڊل='فراري 360 اسپائڊر'}، ڪار{ماڊل='بوگٽي ويرون'}، ڪار{ماڊل='ليمبوروگيني ڊيابلو'}] [ڪار{ماڊل='فورڊ مونڊيو'}، ڪار{ماڊل=' Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}, Car{model='Fiat Ducato'}] اسان فهرست جي مٿئين پاسي "Ford" سان ختم ڪريون ٿا ، ۽ آخر ۾ "Fiat".
  • peekFirst() , peekLast() : طريقا لسٽ ۾ پهريون/آخري عنصر واپس آڻيندا آهن. اهي null موٽندا جيڪڏهن فهرست خالي آهي.
public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.peekFirst());
   System.out.println(cars.peekLast());
}
ٻاڦ _
  • pollFirst() , pollLast() : اهي طريقا لسٽ ۾ پهريون/آخري عنصر واپس آڻيندا آهن ۽ ان کي لسٽ مان هٽائي ڇڏيندا آهن. اهي null موٽندا جيڪڏهن فهرست خالي آهي
public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.pollFirst());
   System.out.println(cars.pollLast());

   System.out.println ("What's on the list?");
   System.out.println(cars);
}
آئوٽ پٽ: ڪار{model='Ferrari 360 Spider'} ڪار{model='Lamborghini Diablo'} فهرست ۾ ڇا بچيو آهي؟ [ڪار{ماڊل='بوگٽي ويرون'}]
  • toArray() : هي طريقو هڪ صف ڏي ٿو جنهن ۾ لسٽ شيون شامل آهن
public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   Car[] carsArray = cars.toArray(new Car[3]);
   System.out.println(Arrays.toString(carsArray));
}
آئوٽ پٽ: [ڪار{model='Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}] هاڻي اسان ڄاڻون ٿا ته LinkedList ڪيئن ڪم ڪري ٿي ۽ ڪيئن ان جو ادارو ArrayList کان مختلف آهي . LinkedList استعمال ڪرڻ جا ڪهڙا فائدا آهن ؟ سڀ کان وڌيڪ، اسان کي فائدو ٿيندو جڏهن فهرست جي وچ ۾ ڪم ڪري. LinkedList جي وچ ۾ داخل ڪرڻ ۽ ختم ڪرڻ جا عمل ArrayList جي ڀيٽ ۾ تمام آسان آھن . اسان صرف پاڙيسري عناصر جي لنڪ کي تازه ڪاري ڪندا آهيون، ۽ ناپسنديده عنصر لنڪس جي زنجير مان "ڊراپ آئوٽ" ڪري ٿو. پر هڪ ArrayList ۾ ، اسان کي گهرجي
  • چيڪ ڪريو ته ڪافي جاء آهي (جڏهن داخل ڪرڻ)
  • جيڪڏهن نه، ته پوءِ اسان هڪ نئين صف ٺاهيندا آهيون ۽ اتي ڊيٽا کي نقل ڪندا آهيون (جڏهن داخل ڪرڻ)
  • اسان عنصر کي هٽائي / داخل ڪريون، ۽ ٻين سڀني عنصرن کي ساڄي / کاٻي ڏانهن منتقل ڪيو (انحصار جي قسم تي). ۽ هن عمل جي پيچيدگي تمام گهڻي فهرست جي سائيز تي منحصر آهي. 10 عناصر کي نقل ڪرڻ / منتقل ڪرڻ لاء هڪ شيء آهي، ۽ هڪ ملين عناصر سان ساڳيو ڪم ڪرڻ لاء هڪ ٻي شيء آهي.
ٻين لفظن ۾، جيڪڏهن فهرست جي وچ ۾ داخل ڪرڻ / هٽائڻ وارا عمل توهان جي پروگرام ۾ تمام عام آهن، LinkedList ArrayList کان تيز هجڻ گهرجي .

نظريي ۾

public class Main {

   public static void main(String[] args) {
       List<Integer> list = new LinkedList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by LinkedList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}
آئوٽ: وقت ورتو ويو LinkedList طرفان (ملي سيڪنڊن ۾) = 1873
public class Main {

   public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by ArrayList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}
آئوٽ: ArrayList پاران ورتو ويو وقت (ملي سيڪنڊن ۾) = 181 اهو غير متوقع هو! اسان هڪ آپريشن ڪيو جتي LinkedList تمام گهڻو ڪارائتو هجڻ گهرجي: لسٽ جي وچ ۾ 100 شيون داخل ڪرڻ. ۽ اسان جي فهرست تمام وڏي آهي: 5,000,000 عناصر. ArrayList کي هر داخل ڪرڻ سان گڏ ٻه ملين شيون منتقل ڪرڻ گهرجن! اهو ڪيئن کٽيو؟ پهريون، عناصر تائين رسائي لاءِ ArrayList لاءِ گهربل وقت مقرر ٿيل آهي (مسلسل). جڏهن توهان لکندا آهيو
list.add(2_000_000, new Integer(Integer.MAX_VALUE));
پوءِ ArrayList [2_000_000] هڪ مخصوص ميموري ايڊريس آهي (آخرڪار، فهرست ۾ هڪ اندروني صف آهي). پر، هڪ LinkedList ۾ هڪ صف نه آهي. اهو ڳولهيندو عنصر نمبر 2_000_000 لنڪ جي زنجير سان. LinkedList لاءِ، هي ميموري ايڊريس ناهي، پر هڪ ڪڙي آهي جنهن کي اڃا تائين پهچڻو آهي: fistElement.next.next.next.next.next.next.next.next.next.next.next.next.next.next. اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.اڳيون.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نڪسٽ.نيڪسٽ.نيڪسٽ.نڪسٽ.نيڪسٽ.نڪسٽ.نيڪسٽ.نڪسٽ.نيڪسٽ.نڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ.نيڪسٽ، . , ArrayList اڳ ۾ ئي صحيح ياداشت جو پتو ڄاڻندو آهي رسائي حاصل ڪرڻ لاء، پر LinkedList اڃا تائين "اتي حاصل ڪرڻ" جي ضرورت آهي. ٻيو، اتي ئي ArrayList جي جوڙجڪ آهي . هڪ خاص اندروني فنڪشن ( System.arrayCopy() ) اندروني صف کي وڌايو، ۽ نقل ڪري ٿو ۽ سڀني عناصر کي شفٽ ڪري ٿو. اهو تمام تيز آهي، ڇاڪاڻ ته اهو هن مخصوص ڪم لاء بهتر آهي. پر جڏهن توهان کي ڪنهن خاص انڊيڪس کي "حاصل" ڪرڻ جي ضرورت ناهي، LinkedList فاتح آهي. فرض ڪريو اسان لسٽ جي شروعات ۾ داخل ڪريون ٿا. اچو ته اتي هڪ ملين عناصر داخل ڪرڻ جي ڪوشش ڪريو:
public class Main {

   public static void main(String[] args) {
       getTimeMsOfInsert(new ArrayList());
       getTimeMsOfInsert(new LinkedList());
   }

   public static long getTimeMsOfInsert(List list) {
       // Write your code here
       Date currentTime = new Date();
       insert1000000(list);
       Date newTime = new Date();
       long msDelay = newTime.getTime() - currentTime.getTime(); // Calculate the difference
       System.out.println("The result in milliseconds: " + msDelay);
       return msDelay;

   }

   public static void insert1000000(List list) {
       for (int i = 0; i < 1000000; i++) {
           list.add(0, new Object());
       }
   }

}
ٻاھر نڪتو: نتيجو مليس سيڪنڊن ۾: 43448 مليس سيڪنڊن ۾ نتيجو: 107 ھاڻي اسان کي مڪمل طور تي مختلف نتيجو ملي ٿو! ArrayList 43 سيڪنڊن کان وڌيڪ خرچ ڪيو لسٽ جي سامهون هڪ ملين شيون داخل ڪرڻ ۾، جڏهن ته LinkedList ان کي 0.1 سيڪنڊن ۾ منظم ڪيو! LinkedList هتي فائدو حاصل ڪيو، ڇاڪاڻ ته اهو هر وقت لسٽ جي وچ ۾ لنڪ جي زنجير ذريعي هلائڻ جي ضرورت ناهي. اهو فوري طور تي لسٽ جي شروعات ۾ گهربل انڊيڪس ڳولي ٿو، تنهنڪري مختلف الگورتھم اڳ ۾ ئي هڪ فائدو آهي. :) حقيقت ۾، " ArrayList بمقابله LinkedList " بحث تمام وسيع آهي، ۽ اسان موجوده سطح تي ان ۾ گهيرو نه ڪنداسين. بنيادي شيء جيڪا توهان کي ياد رکڻ جي ضرورت آهي اها آهي:
  • نه سڀئي نظرياتي فائدا ڪو به خاص مجموعو هميشه حقيقت ۾ ڪم ڪندو آهي (اسان هن کي فهرست جي وچ ۾ شامل مثال سان ڏٺو)
  • جڏهن ڪو مجموعو چونڊڻ جي ڳالهه اچي ٿي ته انتهائي پوزيشن نه اختيار ڪريو (" ArrayList هميشه تيز آهي. ان کي استعمال ڪريو ۽ توهان غلط نه ٿي سگهو. ڪو به هڪ ڊگهي وقت تائين LinkedList استعمال نه ڪري رهيو آهي").
جيتوڻيڪ LinkedList جو ليکڪ، جوشوا بلوچ، چوي ٿو ته اهو معاملو آهي. :) اڃا تائين، اهو نقطو 100٪ صحيح کان پري آهي، ۽ اسان پاڻ کي هن تي قائل ڪيو آهي. اسان جي پوئين مثال ۾، LinkedList 400 (!) ڀيرا تيز هو. ٻي شيء اها آهي ته واقعي ڪجھه حالتون آهن جتي LinkedList بهترين انتخاب آهي. پر اهي موجود آهن، ۽ صحيح وقت تي LinkedList توهان کي سٺي نموني انعام ڏئي سگهي ٿو. اهو نه وساريو جيڪو اسان سبق جي شروعات ۾ چيو هو: مختلف ڪمن لاءِ تمام ڪارآمد ڊيٽا جي جوڙجڪ مختلف آهن. اهو ناممڪن آهي 100٪ پڪ آهي ته ڪهڙي ڊيٽا جي جوڙجڪ بهترين هوندي جيستائين توهان پنهنجي ڪم جي سڀني شرطن کي ڄاڻو ٿا. توھان انھن مجموعن بابت وڌيڪ ڄاڻو ٿا بعد ۾، جيڪو چونڊ کي آسان بڻائي ڇڏيندو. پر سادو ۽ سڀ کان وڌيڪ اثرائتو اختيار هميشه ساڳيو آهي: توهان جي پروگرام ۾ استعمال ٿيل حقيقي ڊيٽا تي ٻنهي جي ڪوشش ڪريو. پوءِ توھان پاڻ ڏسي سگھوٿا ته ڪيئن ٻنهي قسمن جون لسٽون انجام ڏين ٿيون ۽ توھان ضرور غلط نه ٿيندا. :) جيڪو توهان سکيو ان کي مضبوط ڪرڻ لاءِ، اسان توهان کي اسان جي جاوا ڪورس مان هڪ وڊيو سبق ڏسڻ جي صلاح ڏيون ٿا
تبصرا
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION