جاوا ۾ TreeSet

جاوا ڊيٽا جي جوڙجڪ جو هڪ وسيع سيٽ مهيا ڪري ٿو موثر طريقي سان ڪم ڪرڻ لاءِ عنصر گڏ ڪرڻ سان. هڪ اهڙي ڊيٽا جي جوڙجڪ TreeSet آهي، جاوا ۾ هڪ ڳاڙهي-ڪارو وڻ جو عمل. TreeSet منفرد عناصر کي محفوظ ڪرڻ لاء ترتيب ڏنل ترتيب رکي ٿو. شروعات ڪندڙ شايد Java TreeSet ڪلاس استعمال ڪندي شروع ۾ ٿورو مشڪل ڳولي سگھن ٿا. هن آرٽيڪل ۾، اسان اهو معلوم ڪرڻ وارا آهيون ته TreeSet ڪيئن استعمال ڪجي ، ان جي بنيادي تصورن جي وضاحت ڪندي ۽ ڪوڊ جا مثال مهيا ڪرڻ لاءِ توهان جي جاوا منصوبن ۾ TreeSet کي شامل ڪرڻ شروع ڪرڻ ۾ مدد ڪري.

وڻن جي جوڙجڪ: ڳاڙهو-ڪارو وڻ

جيئن اسان اڳ ۾ ذڪر ڪيو آهي، جاوا TreeSet طبقي جي جوڙجڪ هڪ خود توازن بائنري ڳولا واري وڻ جي طور تي لاڳو ڪيو ويو آهي جيڪو Red-Black Tree جي نالي سان مشهور آهي. اچو ته وضاحت ڪريون ته هي ڇا آهي... هڪ ڳاڙهو-ڪارو وڻ هڪ متوازن بائنري سرچ ڊيٽا جي جوڙجڪ جي نمائندگي ڪري ٿو جيڪو عام طور تي ترتيب ڏنل ڊيٽا کي ذخيرو ۽ منظم ڪرڻ لاء استعمال ڪيو ويندو آهي. اهو نالو ان ملڪيت مان نڪتل آهي جيڪي ان جي توازن کي برقرار رکندا آهن:

• وڻ ۾ هر ڪونڊ ڳاڙهي يا ڪارو آهي.
• ڳاڙهي-ڪاري وڻ جي پاڙ هميشه ڪارا هوندي آهي.
• سڀ ليف نوڊس (NIL nodes يا null links) ڪارا هوندا آهن.
• جيڪڏهن وڻ جي هڪ ڪنڊ ڳاڙهي آهي، ته ان جا ٻار ڪارا آهن.
• هر سادو رستو هڪ نوڊ کان ان جي نسلي نوڊس تائين هڪ جيتري تعداد ۾ ڪارو نوڊس تي مشتمل آهي.

ڳاڙهي-ڪاري وڻن کي شامل ڪرڻ، حذف ڪرڻ، ۽ عنصر ڳولڻ جي عملن لاءِ موثر ڪارڪردگي ڏيکاري ٿي توازن کي يقيني بڻائي. اهو ضمانت ڏئي ٿو ته وڻ جي اوچائي ان ۾ شامل نوڊس جي تعداد جي لاگارٿم جي تناسب سان رهي ٿي، جنهن جي نتيجي ۾ عملن لاءِ منطقي وقت جي پيچيدگي پيدا ٿئي ٿي. ڳاڙهو-ڪارو وڻ مختلف ڊومينز ۾ وسيع ايپليڪيشنون ڳوليندا آهن، بشمول پروگرامنگ ٻولين ۾ متوازن ڳولا واري وڻن جو عمل، ڊيٽابيس (مثال طور، اندروني انڊيڪس ڍانچي)، ۽ ٻيون منظرنامو جتي موثر اسٽوريج ۽ ترتيب ڏنل ڊيٽا تي آپريشن ضروري آهن.

TreeSet جون خاصيتون ۽ ڪمزوريون

TreeSet ڪيترن ئي اهم خصوصيتن کي مهيا ڪري ٿو جيڪا ترتيب سان ترتيب ڏنل شيون جي مجموعن کي منظم ڪرڻ لاء هڪ قيمتي اوزار بڻائي ٿي. فائدا:

