Memilih Struktur Data

Seluruh struktur telah kita kuasai satu per satu: array, cell array, struct, table, timetable, string array, categorical, datetime/duration, hingga containers.Map. Pilihan yang tepat membuat kode pendek, cepat, dan terbaca; pilihan yang salah membuat hal sepele — menjumlahkan stok, memfilter baris — berubah jadi loop berlapis. Chapter penutup ini merangkum seluruh perangkat dalam satu tabel keputusan, satu diagram alur, dan contoh kasus nyata, lalu mengukur harganya lewat demo array vs cell vs struct pada data yang sama.

Peta Semua Struktur #

Tabel berikut membandingkan seluruh struktur pada empat pertanyaan kunci: homogen?, berlabel?, berstempel waktu?, dan seberapa besar datanya?

Tiga struktur pertama berjalan di MATLAB maupun Octave; sisanya MATLAB-ONLY — pertimbangan portabilitas masuk daftar kriteria bila kode kita harus hidup di dua dunia.

Diagram Keputusan #

Alur berikut membujuk pertanyaan paling menentukan lebih dulu: wujud data apa? — lalu turun ke bagaimana cara mengaksesnya?

Diagram ini membaca dua keputusan bertingkat: wujud data menentukan baris pertama (array, string, categorical, datetime), sedangkan data campuran menurun ke pertanyaan akses — posisi memilih cell, nama memilih struct, key data memilih Map, dan kolom bernama memilih table/timetable. Struktur hasil diagram boleh dibungkus lagi: kolom table bertipe string/categorical/datetime adalah pola normal di analisis data MATLAB.

Empat Kasus Nyata #

Baris pertama memakai timetable karena pertanyaan “berapa rata-rata jam ini?” menuntut pengelompokan per waktu — layaknya contoh sensor di Chapter Timetable. Baris kedua memilih struct karena konfigurasi selalu dibaca dengan nama (config.bahasa), bukan nomor urut. Katalog memilih Map karena kodenya datang dari data, bukan dari skema. Label kepuasan memilih categorical karena nilainya terbatas dan berulang — menyimpan teks penuh per baris adalah pemborosan.

Demo: Data yang Sama, Tiga Struktur #

Lima angka stok disimpan sebagai matrix, cell array, dan struct array — lalu diakses dan dihitung dengan jalur masing-masing:

stokArray  = [120 200 80 50 90];                       % matrix
stokCell   = {120, 200, 80, 50, 90};                   % cell array
stokStruct = struct('stok', {120, 200, 80, 50, 90});   % struct array

fprintf('array(3)     : %d\n', stokArray(3));
fprintf('cell{3}      : %d\n', stokCell{3});
fprintf('struct(3)    : %d\n', stokStruct(3).stok);

fprintf('sum(array)          : %d\n', sum(stokArray));
fprintf('sum([cell{:}])      : %d\n', sum([stokCell{:}]));
fprintf('sum([struct.stok])  : %d\n', sum([stokStruct.stok]));

Output yang Dihasilkan:

array(3)     : 80
cell{3}      : 80
struct(3)    : 80
sum(array)          : 540
sum([cell{:}])      : 540
sum([struct.stok])  : 540

Mari kita bedah hasil tersebut:

1. Akses elemen ketiga: tiga sintaks berbeda — stokArray(3), stokCell{3}, stokStruct(3).stok — menunjukkan wujud pertanyaan yang berbeda: posisi pada blok data, posisi pada sel, dan field pada elemen.
2. Penjumlahan: matrix dijumlahkan langsung; cell dan struct harus “dijatuhkan” dulu menjadi vektor lewat [C{:}] dan [S.stok] — langkah ekstra ini biaya dari fleksibilitasnya.
3. Hasil akhir sama (540): struktur tidak mengubah nilai, hanya mengubah cara mencapainya — kunci memilih adalah frekuensi operasi mana yang akan dominan.

Memori dan Performa #

Aturan ringkas biaya memori: array numerik paling hemat — double memakai 8 byte per elemen dalam blok kontigu; char 2 byte per karakter. Struktur berlabel membayar infrastruktur: setiap sel cell array membungkus isi dengan pointer, setiap elemen struct membawa header per field, dan table menambah metadata nama — anggota data sama, jejak memori lebih besar. Categorical justru berbalik arah: kode angka kecil per elemen ditambah daftar label yang tersimpan sekali, sehingga kolom label yang sangat berulang menjadi jauh lebih hemat daripada teks penuh.

Performa mengikuti pola yang sama: operasi vektorisasi pada matrix (sum(stokArray)) menyentuh memori berurutan dan tercepat; mengambil isi sel atau field satu per satu menambah lompatan pointer per elemen. Konsekuensi praktisnya:

fprintf('rata-rata array : %.1f\n', mean(stokArray));
fprintf('jumlah > 100 (cell)  : %d\n', sum([stokCell{:}] > 100));
fprintf('jumlah > 100 (struct): %d\n', sum([stokStruct.stok] > 100));

Output yang Dihasilkan:

rata-rata array : 108.0
jumlah > 100 (cell)  : 2
jumlah > 100 (struct): 2

Statistik dan mask bekerja mulus di ketiganya — tetapi pada cell dan struct, data harus dikonversi ke array dulu. Pola umum yang sehat: simpan data massal sebagai array (atau table yang kolomnya array), pakai cell/struct untuk metadata dan record, dan konversi di batas-batasnya.

Ringkasan #

Struktur-struktur ini dibedakan oleh wujud data (homogen, teks, kategori, waktu, campuran) dan cara akses (posisi, nama, key, kolom): matrix untuk angka homogen, cell untuk campuran berposisi, struct untuk record bernama, table/timetable untuk dataset berkolom — bertambah stempel waktu pada yang terakhir, string untuk teks massal, categorical untuk label berulang, Map untuk key dinamis, datetime/duration untuk waktu. Data numerik murni paling hemat dan tercepat di array; struktur berlabel membayar overhead infrastruktur namun mengembalikannya dalam keterbacaan dan alat siap pakai. Berkas contoh.m menutup bab dengan perbandingan langsung ketiga struktur universal pada data yang sama.