TreeSet ing Jawa

Jawa nyedhiyakake struktur data sing akeh kanggo nggarap kumpulan unsur kanthi efisien. Salah sawijining struktur data kasebut yaiku TreeSet, implementasine wit abang-ireng ing Jawa. TreeSet njaga urutan sing diurutake kanggo nyimpen unsur unik. Pamula bisa nemokake nggunakake kelas Java TreeSet rada nantang ing wiwitan. Ing artikel iki, kita bakal nemtokake cara nggunakake TreeSet , nerangake konsep inti lan menehi conto kode kanggo mbantu sampeyan miwiti nggabungake TreeSet ing proyek Java.

Struktur TreeSet: Wit Abang-Ireng

Kaya sing wis kasebut sadurunge, struktur kelas Java TreeSet diimplementasikake minangka wit telusuran binar sing ngimbangi dhewe sing dikenal minangka wit Abang-Ireng. Ayo nerangake apa iki ... Wit Abang-Ireng nggambarake struktur data telusuran biner sing seimbang sing umum digunakake kanggo nyimpen lan ngatur data sing diurutake. Jeneng kasebut asale saka sifat-sifat sing njaga keseimbangane:

• Saben simpul ing wit iku abang utawa ireng.
• Oyod saka wit Abang-Ireng tansah ireng.
• Kabeh simpul godhong (node ​​NIL utawa null link) ireng.
• Yen simpul saka wit iku abang, banjur anak-anake ireng.
• Saben path prasaja saka simpul menyang simpul turunane ngemot jumlah simpul ireng sing padha.

Wit abang-ireng nuduhake kinerja sing efisien kanggo nglebokake, mbusak, lan operasi golek unsur kanthi njamin keseimbangan. Iki njamin yen dhuwur wit tetep sebanding karo logaritma saka jumlah simpul sing ana, nyebabake kerumitan wektu logaritma kanggo operasi. Wit abang-ireng nemokake aplikasi sing wiyar ing macem-macem domain, kalebu implementasi wit telusuran sing seimbang ing basa pemrograman, database (contone, struktur indeks internal), lan skenario liyane sing mbutuhake panyimpenan lan operasi sing efisien ing data sing diurutake.

Fitur lan kelemahane TreeSet

TreeSet nyedhiyakake sawetara fitur utama sing ndadekake alat sing migunani kanggo ngatur koleksi obyek kanthi cara sing diurutake. Kaluwihan:

• Pangopènan otomatis unsur ing urutan diurutake. Nalika nambah utawa mbusak unsur, struktur wit nyetel supaya padha diurutake. Iki ngilangi kabutuhan kanggo ngurutake manual lan nyedhiyakake akses sing efisien ing urutan munggah utawa mudhun.
• Operasi telusuran, nyisipake, lan mbusak sing efisien. Iki nggunakake struktur wit telusuran binar, mbisakake operasi kasebut kanthi kerumitan wektu O(log N) . Ing kene N minangka jumlah unsur.
• TreeSet njamin keunikan unsur kanthi nggunakake urutan alami utawa Comparator khusus . Iki migunani nalika nggarap koleksi sing mbutuhake unsur sing béda.

Watesan:

• Luwih alon tinimbang HashSet amarga njaga urutan sing diurutake.
• Ora ngidini unsur null, amarga gumantung ing urutan alam utawa Comparator adat kanggo comparison unsur.

Java TreeSet: conto operasi utama

Saiki ayo nduduhake carane nggawe TreeSet ing Jawa, entuk ukuran koleksi, nambah unsur menyang, mbusak saka lan priksa manawa ana unsur ing TreeSet . Conto kode iki nduduhake operasi utama nalika nggarap TreeSet : nggawe conto, nambah unsur, mbusak unsur, mriksa anané unsur, lan entuk ukuran TreeSet . Nggawe conto TreeSet lan nambah unsur:

// 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]

Ing kene kita nggunakake metode add () kanggo nambah 4 nomer ing TreeSet . Yen kita nggawe cara utama lan mbukak program, output bakal diurutake (2, 7, 18, 28). Mbusak unsur saka 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]

Priksa manawa ana unsur ing 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

Entuk ukuran 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