• ترتيب ڏنل ترتيب ۾ عناصر جي خودڪار سار سنڀال. جڏهن عناصر شامل ڪرڻ يا ختم ڪرڻ، وڻ جي جوڙجڪ کي ترتيب ڏيڻ لاء ترتيب ڏئي ٿو. هي هٿرادو ترتيب ڏيڻ جي ضرورت کي ختم ڪري ٿو ۽ چڙهڻ يا نزول جي ترتيب ۾ موثر رسائي فراهم ڪري ٿو.
• موثر ڳولا، داخل ڪريو، ۽ آپريشن کي ختم ڪريو. اهو هڪ بائنري سرچ وڻ جي جوڙجڪ کي استعمال ڪري ٿو، انهن عملن کي O(log N) جي وقت جي پيچيدگي سان چالو ڪري ٿو . هتي اين عناصر جو تعداد آهي.
• TreeSet عنصرن جي انفراديت جي ضمانت ڏئي ٿو انهن جي قدرتي ترتيب يا ڪسٽم ڪمپريٽر کي استعمال ڪندي . اهو مفيد آهي جڏهن مجموعن سان ڪم ڪري رهيا آهن جيڪي مختلف عناصر جي ضرورت هونديون آهن.

حدون:

• ترتيب ڏنل ترتيب کي برقرار رکڻ جي ڪري HashSet کان ٿورو سست .
• null عنصرن جي اجازت نه ٿو ڏئي، ڇاڪاڻ ته اهو قدرتي ترتيب ڏيڻ يا عنصر جي مقابلي لاءِ حسب ضرورت ڪمپريٽر تي ڀاڙي ٿو .

Java TreeSet: مکيه عملن جو مثال

ھاڻي اچو ته ڏيکاريون ته جاوا ۾ TreeSet ڪيئن ٺاھيو ، ڪليڪشن جي سائيز حاصل ڪريو، ان ۾ عناصر شامل ڪريو، انھن کي ختم ڪريو ۽ چيڪ ڪريو ته ڇا ھڪڙو عنصر TreeSet ۾ آھي . اهي ڪوڊ مثال ڏيکارين ٿا مکيه عملن کي جڏهن TreeSet سان ڪم ڪري رهيو آهي: هڪ مثال ٺاهڻ، عناصر شامل ڪرڻ، عناصر کي هٽائڻ، عنصر جي موجودگي جي جانچ ڪرڻ، ۽ TreeSet جي سائيز حاصل ڪرڻ . TreeSet مثال ٺاهڻ ۽ عناصر شامل ڪرڻ:

// Creating a TreeSet of Integer type
TreeSet<Integer> numbers = new TreeSet<>();

// Adding elements to the TreeSet
numbers.add(18);
numbers.add(2);
numbers.add(7);
numbers.add(28);

System.out.println(numbers); // Output: [2, 7, 18, 28]

هتي اسان پنهنجي TreeSet ۾ 4 نمبر شامل ڪرڻ لاءِ add() طريقو استعمال ڪريون ٿا . جيڪڏهن اسان هڪ مکيه طريقو ٺاهي ۽ پروگرام کي هلائيندا آهيون، پيداوار ترتيب ڏنل ترتيب ۾ هوندي (2، 7، 18، 28). TreeSet مان عناصر کي هٽائڻ :

TreeSet<String> names = new TreeSet<>();

names.add("Johnny");
names.add("Ivy");
names.add("David");
names.add("Ricky");

// Removing an element from the TreeSet
names.remove("David");

System.out.println(names); // Output: [Ivy, Johnny, Ricky]

TreeSet ۾ هڪ عنصر جي موجودگي جي جانچ ڪندي :

TreeSet<String> musicalInstrument = new TreeSet<>();

musicalInstrument.add("Piano");
musicalInstrument.add("Drums");
musicalInstrumentfruits.add("Violin");
musicalInstrument.add("Double Bass");

// Checking if an element exists in the TreeSet
boolean containsPiano = musicalInstrument.contains("Piano");
boolean containsCello = musicalInstrument.contains("Cello");

System.out.println(containsPiano); // Output: true
System.out.println(containsCello); // Output: false

TreeSet جي ماپ حاصل ڪرڻ :

