set C++: elemen unik dan terurut dengan std::set

Kantong berisi nilai unik yang terurut

Kamu sudah melihat unordered_map menyimpan pasangan key-value dengan pencarian cepat berbasis hash. std::set adalah saudaranya yang lebih sederhana: ia hanya menyimpan nilai, tanpa data yang terkait, dan secara otomatis menerapkan dua aturan. Setiap elemen unik (duplikat dibuang diam-diam), dan elemen-elemennya selalu dijaga dalam urutan terurut.

Karena itu set adalah pilihan alami untuk pertanyaan seperti "apakah aku sudah pernah melihat ini?" atau "beri aku item-item yang berbeda dalam urutan terurut". Kamu menambahkan elemen tanpa khawatir soal duplikat, dan menelusurinya tanpa perlu mengurutkan dulu.

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s;
    s.insert(40);
    s.insert(10);
    s.insert(30);
    s.insert(10);   // duplicate - ignored

    for (int x : s) cout << x << " ";   // 10 30 40 (sorted, no repeat)
}

Perhatikan bahwa kita menambahkan 10 dua kali dan tidak berurutan, tapi output-nya terurut dan 10 hanya muncul sekali. Set sudah mengurus pencatatannya untukmu.

Menambah dan menghapus

insert menambahkan sebuah nilai kalau nilai itu belum ada. Fungsi ini mengembalikan pair yang .second-nya berupa bool, yang memberi tahu apakah penambahan benar-benar terjadi. Ini berguna kalau kamu ingin tahu apakah sebuah nilai itu baru:

#include <iostream>
#include <set>
#include <string>
using namespace std;

int main() {
    set<string> seen;

    for (string word : {"go", "rust", "go", "cpp"}) {
        auto [it, inserted] = seen.insert(word);
        if (inserted)
            cout << "First time seeing: " << word << "\n";
        else
            cout << "Already saw: " << word << "\n";
    }
}

Untuk menghapus nilai, panggil erase dengan nilai itu sendiri. Fungsi ini mengembalikan jumlah elemen yang dihapus (0 atau 1 untuk set). Menghapus sesuatu yang tidak ada itu aman, bukan error:

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s = {1, 2, 3, 4};

    s.erase(3);          // removes 3
    s.erase(99);         // does nothing, returns 0

    for (int x : s) cout << x << " ";   // 1 2 4
}

Mengecek keberadaan elemen

Inti dari set adalah pengecekan cepat "apakah ini ada di sini?". Cara yang paling jelas adalah count, yang mengembalikan 1 atau 0:

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> primes = {2, 3, 5, 7, 11};

    if (primes.count(7))
        cout << "7 is prime\n";

    if (!primes.count(9))
        cout << "9 is not in the set\n";
}

Sejak C++20 ada pilihan yang lebih mudah dibaca, yaitu contains, yang langsung mengembalikan bool:

if (primes.contains(7)) { /* ... */ }   // C++20

Kesalahan umum adalah memakai operator[] seperti pada map. set tidak punya operator[]: tidak ada nilai yang bisa diambil, yang ada hanya keberadaan yang bisa dicek. Pakai count atau contains, bukan s[7].

Kalau kamu butuh posisi sebenarnya (untuk menghapusnya, atau melihat elemen di sekitarnya), pakai find, yang mengembalikan iterator atau end():

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s = {10, 20, 30};

    auto it = s.find(20);
    if (it != s.end()) {
        cout << "found " << *it << "\n";
        s.erase(it);   // erase by iterator - no second lookup
    }
    cout << "size now " << s.size() << "\n";
}

Penelusuran berurutan dan query rentang

Karena set terurut, penelusuran selalu menghasilkan elemen dari yang terkecil sampai terbesar, dan kamu mendapat trik container terurut secara gratis. lower_bound(x) memberi elemen pertama yang tidak lebih kecil dari x, dan upper_bound(x) memberi elemen pertama yang benar-benar lebih besar dari x. Keduanya memungkinkan kamu memindai rentang angka tanpa mengecek setiap elemen:

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s = {5, 12, 18, 23, 31, 47};

    // print everything in [12, 31]
    auto begin = s.lower_bound(12);
    auto end = s.upper_bound(31);
    for (auto it = begin; it != end; ++it)
        cout << *it << " ";   // 12 18 23 31
}

Ada aturan yang halus tapi penting: elemen set tidak bisa diubah. Iterator memberimu reference const, jadi kamu tidak bisa mengubah elemen di tempatnya, karena itu bisa merusak urutan yang diandalkan container. Untuk "mengubah" sebuah nilai, hapus nilai lama lalu tambahkan nilai yang baru.

Secara default urutannya naik (std::less). Untuk urutan turun, berikan comparator lain sebagai argumen template kedua:

#include <iostream>
#include <functional>
#include <set>
using namespace std;

int main() {
    set<int, greater<int>> s = {5, 12, 18, 23};

    for (int x : s) cout << x << " ";   // 23 18 12 5
}

set vs multiset vs unordered_set

std::set adalah salah satu dari tiga kerabat dekat, dan memilih yang tepat itu penting:

set<int>            // unique values, sorted, O(log n)
multiset<int>       // allows duplicates, sorted, O(log n)
unordered_set<int>  // unique values, NO order, average O(1)

Pakai unordered_set kalau kamu hanya butuh pengecekan keberadaan dan tidak peduli urutan: pencarian berbasis hash-nya rata-rata lebih cepat daripada O(log n) berbasis tree milik set. Pilih set kalau kamu butuh elemen dalam urutan terurut, query rentang dengan lower_bound/upper_bound, atau perilaku iterator yang stabil. Pakai multiset hanya kalau duplikat memang bermakna (misalnya histogram dari nilai yang berulang). Di multiset, count(x) bisa mengembalikan lebih dari 1, dan erase(x) menghapus semua salinannya kecuali kamu menghapus lewat satu iterator.

Satu pemakaian klasik set: menghapus duplikat sekaligus mengurutkan vector dalam satu langkah.

#include <iostream>
#include <set>
#include <vector>
using namespace std;

int main() {
    vector<int> data = {4, 1, 4, 2, 1, 3};
    set<int> unique(data.begin(), data.end());

    for (int x : unique) cout << x << " ";   // 1 2 3 4
}

Membuat set dari iterator milik vector membuang setiap duplikat dan mengurutkan sisanya, tanpa loop manual dan tanpa repot dengan pengurutan eksplisit plus std::unique.

Berikutnya: pair dan tuple

Kamu sudah melihat .first dan .second muncul pada pair yang dikembalikan insert, dan structured binding yang dipadukan dengan kata kunci auto (auto [it, inserted]) membongkarnya dengan rapi. Tipe ringan untuk "menggabungkan beberapa nilai" seperti itu ada di mana-mana di STL. Berikutnya kita akan membahas pair dan tuple secara langsung: cara membuatnya, membongkarnya, dan mengembalikan banyak nilai dari fungsi tanpa harus mendefinisikan struct.