Ngurutake lan Iterating ing TreeSet

TreeSet ing Jawa nyedhiyakake fitur sing kuat kanggo ngurutake lan ngulang koleksi unsur. Ing bagean iki, kita bakal njelajah macem-macem Techniques kanggo ngurutake unsur, iterasi liwat TreeSet , lan nindakake searches adhedhasar sawetara nggunakake subSet () , headSet () , lan tailSet () cara. Kanthi gawan, TreeSet kanthi otomatis njaga unsur ing urutan sing diurutake. Nanging, kita bisa ngatur prilaku ngurutake kanthi nyedhiyakake Comparator sajrone nggawe TreeSet . Ayo ndeleng conto:

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]
  }
}

Ing kode ndhuwur, kita nggawe TreeSet jinis Integer lan nyedhiyani Comparator adat nggunakake Comparator.reverseOrder () kanggo Ngurutake unsur ing urutan mudhun. TreeSet asil bakal ngemot unsur [7, 5, 3, 1] . Ana macem-macem cara kanggo ngulang TreeSet . Kita bisa nggunakake iterator utawa nggunakake peningkatan kanggo saben loop. Ayo ndeleng conto saka loro pendekatan:

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);
    }
  }
}

Ing kode ndhuwur, kita nggawe TreeSet disebut jeneng lan nambah sawetara unsur. Kita banjur nduduhake rong cara kanggo ngulang TreeSet : nggunakake iterator lan nggunakake loop sing ditingkatake kanggo saben. TreeSet nyedhiyakake cara kanggo nindakake telusuran adhedhasar jangkauan, ngidini kita njupuk subset saka unsur adhedhasar kritéria tartamtu. Telung cara utama kanggo telusuran adhedhasar jangkauan yaiku:

• subSet (E fromElement, E toElement) : Ngasilake subset unsur saka fromElement (inklusif) menyang toElement (eksklusif).
• headSet(E toElement) : Ngasilake subset saka unsur kurang saka toElement .
• tailSet(E fromElement) : Ngasilake subset saka unsur sing luwih gedhe utawa padha karo fromElement .

Ayo ndeleng conto:

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]
  }
}

Ing kode ndhuwur, kita nggawe TreeSet disebut nomer lan nambah sawetara unsur. Kita banjur nduduhake telusuran adhedhasar jangkauan nggunakake metode subSet() , headSet() , lan tailSet() .

• Subset TreeSet ngemot unsur antarane 3 (inklusif) lan 8 (eksklusif) , yaiku [3, 5, 7] .
• HeadSet TreeSet ngemot unsur kurang saka 6, yaiku [1, 3, 5 ] .
• tailSet TreeSet ngemot unsur sing luwih gedhe utawa padha karo 5, yaiku [5, 7, 9 ] .

Cara telusuran adhedhasar sawetara iki ngidini kita njupuk subset saka unsur adhedhasar kritéria tartamtu, nyedhiyakake keluwesan kanggo nggarap data sing diurutake.

Comparator ing TreeSet: Ngurutake karo Kriteria Kustom

Kajaba kanggo urutan alam, sampeyan bisa nggunakake Comparator adat kanggo ngurutake TreeSet . Ing bagean iki, kita bakal nliti konsep komparator lan perane ing TreeSet . Kita bakal njelajah carane nggawe TreeSet karo komparator adat lan menehi conto kode kanggo nduduhake ngurutake TreeSet adhedhasar kritéria tartamtu.

Apa iku Comparator?

Comparator minangka antarmuka ing Jawa sing ngidini ngurutake obyek khusus . Iki menehi cara kanggo nemtokake urutan unsur adhedhasar atribut utawa sifat tartamtu. Kanthi ngleksanakake antarmuka Comparator lan overriding cara mbandhingaké () , kita bisa nemtokake carane unsur kudu diurutake ing TreeSet .

Nggawe TreeSet karo Custom Comparator

Kanggo nggawe TreeSet karo komparator khusus, kita kudu nyedhiyakake komparator minangka argumen nalika nggawe conto TreeSet . Ayo ndeleng conto:

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());
  }
}