TreeSet<Character> letters = new TreeSet<>();

letters.add('A');
letters.add('B');
letters.add('C');
letters.add('D');

// Getting the size of the TreeSet
int size = letters.size();

System.out.println(size); // Output: 4

TreeSet ۾ ترتيب ڏيڻ ۽ ٻيهر ڪرڻ

جاوا ۾ TreeSet عناصر جي مجموعن کي ترتيب ڏيڻ ۽ ٻيهر ڪرڻ لاءِ طاقتور خاصيتون مهيا ڪري ٿو. هن حصي ۾، اسان عناصرن کي ترتيب ڏيڻ، TreeSet مٿان ٻيهر ڪرڻ ، ۽ subSet() , headSet() , and tailSet() طريقن کي استعمال ڪندي رينج تي ٻڌل ڳولها ڪرڻ لاءِ مختلف طريقن جي ڳولا ڪنداسين. ڊفالٽ طور، TreeSet خودڪار طريقي سان ترتيب ڏنل ترتيب ۾ عناصر کي برقرار رکي ٿو. تنهن هوندي، اسان TreeSet ٺاھڻ دوران ھڪڙو موازنہ مهيا ڪندي ترتيب ڏيڻ واري رويي کي ترتيب ڏئي سگھون ٿا . اچو ته هڪ مثال ڏسون:

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetSortingExample {
  public static void main(String[] args) {
    // Create a TreeSet with custom sorting
    TreeSet<Integer> numbers = new TreeSet<>(Comparator.reverseOrder());

    // Add elements to the TreeSet
    numbers.add(5);
    numbers.add(3);
    numbers.add(7);
    numbers.add(1);

    System.out.println(numbers); // Output: [7, 5, 3, 1]
  }
}

مٿي ڏنل ڪوڊ ۾، اسان Integer قسم جو TreeSet ٺاهيون ٿا ۽ Comparator.reverseOrder() کي استعمال ڪندي هڪ حسب ضرورت Comparator مهيا ڪريون ٿا ته جيئن عناصرن کي نزولي ترتيب ۾ ترتيب ڏيو. نتيجي ۾ TreeSet عنصرن تي مشتمل هوندو [7, 5, 3, 1] . TreeSet مٿان ٻيهر ورجائڻ جا ڪيترائي طريقا آهن . اسان هڪ آئٽرٽر استعمال ڪري سگھون ٿا يا استعمال ڪري سگھون ٿا وڌايل هر لوپ لاءِ. اچو ته ٻنهي طريقن جا مثال ڏسو:

import java.util.TreeSet;
import java.util.Iterator;

public class TreeSetIterationExample {
  public static void main(String[] args) {
    TreeSet<String> names = new TreeSet<>();

    names.add("Johnny");
    names.add("Ivy");
    names.add("Ricky");
    names.add("David");

    // Iterating using an iterator
    Iterator<String> iterator = names.iterator();
    while (iterator.hasNext()) {
      String name = iterator.next();
      System.out.println(name);
    }

    // Iterating using the enhanced for-each loop
    for (String name : names) {
      System.out.println(name);
    }
  }
}

مٿي ڏنل ڪوڊ ۾، اسان هڪ TreeSet ٺاهيو جنهن کي نالو سڏيو ويندو آهي ۽ ڪجهه عناصر شامل ڪندا آهيون. اسان پوءِ ڏيکاريون ٿا ٻه طريقا ٽري سيٽ تي ٻيهر ورجائڻ لاءِ : هڪ آئٽرٽر استعمال ڪندي ۽ هر هڪ لوپ لاءِ وڌايل استعمال ڪندي. TreeSet رينج جي بنياد تي ڳولها ڪرڻ لاء طريقا مهيا ڪري ٿي، اسان کي مخصوص معيار جي بنياد تي عناصر جي سبسٽس کي ٻيهر حاصل ڪرڻ جي اجازت ڏئي ٿي. رينج تي ٻڌل ڳولا جا ٽي مکيه طريقا آهن:

