Dalam dunia komputasi dan ilmu komputer, pemahaman fundamental mengenai struktur data adalah kunci untuk merancang algoritma yang efisien dan program yang stabil. Di antara berbagai struktur data yang ada, **larik**, atau yang dikenal luas sebagai array, berdiri sebagai salah satu fondasi yang paling esensial dan paling sering digunakan.
Larik adalah kumpulan elemen data yang memiliki tipe yang sama, disimpan secara berdekatan (kontigu) di dalam memori, dan diakses menggunakan satu set indeks. Sifat kontigu inilah yang memberikan larik keunggulan dalam hal kecepatan akses, menjadikannya pilihan utama untuk berbagai tugas, mulai dari penyimpanan data sederhana hingga implementasi struktur data yang lebih kompleks.
Artikel ini akan mengupas tuntas segala aspek mengenai larik: dari konsep paling dasar, perbedaan dimensi, operasi-operasi penting, hingga perbandingan antara implementasi statis dan dinamis, serta peran kritisnya dalam aplikasi nyata.
Untuk memahami kekuatan larik, kita harus terlebih dahulu menguasai terminologi dasarnya.
Larik bukan hanya sekumpulan variabel. Larik adalah blok memori terstruktur yang dirancang untuk efisiensi. Tiga karakteristik utama mendefinisikan sebuah larik:
Indeks adalah label numerik yang digunakan untuk mengidentifikasi posisi spesifik dari sebuah elemen di dalam larik. Dalam sebagian besar bahasa pemrograman modern (seperti C, C++, Java, Python), pengindeksan dimulai dari 0.
Jika sebuah larik memiliki N elemen, maka indeksnya akan berkisar dari 0 hingga N-1. Kesalahan yang umum terjadi pada pemula adalah mencoba mengakses elemen pada indeks N, yang akan menghasilkan kesalahan "Array Index Out of Bounds", sebuah kondisi kritis yang menandakan upaya mengakses memori di luar batas yang dialokasikan untuk larik tersebut.
Penting: Kecepatan akses pada larik adalah O(1) atau waktu konstan. Ini berarti mengambil elemen pertama secepat mengambil elemen ke-seribu, karena sistem hanya perlu melakukan perhitungan matematis sederhana untuk menemukan alamatnya.
Akses acak dimungkinkan melalui perhitungan sederhana. Jika kita memiliki larik bernama A, yang dimulai pada alamat B (Base Address), dan setiap elemen memiliki ukuran W (Word size), alamat elemen ke-i dihitung sebagai:
Alamat(A[i]) = B + (i * W)
Misalnya, jika alamat dasar adalah 1000, ukuran integer adalah 4 byte, dan kita mencari elemen indeks 5:
Alamat(A[5]) = 1000 + (5 * 4) = 1020
Perhitungan yang cepat dan langsung inilah yang mendasari efisiensi larik.
Larik dapat diklasifikasikan berdasarkan jumlah indeks yang diperlukan untuk mengakses elemennya. Klasifikasi ini mendefinisikan cara data distrukturkan, disimpan, dan diakses.
Larik satu dimensi adalah bentuk larik yang paling sederhana. Ia memerlukan satu indeks tunggal untuk mengidentifikasi lokasi data. Struktur ini merepresentasikan daftar atau urutan linier elemen.
Contoh Konseptual Deklarasi:
LARIK_INT Nilai[10] // Larik dengan 10 elemen integer, index 0 sampai 9
Operasi Khas pada Larik 1D:
Penelusuran adalah operasi dasar yang melibatkan akses ke setiap elemen larik sekali. Karena larik adalah struktur statis, penelusuran sangat efisien, dengan kompleksitas waktu O(N), di mana N adalah jumlah elemen. Penelusuran diperlukan untuk tugas-tugas seperti menghitung total nilai, mencari nilai minimum/maksimum, atau mencetak seluruh isi larik.
Pseudocode Traversal 1D:
PROSEDUR CetakLarik (Larik A, Ukuran N)
UNTUK i DARI 0 SAMPAI N-1 LAKUKAN
CETAK A[i]
AKHIR UNTUK
AKHIR PROSEDUR
Konsep O(N) di sini sangat penting. Artinya, jika ukuran larik digandakan, waktu yang dibutuhkan untuk menelusuri juga akan digandakan, menunjukkan hubungan linier yang dapat diprediksi antara ukuran input dan kinerja.
Larik dua dimensi memerlukan dua indeks untuk mengakses elemen: satu untuk baris (row) dan satu untuk kolom (column). Larik 2D sering digunakan untuk merepresentasikan tabel, spreadsheet, atau matriks dalam matematika.
Contoh Konseptual Deklarasi:
LARIK_FLOAT Matriks[3][4] // 3 baris dan 4 kolom, total 12 elemen
Meskipun secara logika terlihat seperti kisi-kisi (grid), larik 2D tetap disimpan secara linier dan kontigu dalam memori fisik. Ada dua cara utama kompilator memetakan larik 2D ke memori 1D:
Memahami urutan penyimpanan ini sangat krusial untuk optimasi kinerja, terutama saat bekerja dengan caching CPU. Mengakses elemen secara berurutan sesuai dengan tata letak memori (misalnya, mengakses semua kolom dalam baris pada Row-Major Order) jauh lebih cepat.
Jika matriks M berukuran R baris dan C kolom, dan kita ingin mencari alamat elemen M[i][j]:
Alamat(M[i][j]) = B + ((i * C) + j) * W
Di mana:
Penelusuran matriks memerlukan perulangan bersarang (nested loop). Loop luar biasanya mengontrol baris (i), dan loop dalam mengontrol kolom (j). Ini juga memiliki kompleksitas O(N*M) di mana N adalah baris dan M adalah kolom, atau O(Total Elemen).
Pseudocode Traversal 2D (Row-Major):
PROSEDUR CetakMatriks (Matriks M, Baris R, Kolom C)
UNTUK i DARI 0 SAMPAI R-1 LAKUKAN // Loop Baris
UNTUK j DARI 0 SAMPAI C-1 LAKUKAN // Loop Kolom
CETAK M[i][j]
AKHIR UNTUK
AKHIR UNTUK
AKHIR PROSEDUR
Pengurutan matriks jauh lebih kompleks dibandingkan larik 1D. Operasi matriks standar melibatkan penambahan, pengurangan, dan perkalian matriks, yang semuanya memerlukan penanganan indeks baris dan kolom yang cermat dan berulang kali harus diuji terhadap batasan-batasan dimensi yang ketat.
Larik multi-dimensi (3D, 4D, dst.) adalah ekstensi dari larik 2D. Larik 3D sering digunakan untuk merepresentasikan volume data, seperti citra 3D (misalnya, data medis CT scan) atau pemetaan ruang-waktu. Untuk larik 3D, diperlukan tiga indeks: kedalaman (z), baris (y), dan kolom (x).
Contoh Konseptual Deklarasi 3D:
LARIK_BOOLEAN Ruang[5][10][20] // 5 lapis, 10 baris, 20 kolom
Meskipun secara konseptual tidak ada batasan jumlah dimensi, dalam praktik nyata, jarang sekali digunakan larik dengan dimensi lebih dari tiga atau empat karena kerumitan manajemen indeks dan kebutuhan memori yang sangat besar. Struktur data lain, seperti pohon (tree) atau graf (graph), seringkali lebih efisien untuk merepresentasikan data berdimensi sangat tinggi.
Jika Larik 3D memiliki dimensi D (Kedalaman), R (Baris), dan C (Kolom), dan kita mencari alamat elemen A[d][r][c]:
Offset = (d * R * C) + (r * C) + c
Alamat(A[d][r][c]) = B + Offset * W
Perhatikan bahwa perhitungan offset selalu melibatkan ukuran dimensi-dimensi yang "lebih dalam" untuk menentukan berapa banyak elemen yang harus dilewati sebelum mencapai dimensi saat ini. Ini menekankan sifat linier penyimpanan memori larik, terlepas dari representasi logisnya yang kompleks.
Meskipun larik dikenal karena efisiensi aksesnya (O(1)), operasi modifikasi dan penataan ulang data (penyisipan dan penghapusan) cenderung kurang efisien.
Larik harus dideklarasikan dengan tipe data dan ukurannya sebelum digunakan. Ukuran ini, pada larik statis, harus diketahui pada waktu kompilasi.
Contoh Inisialisasi Larik:
// Larik Statis dengan ukuran tetap 5
LARIK_INT DaftarAngka[5] = {10, 20, 30, 40, 50}
// Matriks 2x3
LARIK_FLOAT M[2][3] = {
{1.1, 1.2, 1.3},
{2.1, 2.2, 2.3}
}
Akses elemen adalah operasi larik yang paling efisien, dilakukan dengan menggunakan indeks yang sesuai. Seperti yang telah dibahas, ini adalah operasi O(1).
Contoh Akses:
ElemenKetiga = DaftarAngka[2] // Mengambil nilai 30
NilaiKolomDuaBarisSatu = M[0][1] // Mengambil nilai 1.2
Menyisipkan elemen baru ke dalam larik adalah salah satu kelemahan utama struktur ini, terutama jika penyisipan dilakukan di tengah atau di awal.
Jika larik sudah penuh, operasi penyisipan tidak dimungkinkan pada larik statis (membutuhkan realokasi pada larik dinamis, yang akan dibahas nanti).
Jika larik belum penuh, menyisipkan elemen di posisi tertentu (indeks k) memerlukan pergeseran semua elemen yang berada setelah posisi k satu langkah ke belakang untuk membuat ruang kosong. Operasi pergeseran ini memiliki kompleksitas waktu O(N), karena dalam kasus terburuk (menyisipkan di indeks 0), semua N elemen harus dipindahkan.
Pseudocode Penyisipan di Posisi k:
PROSEDUR Sisip (Larik A, Nilai V, Posisi K, Ukuran N)
JIKA N < UkuranMaksimal LAKUKAN
// Geser elemen dari belakang ke posisi K
UNTUK i DARI N-1 TURUN KE K LAKUKAN
A[i+1] = A[i]
AKHIR UNTUK
// Sisipkan nilai baru
A[K] = V
N = N + 1
LAIN
CETAK "Larik Penuh"
AKHIR JIKA
AKHIR PROSEDUR
Sama seperti penyisipan, penghapusan elemen dari larik juga memerlukan operasi pergeseran untuk mempertahankan alokasi kontigu dan mengisi "lubang" yang ditinggalkan oleh elemen yang dihapus.
Jika kita menghapus elemen pada indeks k, semua elemen yang berada setelah k harus digeser satu langkah ke depan (ke kiri). Penghapusan juga memiliki kompleksitas O(N).
Pseudocode Penghapusan di Posisi k:
PROSEDUR Hapus (Larik A, Posisi K, Ukuran N)
JIKA K >= 0 DAN K < N LAKUKAN
// Geser elemen dari posisi K+1 ke depan
UNTUK i DARI K SAMPAI N-2 LAKUKAN
A[i] = A[i+1]
AKHIR UNTUK
// Kurangi ukuran larik
N = N - 1
LAIN
CETAK "Indeks tidak valid"
AKHIR JIKA
AKHIR PROSEDUR
Dari analisis ini, jelas bahwa larik adalah pilihan yang sangat baik ketika kita sering melakukan operasi akses dan jarang melakukan modifikasi di tengah data. Jika sering ada penyisipan dan penghapusan di awal atau tengah, linked list seringkali merupakan pilihan yang lebih baik.
Konsep larik dapat dibagi menjadi dua kategori utama berdasarkan bagaimana memori dialokasikan dan bagaimana ukurannya dikelola.
Larik statis adalah larik yang ukurannya ditentukan pada saat kompilasi (compile-time). Setelah dideklarasikan, ukurannya tidak dapat diubah selama eksekusi program.
Larik dinamis, sering diimplementasikan dalam pustaka standar (misalnya, std::vector di C++ atau ArrayList di Java), adalah struktur yang memungkinkan ukuran larik berubah saat program berjalan (run-time).
Secara internal, larik dinamis masih menggunakan larik statis, tetapi ia mengelola realokasi memori di balik layar.
Ketika larik dinamis mencapai kapasitas penuh dan operasi penyisipan (misalnya, push_back) dipanggil, ia melakukan proses realokasi yang mahal:
Meskipun operasi penyisipan tunggal (yang memicu realokasi) bisa sangat lambat, memiliki kompleksitas waktu O(N), rata-rata waktu (amortized time complexity) untuk penyisipan berurutan adalah O(1).
Kenapa O(1) Amortized? Karena realokasi O(N) hanya terjadi sesekali. Jika kita menyisipkan N elemen, total waktu yang dihabiskan untuk realokasi mungkin hanya sebanding dengan N (karena total salinan yang dilakukan sebanding dengan 1 + 2 + 4 + ... + N/2, yang mendekati 2N). Oleh karena itu, rata-rata biaya per penyisipan adalah konstan.
| Operasi | Waktu (Statis & Dinamis) | Keterangan |
|---|---|---|
| Akses (A[i]) | O(1) | Sangat cepat, hitung alamat langsung. |
| Sisip/Hapus (Akhir) | O(1) | Tidak perlu pergeseran data. |
| Sisip/Hapus (Tengah/Awal) | O(N) | Membutuhkan pergeseran semua elemen berikutnya. |
| Realokasi (Dinamis) | O(N) | Membutuhkan penyalinan seluruh N elemen. |
Larik adalah struktur data dasar yang berfungsi sebagai blok bangunan untuk mengimplementasikan banyak struktur data yang lebih abstrak dan kompleks.
Stack (Tumpukan): Konsep LIFO (Last-In, First-Out) dapat dengan mudah diimplementasikan menggunakan larik. Operasi push (sisip) dan pop (hapus) hanya terjadi di satu ujung, yang disebut TOP. Karena modifikasi hanya terjadi di akhir larik, baik push maupun pop adalah operasi O(1) yang sangat cepat.
Queue (Antrian): Konsep FIFO (First-In, First-Out) juga dapat diimplementasikan menggunakan larik. Namun, jika kita menggunakan larik standar, operasi dequeue (pengambilan elemen depan) akan sangat mahal, karena ia menghapus elemen pada indeks 0, memaksa pergeseran seluruh N-1 elemen (O(N)).
Untuk menghindari biaya O(N) ini, antrian biasanya diimplementasikan menggunakan Circular Array (Larik Melingkar). Dalam larik melingkar, indeks depan dan belakang (front dan rear) "membungkus" kembali ke awal ketika mereka mencapai batas larik, memungkinkan operasi enqueue dan dequeue menjadi O(1).
Dalam banyak bahasa, string hanyalah larik dari karakter. Sifat kontigu larik sangat penting di sini, memungkinkan string diakses dan diproses secara sangat efisien, terutama oleh fungsi-fungsi pemrosesan string tingkat rendah.
Larik juga sering digunakan sebagai buffer (penyangga) untuk I/O (Input/Output). Data yang masuk dari jaringan atau disk biasanya dimuat ke dalam blok memori kontigu (larik byte) sebelum diproses lebih lanjut.
Jika sebuah larik diurutkan (misalnya, secara ascending), kita dapat memanfaatkan teknik pencarian yang jauh lebih cepat daripada pencarian linier O(N).
Pencarian Biner (Binary Search) adalah algoritma yang hanya bekerja pada larik terurut. Ia berulang kali membagi ruang pencarian menjadi dua, secara signifikan mengurangi jumlah perbandingan yang diperlukan. Kompleksitas waktu pencarian biner adalah O(log N). Ini adalah peningkatan besar dibandingkan O(N), terutama untuk larik yang sangat besar. Misalnya, mencari di larik 1 juta elemen hanya memerlukan maksimum 20 langkah dengan pencarian biner, sementara pencarian linier bisa memakan waktu 1 juta langkah.
Pseudocode Dasar Pencarian Biner:
FUNGSI CariBiner (Larik A, Nilai Target, Low, High)
JIKA Low > High MAKA
KEMBALIKAN -1 // Tidak Ditemukan
AKHIR JIKA
Mid = (Low + High) / 2
JIKA A[Mid] = Target MAKA
KEMBALIKAN Mid
JIKA A[Mid] < Target MAKA
// Cari di setengah kanan
KEMBALIKAN CariBiner(A, Target, Mid + 1, High)
LAIN
// Cari di setengah kiri
KEMBALIKAN CariBiner(A, Target, Low, Mid - 1)
AKHIR JIKA
AKHIR FUNGSI
Hash table, atau peta (map/dictionary), adalah struktur data yang menyediakan akses O(1) berdasarkan kunci (key). Inti dari hash table adalah larik. Larik ini bertindak sebagai tempat penyimpanan (bucket array).
Ketika sebuah kunci di-hash, hasilnya adalah indeks numerik yang menunjuk langsung ke salah satu lokasi dalam larik ini. Efisiensi hash table secara langsung bergantung pada kualitas fungsi hash dan efisiensi akses ke larik dasarnya.
Untuk mendemonstrasikan kompleksitas larik multi-dimensi, kita akan membahas secara mendalam operasi-operasi yang diterapkan pada matriks 2D, yang merupakan aplikasi larik yang sangat umum di bidang komputasi ilmiah dan grafika.
Perkalian matriks adalah salah satu operasi paling intensif komputasi yang menggunakan larik 2D. Untuk mengalikan dua matriks, A (ukuran M x P) dan B (ukuran P x N), hasilnya adalah matriks C (ukuran M x N). Syarat mutlaknya adalah jumlah kolom matriks A harus sama dengan jumlah baris matriks B (P).
Perhitungan setiap elemen C[i][j] melibatkan penjumlahan hasil perkalian elemen-elemen dari baris i di matriks A dengan elemen-elemen dari kolom j di matriks B.
Kompleksitas waktu untuk perkalian matriks standar (algoritma naive) adalah O(M * P * N). Jika matriks adalah persegi (N x N), kompleksitasnya adalah O(N³).
Pseudocode Perkalian Matriks C = A * B:
PROSEDUR KaliMatriks (A[M][P], B[P][N], C[M][N])
UNTUK i DARI 0 SAMPAI M-1 LAKUKAN // Loop Baris Matriks Hasil C
UNTUK j DARI 0 SAMPAI N-1 LAKUKAN // Loop Kolom Matriks Hasil C
C[i][j] = 0 // Inisialisasi elemen hasil
// Loop K: Iterasi melalui P (dimensi tengah)
UNTUK k DARI 0 SAMPAI P-1 LAKUKAN
C[i][j] = C[i][j] + ( A[i][k] * B[k][j] )
AKHIR UNTUK
AKHIR UNTUK
AKHIR UNTUK
AKHIR PROSEDUR
Tiga lapis perulangan bersarang inilah yang memberikan kompleksitas kubik O(N³), menyoroti betapa cepatnya waktu komputasi dapat meningkat seiring bertambahnya dimensi larik yang diproses.
Operasi transpose melibatkan penukaran baris dengan kolom. Jika matriks A adalah M x N, maka transpose A (ditulis Aᵀ) adalah N x M. Transpose sangat penting dalam aljabar linier dan sering digunakan dalam pembelajaran mesin dan grafika.
Untuk mendapatkan Aᵀ[i][j], kita cukup mengambil elemen A[j][i].
Pseudocode Transpose:
PROSEDUR TransposeMatriks (A[M][N], T[N][M])
UNTUK i DARI 0 SAMPAI M-1 LAKUKAN // Baris A
UNTUK j DARI 0 SAMPAI N-1 LAKUKAN // Kolom A
T[j][i] = A[i][j]
AKHIR UNTUK
AKHIR UNTUK
AKHIR PROSEDUR
Kompleksitas operasi transpose adalah O(M*N), atau O(Total Elemen), yang relatif efisien. Namun, implementasi in-place (transpose tanpa menggunakan matriks baru) untuk matriks non-persegi jauh lebih rumit, melibatkan pengelompokan siklus.
Meskipun larik 2D standar harus berbentuk persegi panjang (semua baris memiliki jumlah kolom yang sama), dalam beberapa bahasa pemrograman (seperti Java atau C++ dengan pointer), dimungkinkan untuk membuat Larik Ragged.
Larik ragged adalah larik dari larik, di mana setiap larik bagian (baris) dapat memiliki panjang yang berbeda. Secara memori, ini adalah larik 1D dari pointer, di mana setiap pointer menunjuk ke awal dari larik 1D lain yang ukurannya berbeda.
Keuntungan: Menghemat memori karena hanya dialokasikan ruang yang benar-benar dibutuhkan, terutama berguna ketika data bersifat sparse (jarang).
Kerugian: Mengakses elemen menjadi sedikit lebih lambat (membutuhkan dua kali dereferensi pointer), dan perhitungan alamat menjadi lebih kompleks karena tidak dapat dihitung menggunakan formula linier tunggal.
Inti dari larik adalah alokasi memori yang kontigu. Memahami implikasi dari alokasi ini sangat penting untuk pemrograman tingkat lanjut.
Prosesor modern menggunakan memori cache yang kecil dan sangat cepat untuk menyimpan data yang baru saja diakses atau kemungkinan besar akan diakses berikutnya. Karena larik menyimpan data secara berdekatan, ketika program mengakses A[i], hampir pasti elemen A[i+1], A[i+2], dst., juga akan dimuat ke dalam cache (ini disebut spatial locality).
Fenomena cache locality ini membuat penelusuran (traversal) larik menjadi sangat cepat, jauh lebih cepat daripada menelusuri struktur data non-kontigu seperti linked list, bahkan jika kompleksitas waktunya sama-sama O(N). Kecepatan akses memori, bukan hanya jumlah operasi, seringkali menjadi penentu kinerja riil.
Kebutuhan akan alokasi kontigu menimbulkan masalah pada sistem dengan memori yang terfragmentasi. Jika kita mencoba mengalokasikan larik yang sangat besar (misalnya, beberapa gigabyte), sistem operasi mungkin kesulitan menemukan blok memori tunggal yang cukup besar dan tidak terputus, meskipun total memori bebas yang tersedia mungkin mencukupi. Ini adalah salah satu batasan praktis dari larik.
Struktur data lain seperti linked list atau struktur data berbasis pohon tidak memiliki batasan ini karena mereka dapat tersebar di seluruh memori (non-kontigu).
Larik disebut sparse jika sebagian besar elemennya memiliki nilai nol (atau nilai default/kosong). Jika kita menggunakan larik standar untuk menyimpan data sparse, memori akan sangat terbuang untuk menyimpan nilai nol yang tidak informatif.
Contoh umum adalah matriks yang sangat besar di mana 99% selnya kosong. Dalam kasus ini, programmer harus beralih dari larik 2D ke representasi yang lebih efisien, seperti:
Keputusan untuk beralih dari representasi larik standar menunjukkan batasan larik ketika efisiensi ruang menjadi perhatian utama, bukan hanya efisiensi waktu akses O(1).
Peran larik meluas ke hampir setiap bidang pemrograman modern, mulai dari tingkat rendah hingga aplikasi tingkat tinggi.
Sinyal audio (sampel suara) atau sinyal gambar (intensitas piksel) adalah data berurutan yang secara alami disimpan dalam larik 1D. Filter digital (seperti convolution) bekerja dengan memproses urutan nilai ini, dan sifat kontigu larik memastikan data dapat dioperasikan secara cepat oleh prosesor DSP.
Meskipun basis data menggunakan struktur yang jauh lebih kompleks untuk penyimpanan data utamanya (misalnya, B-Trees), indeks dasar yang digunakan untuk memetakan ID catatan ke lokasi fisik (atau virtual) sering kali dikelola melalui tabel atau larik hash yang memerlukan akses cepat.
Semua algoritma pengurutan klasik—termasuk Quick Sort, Merge Sort, dan Heap Sort—semuanya memerlukan larik sebagai wadah data utama. Misalnya, Merge Sort memecah larik menjadi sub-larik kecil dan menggabungkannya kembali, memanfaatkan kemampuan larik untuk penelusuran dan sub-pengindeksan yang mudah.
Teknik pemrograman dinamis (Dynamic Programming) sering bergantung pada penyimpanan hasil sub-masalah dalam tabel (larik 2D) untuk menghindari perhitungan berulang. Larik menyediakan cara tercepat untuk mencari solusi sub-masalah yang sudah dihitung sebelumnya.
Dalam C atau C++, meskipun secara logis kita mendefinisikan larik sebagai blok kontigu, bagaimana elemen disusun di dalam memori dapat dipengaruhi oleh batasan perangkat keras (data alignment). Prosesor bekerja paling efisien ketika data diatur pada batas memori tertentu (misalnya, kelipatan 4 atau 8 byte).
Ketika larik terdiri dari struktur (struct) atau objek, kompilator mungkin menyisipkan byte kosong (padding) di antara elemen-elemen untuk memastikan setiap elemen dimulai pada alamat yang dioptimalkan. Hal ini dapat sedikit meningkatkan ukuran total larik yang dialokasikan, meskipun secara logis dianggap kontigu.
Larik adalah struktur yang ideal untuk pemrosesan paralel dan instruksi SIMD (Single Instruction, Multiple Data). Prosesor modern dapat menggunakan instruksi vektor untuk melakukan operasi yang sama pada beberapa elemen larik secara simultan.
Karena elemen larik tersimpan bersebelahan, prosesor dapat memuat blok data besar (misalnya, 8 atau 16 integer) dan memprosesnya sekaligus, menghasilkan peningkatan kinerja yang dramatis dalam tugas-tugas seperti perkalian matriks, pemrosesan citra, atau operasi aritmatika besar-besaran.
Dalam bahasa seperti Python (List) atau JavaScript (Array), implementasi "larik" sebenarnya adalah larik dinamis yang jauh lebih fleksibel, namun dengan biaya kinerja.
Untuk komputasi numerik intensif di Python, komunitas beralih ke pustaka seperti NumPy, yang menggunakan struktur data ndarray, yang secara internal adalah implementasi larik statis C yang homogen dan kontigu, memaksimalkan kecepatan akses dan memanfaatkan vektorisasi.
Larik adalah struktur data yang paling kuno, namun hingga hari ini, ia tetap menjadi struktur yang paling fundamental dan paling banyak digunakan. Keunggulan utamanya—akses cepat O(1) yang didorong oleh alokasi memori kontigu—sulit ditandingi oleh struktur data lain dalam kasus penggunaan yang menuntut kinerja.
Meskipun tantangan terkait penyisipan dan penghapusan di tengah (O(N)) atau kebutuhan akan ukuran awal yang tepat (pada larik statis) tetap ada, larik telah beradaptasi melalui implementasi dinamis dan larik melingkar. Pemahaman yang mendalam tentang bagaimana larik memetakan data logis ke memori fisik adalah salah satu pengetahuan dasar yang membedakan seorang programmer handal dari seorang pemula.
Dari komputasi ilmiah yang memerlukan perkalian matriks yang intensif, hingga antarmuka pengguna grafis yang mengelola jutaan piksel, efisiensi dan kesederhanaan operasional larik memastikan bahwa ia akan terus menjadi fondasi utama bagi arsitektur perangkat lunak yang cepat dan andal di masa depan.