Ing kode ndhuwur, kita nggawe TreeSet disebut jeneng karo komparator adat disebut LengthComparator . LengthComparator mbandhingake dawa rong senar lan ngurutake. Akibaté, TreeSet diurutake adhedhasar dawa strings, menehi kita output [Ivy, Rick, David, Johnny] .

Conto Ngurutake TreeSet nggunakake Comparator

Saliyane nggawe TreeSet kanthi komparator khusus, kita uga bisa nggunakake komparator kanggo ngurutake TreeSet sementara tanpa ngowahi urutan alami. Ayo ndeleng conto:

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]
    }
  }

Ing kode ndhuwur, kita nggawe TreeSet disebut jeneng lan nambah sawetara unsur. Kita banjur nggawe TreeSet anyar disebut sortedNames karo komparator adat Comparator.reverseOrder () . Kanthi nambahake kabeh unsur saka jeneng asli TreeSet menyang sortedNames , kita entuk versi diurutake sementara saka TreeSet .

Mbandhingake TreeSet karo Struktur Data Liyane

Mbandhingake TreeSet karo HashSet

TreeSet lan HashSet minangka implementasi saka antarmuka Set ing Jawa. Nanging, ana beda sing signifikan ing antarane. TreeSet : TreeSet nyimpen unsur unik ing urutan sing diurutake. Iki nggunakake wit telusuran binar sing ngimbangi dhewe (biasane Wit Abang-Ireng) kanggo njaga urutan sing diurutake, nyebabake kerumitan wektu logaritmik kanggo operasi kaya penyisipan, pambusakan, lan telusuran. TreeSet efisien kanggo njaga koleksi sing diurutake lan nindakake operasi adhedhasar sawetara. Nanging, nduweni overhead memori sing luwih dhuwur amarga struktur wit lan ora ngidini unsur null. HashSet : HashSet nyimpen unsur unik kanthi cara sing ora teratur nggunakake kode hash lan tabel hash sacara internal. Nyedhiyakake kerumitan wektu sing tetep kanggo operasi dhasar kaya selipan, pambusakan, lan telusuran. HashSet efisien kanggo nggoleki unsur cepet lan ora nemtokke sembarang overhead memori tambahan kanggo njaga supaya. Nanging, ora njamin urutan tartamtu saka unsur.

Nalika nggunakake TreeSet:

• Nalika sampeyan kudu njaga unsur ing urutan diurutake kanthi otomatis.
• Yen sampeyan mbutuhake operasi adhedhasar sawetara utawa kudu nemokake unsur ing sawetara tartamtu kanthi efisien.
• Nalika unsur duplikat ora diidini lan keunikan penting.
• Nalika sampeyan gelem perdagangan mati panggunaan memori rada luwih kanggo keuntungan saka otomatis ngurutake lan sawetara operasi.

Mbandhingake TreeSet karo ArrayList

ArrayList minangka implementasi array dinamis ing Jawa. Mangkene prabédan utama antarane TreeSet lan ArrayList :

• TreeSet : TreeSet nyimpen unsur unik ing urutan sing diurutake, nyedhiyakake operasi sing efisien kanggo njaga koleksi sing diurutake lan nindakake telusuran adhedhasar sawetara. Wis kerumitan wektu logaritmik kanggo operasi. TreeSet ora cocok kanggo akses acak utawa njaga urutan selipan.
• ArrayList : ArrayList nyimpen unsur ing urutan sisipan, nyedhiyakake akses acak kanthi cepet menyang unsur nggunakake indeks. Nduwe kerumitan wektu sing tetep kanggo umume operasi nalika ngakses unsur kanthi indeks. Nanging, nduweni kerumitan wektu linier kanggo nglebokake utawa mbusak unsur saka tengah dhaptar, amarga mbutuhake unsur owah-owahan.

Nalika Nganggep Struktur Data Liyane

• Yen njaga unsur ing urutan sing diurut ora dibutuhake, lan sampeyan butuh golek unsur sing cepet utawa koleksi sing ora diurutake, HashSet bisa dadi pilihan sing luwih apik.
• Yen sampeyan mbutuhake akses acak menyang unsur kanthi indeks utawa kudu njaga urutan sisipan, ArrayList bakal luwih cocog.