• ذيلي سيٽ (E کان عنصر، E کان عنصر) : عنصرن جو ھڪڙو ذيلي سيٽ واپس ڪري ٿو عنصر (شامل) کان عنصر (خاص) ڏانھن.
• headSet(E toElement) : عنصرن جو ذيلي سيٽ واپس ڪري ٿو toElement کان گھٽ .
• tailSet(E fromElement) : عنصرن جو هڪ ذيلي سيٽ واپس ڪري ٿو fromElement کان وڌيڪ يا برابر .

اچو ته هڪ مثال ڏسون:

import java.util.TreeSet;

public class TreeSetRangeSearchExample {
  public static void main(String[] args) {
    TreeSet<Integer> numbers = new TreeSet<>();

    numbers.add(1);
    numbers.add(3);
    numbers.add(5);
    numbers.add(7);
    numbers.add(9);

    // Performing range-based search using subSet()
    TreeSet<Integer> subset = new TreeSet<>(numbers.subSet(3, 8));
    System.out.println(subset); // Output: [3, 5, 7]

    // Performing range-based search using headSet()
    TreeSet<Integer> headSet = new TreeSet<>(numbers.headSet(6));
    System.out.println(headSet); // Output: [1, 3, 5]

    // Performing range-based search using tailSet()
     TreeSet<Integer> tailSet = new TreeSet<>(numbers.tailSet(5));
    System.out.println(tailSet); // Output: [5, 7, 9]
  }
}

مٿي ڏنل ڪوڊ ۾، اسان هڪ TreeSet ٺاهيندا آهيون جنهن کي نمبر سڏيو ويندو آهي ۽ ڪجهه عناصر شامل ڪندا آهيون. اسان پوءِ ڏيکاريون ٿا رينج تي ٻڌل ڳولها استعمال ڪندي subSet() , headSet() , and tailSet() طريقا.

• سبسيٽ TreeSet ۾ 3 (شامل) ۽ 8 (خاص) جي وچ ۾ عناصر شامل آھن، جيڪي آھن [3, 5, 7] .
• هيڊ سيٽ TreeSet ۾ 6 کان گهٽ عناصر شامل آهن، جيڪي [1، 3، 5] آهن .
• tailSet TreeSet 5 کان وڌيڪ يا برابر عناصر تي مشتمل آهي، جيڪي [5, 7, 9] آهن .

اهي رينج جي بنياد تي ڳولا جا طريقا اسان کي اجازت ڏين ٿا عناصر جي سبسٽس کي حاصل ڪرڻ جي مخصوص معيار جي بنياد تي، ترتيب ڏنل ڊيٽا سان ڪم ڪرڻ ۾ لچڪ فراهم ڪرڻ.

TreeSet ۾ مقابلو ڪندڙ: ترتيب سان ترتيب ڏنل معيار

قدرتي ترتيب ڏيڻ کان سواءِ، توھان استعمال ڪري سگھو ٿا ھڪڙي ڪسٽم ڪمپيريٽر کي ترتيب ڏيڻ لاءِ TreeSet . هن سيڪشن ۾، اسان هڪ موازنہ جي تصور ۽ TreeSet ۾ ان جي ڪردار تي غور ڪنداسين . اسان ڳولهينداسين ته ڪيئن ٺاهجي TreeSet هڪ گراهڪ موازن سان ۽ ڪوڊ جا مثال مهيا ڪري ڏيکارينداسين TreeSet کي مخصوص معيار جي بنياد تي ترتيب ڏيڻ لاءِ.

Comparator ڇا آهي؟

هڪ Comparator جاوا ۾ هڪ انٽرفيس آهي جيڪو اجازت ڏئي ٿو حسب ضرورت شين جي ترتيب سان. اهو مخصوص خاصيتن يا خاصيتن جي بنياد تي عناصر جي ترتيب کي بيان ڪرڻ جو هڪ طريقو مهيا ڪري ٿو. Comparator انٽرفيس کي لاڳو ڪرڻ ۽ ان جي compare() طريقي کي ختم ڪرڻ سان، اسان وضاحت ڪري سگھون ٿا ته عناصر کي TreeSet ۾ ڪيئن ترتيب ڏنو وڃي .

هڪ گراهڪ مقابلي سان TreeSet ٺاهڻ

ھڪڙي ٺاھڻ لاءِ TreeSet ھڪڙي ڪسٽم موازنہ ڪندڙ سان، اسان کي ضرورت آھي موازن کي مهيا ڪرڻ لاءِ دليل جي طور تي جڏھن TreeSet مثال ٺاھيو. اچو ته هڪ مثال ڏسون:

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetComparatorExample {
  public static void main(String[] args) {
    // Create a TreeSet with a custom comparator
    TreeSet<String> names = new TreeSet<>(new LengthComparator());

    // Add elements to the TreeSet
    names.add("Johnny");
    names.add("Ivy");
    names.add("Rick");
    names.add("David");

    System.out.println(names); // Output: [Ivy, Johnny, David, Rick]
  }
}

class LengthComparator implements Comparator<String> {
  @Override
  public int compare(String s1, String s2) {
    return Integer.compare(s1.length(), s2.length());
  }
}

مٿي ڏنل ڪوڊ ۾، اسان هڪ TreeSet ٺاهيندا آهيون نالن جي نالي سان هڪ ڪسٽم موازنہ ڪندڙ جنهن کي LengthComparator سڏيو ويندو آهي . LengthComparator ٻن تارن جي ڊگھائي جو مقابلو ڪري ٿو ۽ انھن جي مطابق ترتيب ڏئي ٿو . نتيجي طور، TreeSet ترتيب ڏنل آھي تارن جي ڊگھائي جي بنياد تي، اسان کي پيداوار ڏيو [Ivy, Rick, David, Johnny] .

ڪامپريٽر استعمال ڪندي TreeSet کي ترتيب ڏيڻ جا مثال

هڪ ٽري سيٽ ٺاهڻ سان گڏ هڪ ڪسٽم ڪمپيريٽر سان، اسان پڻ استعمال ڪري سگهون ٿا ڪامپريٽر کي ترتيب ڏيڻ لاءِ هڪ TreeSet کي عارضي طور تي ترتيب ڏيڻ کان سواءِ ان جي قدرتي ترتيب جي. اچو ته هڪ مثال ڏسون:

import java.util.Comparator;
import java.util.TreeSet;

  public class TreeSetTest {
    public static void main(String[] args) {
      TreeSet<String> names = new TreeSet<>();

      names.add("Johnny");
      names.add("Ivy");
      names.add("Ricky");
      names.add("David");

      // Sort TreeSet temporarily using a comparator
      TreeSet<String> sortedNames = new TreeSet<>(Comparator.reverseOrder());
      sortedNames.addAll(names);

      System.out.println(sortedNames); // Output: [Ricky, Johnny, Ivy, David]
      System.out.println(names); // Output: [David, Ivy, Johnny, Ricky]
    }
  }

مٿي ڏنل ڪوڊ ۾، اسان هڪ TreeSet ٺاهيو جنهن کي نالو سڏيو ويندو آهي ۽ ڪجهه عناصر شامل ڪندا آهيون. ان کان پوء اسان هڪ نئون TreeSet ٺاهيو جنهن کي ترتيب ڏنل نالو سڏيو ويندو آهي هڪ ڪسٽم موازنہ Comparator.reverseOrder() سان . اصل نالن TreeSet مان سڀني عناصر کي ترتيب ڏنل نالن ۾ شامل ڪرڻ سان ، اسان حاصل ڪريون ٿا عارضي ترتيب ڏنل نسخو TreeSet جو .

ٻين ڊيٽا جي جوڙجڪ سان TreeSet جو مقابلو

TreeSet جو مقابلو HashSet سان

ٻئي TreeSet ۽ HashSet جاوا ۾ سيٽ انٽرفيس جا عمل آهن . بهرحال، انهن جي وچ ۾ اهم اختلاف آهن. TreeSet : TreeSet منفرد عناصر کي ترتيب ڏنل ترتيب ۾ محفوظ ڪري ٿو. اهو ترتيب ڏنل ترتيب کي برقرار رکڻ لاءِ خود توازن وارو بائنري سرچ وڻ (عام طور تي هڪ ڳاڙهو-ڪارو وڻ) استعمال ڪري ٿو، جنهن جي نتيجي ۾ لاگارٿمڪ وقت جي پيچيدگي جهڙوڪ آپريشنز جهڙوڪ داخل ڪرڻ، حذف ڪرڻ، ۽ ڳولا. TreeSet ھڪڙي ترتيب واري مجموعي کي برقرار رکڻ ۽ رينج تي ٻڌل آپريشن کي انجام ڏيڻ لاء ڪارائتو آھي. تنهن هوندي به، وڻ جي جوڙجڪ جي ڪري ان ۾ وڌيڪ ميموري اوور هيڊ آهي ۽ نيل عناصر کي اجازت نه ڏيندو آهي. HashSet : HashSet منفرد عناصر کي غير ترتيب واري انداز ۾ محفوظ ڪري ٿو هيش ڪوڊس ۽ هيش ٽيبل اندروني طور استعمال ڪندي. اهو بنيادي عملن جهڙوڪ داخل ڪرڻ، حذف ڪرڻ، ۽ ڳولا لاء مسلسل وقت جي پيچيدگي فراهم ڪري ٿو. HashSet تيز عنصر ڏسڻ لاءِ ڪارائتو آهي ۽ آرڊر برقرار رکڻ لاءِ ڪنهن به اضافي ميموري اوور هيڊ کي لاڳو نٿو ڪري. بهرحال، اهو عناصر جي ڪنهن خاص ترتيب جي ضمانت نٿو ڏئي.

جڏهن TreeSet استعمال ڪرڻ لاء:

• جڏهن توهان کي خودڪار طريقي سان ترتيب ڏنل ترتيب ۾ عناصر کي برقرار رکڻ جي ضرورت آهي.
• جڏهن توهان کي رينج جي بنياد تي آپريشن جي ضرورت آهي يا هڪ مخصوص حد اندر عناصر کي موثر طريقي سان ڳولڻ جي ضرورت آهي.
• جڏهن نقلي عناصر جي اجازت نه آهي ۽ انفراديت ضروري آهي.
• جڏهن توهان واپار ڪرڻ لاءِ تيار آهيو ٿوري گهڻي ياداشت جي استعمال کي خودڪار ترتيب ڏيڻ ۽ رينج جي عملن جي فائدن لاءِ.

TreeSet جو مقابلو ArrayList سان

ArrayList جاوا ۾ هڪ متحرڪ صف عمل درآمد آهي. هتي TreeSet ۽ ArrayList جي وچ ۾ اهم فرق آهن :

• TreeSet : TreeSet منفرد عناصر کي ترتيب ڏنل ترتيب ۾ ذخيرو ڪري ٿو، ترتيب ڏنل مجموعي کي برقرار رکڻ ۽ رينج جي بنياد تي ڳولا کي انجام ڏيڻ لاء موثر آپريشن مهيا ڪري ٿو. اهو عملن لاء منطقي وقت جي پيچيدگي آهي. TreeSet بي ترتيب رسائي يا داخل ڪرڻ جي ترتيب کي برقرار رکڻ لاء مناسب ناهي.
• ArrayList : ArrayList ذخيرو عناصر کي داخل ڪرڻ جي ترتيب ۾، اشارن کي استعمال ڪندي عناصر تائين تيز بي ترتيب رسائي فراهم ڪري ٿي. ان ۾ اڪثر عملن لاءِ مسلسل وقت جي پيچيدگي آهي جڏهن انڊيڪس ذريعي عناصر تائين پهچندي آهي. بهرحال، ان ۾ لسٽ جي وچ مان عناصر داخل ڪرڻ يا ختم ڪرڻ لاءِ لڪير واري وقت جي پيچيدگي آهي، جيئن ان کي تبديل ڪرڻ واري عناصر جي ضرورت آهي.

جڏهن ٻين ڊيٽا جي جوڙجڪ تي غور ڪيو وڃي

• جيڪڏهن ترتيب ڏنل ترتيب ۾ عناصر کي برقرار رکڻ جي ضرورت ناهي، ۽ توهان کي هڪ تيز عنصر ڳولڻ يا هڪ غير ترتيب واري مجموعي جي ضرورت آهي، HashSet هڪ بهتر انتخاب ٿي سگهي ٿو.
• جيڪڏھن توھان کي ضرورت آھي عناصرن تائين بار بار بي ترتيب رسائي انڊيڪس ذريعي يا داخل ڪرڻ جي ترتيب کي برقرار رکڻ جي ضرورت آھي، ArrayList وڌيڪ مناسب ھوندو.