MAKALAH METODOLOGI PEMROGRAMAN

Tugas Ini Disusun Guna Memenuhi Tugas Mata Kuliah Struktur Data
Dosen Pengampu : Bapak Muhaimin Hasanudin ,S.T., M.Kom.

Disusun Oleh :
Kelompok 4
Anggota : 1. M Fari Artha Yudha (202031048)
2. Ufie Rahma (202031068)
3. Puput Amaliyah (202031069)

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TELEMATIKA ENERGI
INSTITUT TEKNOLOGI PLN
2021/2022
 METODOLOGI PEMROGRAMAN
Metodologi pemrograman berurusan dengan metode yang berbeda untuk merancang
program. Ini akan mengajari Anda cara memprogram secara efisien. Buku ini membatasi diri pada
dasar-dasar pemrograman dalam C dan C++, dengan asumsi bahwa Anda sudah familiar dengan
sintaks C dan C++ dan dapat menulis, men-debug, dan menjalankan program dalam C dan C++.
Diskusi dalam bab ini menguraikan pentingnya penataan program, tidak hanya data yang berkaitan
dengan solusi masalah tetapi juga program yang beroperasi pada data.

Data adalah entitas dasar atau fakta yang digunakan dalam proses perhitungan atau
manipulasi. Ada dua jenis data seperti data numerik dan alfanumerik. Bilangan bulat dan angka
floating-point adalah tipe data numerik dan string adalah data alfanumerik Tipe. Data mungkin
tunggal atau sekumpulan nilai, dan harus diatur dengan cara tertentu. Organisasi atau penataan
data ini akan memiliki dampak besar pada efisiensi program.
 Daftar Isi
1.1 Perkenalan Struktur Data ...................................................................................................... 1

1.2 Algoritma ............................................................................................................................. 2

1.3 Teknik Penyempurnaan Bertahap ......................................................................................... 2

1.4 Pemrograman Modular ......................................................................................................... 3

1.5 Desain Algoritma Top-Down ............................................................................................... 4

1.6 Desain Algoritma Bottop-Up ................................................................................................ 5

1.7 Pemrograman Terstruktur .................................................................................................... 5

1.8 Analisa Algoritma ................................................................................................................ 6

1.8.1. Komleksitas Ruang .................................................................................................... 7

1.8.2. Kompleksitas Waktu ................................................................................................... 8

1.8.3. Kompleksitas Amstrong............................................................................................. 10

1.9 Trade Off Ruang-Waktu ...................................................................................................... 10

1.10 Notasi Big “OH” ................................................................................................................ 1 1

1.11 Batasan dari Notasi BIG “OH” ......................................................................................... 12

1.12 Klasifikasi Struktur Data.................................................................................................... 13

1.13 Array .................................................................................................................................. 14

1.13.1. Array Satu Dimensi ................................................................................................ 14

1.13.2. Array Multi Dimensi .............................................................................................. 18

1.13.3. Array Jarang ........................................................................................................... 20

1.14 Vektor ............................................................................................................................... 24

1.15 List .................................................................................................................................... 27

1.16 File dan Records ............................................................................................................... 28

1.17 Karakteristrik String .......................................................................................................... 28

1.17.1. Representasi String ................................................................................................ 29

1.17.2. Sub String ............................................................................................................... 31

1.1. Perkenalan Struktur Data

Struktur data adalah representasi struktural dari hubungan logis antara elemen data.
Dengan kata lain struktur data adalah cara mengatur item data dengan mempertimbangkan
hubungannya satu sama lain.

Struktur data terutama menentukan organisasi data terstruktur, dengan menyediakan

mengakses metode dengan tingkat asosiatif yang benar. Struktur data mempengaruhi desain dari
kedua aspek struktural dan fungsional dari sebuah program.

Algoritma + Struktur Data = Program

Struktur data adalah blok bangunan dari sebuah program; di sini pemilihan struktur data
tertentu akan membantu programmer untuk merancang program yang lebih efisien sebagai:
kompleksitas dan volume masalah yang diselesaikan oleh komputer terus meningkat dari hari ke
hari oleh hari. Para programmer harus berusaha keras untuk memecahkan masalah ini. Jika
masalahnya adalah dianalisis dan dibagi menjadi sub masalah, tugas akan jauh lebih mudah yaitu,
membagi, menaklukkan dan menggabungkan.

Masalah yang kompleks biasanya tidak dapat dibagi dan diprogram oleh sekumpulan
modul kecuali solusinya terstruktur atau terorganisir. Ini karena ketika kita membagi yang besar
masalah menjadi sub masalah, sub masalah ini akan diprogram oleh pemrogram atau kelompok
pemrogram yang berbeda. Tetapi semua programmer harus mengikuti standar metode struktural
sehingga membuat integrasi modul-modul ini menjadi mudah dan efisien. Seperti jenis penataan
hierarki modul program dan sub modul seharusnya tidak hanya mengurangi kompleksitas dan
mengontrol aliran pernyataan program tetapi juga mempromosikan struktur informasi yang tepat.
Dengan memilih struktur tertentu (atau struktur data) untuk item data, item data tertentu menjadi
teman sementara yang lain kehilangan relasinya.

1
1.2. Algoritma

Algoritma adalah urutan instruksi yang terbatas langkah demi langkah. untuk memecahkan
masalah komputasi yang terdefinisi dengan baik. Yaitu, dalam praktiknya untuk memecahkan
masalah kehidupan nyata yang kompleks: pertama-tama kita harus mendefinisikan masalahnya.
langkah kedua adalah merancang algoritma untuk memecahkan masalah itu.

Menulis dan mengeksekusi program dan kemudian mengoptimalkannya mungkin efektif

untuk program kecil. optimasi program secara langsung berkaitan dengan desain algoritma. tetapi
untuk program yang besar, setiap bagian dari program harus diatur dengan baik sebelum menulis
program. ada beberapa langkah perbaikan yang terlibat ketika masalah dikonversi ke program:
metode ini disebut metode perbaikan bertahap. ada dua pendekatan untuk desain algoritma; mereka
adalah desain algoritma top-down dan bottom-up.

1.3. Teknik Penyempurnaan Bertahap

Kita dapat menulis algoritma informal, jika kita memiliki model matematika yang sesuai
untuk suatu masalah. versi awal dari algoritma akan berisi pernyataan umum, yaitu: instruksi
informal. kemudian kita ubah algoritma informal ini menjadi algoritma formal. yaitu, instruksi
yang lebih pasti dengan menerapkan sintaks dan semantik labguage pemrograman apa pun secara
parsial. akhirnya sebuah program dapat dikembangkan dengan mengubah algoritma formal dengan
manual bahasa pemrograman

Dari pembahasan di atas kita telah memahami bahwa ada beberapa langkah untuk
mencapai suatu program dari model matematika. dalam setiap langkah ada penyempurnaan (atau
konversi). formalisasi sampai kita tiba di sebuah program yang artinya secara formal didefinisikan
oleh manual bahasa pemrograman yang disebut teknik penyempurnaan bertahap.

2
Metodologi Pemrograman

1. Pada tahap pertama, pemodelan, kami mencoba untuk mewakili masalah menggunakan
yang sesuai model matematika seperti grafik, pohon dll. Pada tahap ini, solusi untuk
masalah adalah algoritma yang diekspresikan dengan sangat informal.
2. Pada tahap berikutnya, algoritme ditulis dalam bahasa semu (atau algo rithm formal) yaitu,
campuran dari konstruksi bahasa pemrograman apa pun dan kurang untuk pernyataan
bahasa Inggris mal. Operasi yang akan dilakukan pada berbagai jenis data menjadi tetap.
3. Pada tahap akhir kami memilih implementasi untuk setiap tipe data abstrak dan tulis
prosedur untuk berbagai operasi pada tipe tersebut. Sisanya dalam pernyataan formal
dalam algoritma bahasa semu digantikan oleh (atau bahasa pemrograman) kode C/C++.

Bagian berikut akan membahas metodologi pemrograman yang berbeda untuk merancang sebuah
program.

1.4. Pemrograman Modular

Pemrograman Modular sangat prosedural. Fokusnya sepenuhnya pada penulisan kode

(fungsi). Data pasif dalam Pemrograman Modular. Kode apa pun dapat mengakses konten setiap
struktur data yang diteruskan ke sana. (Tidak ada konsep enkapsulasi.) Modular Programming
adalah tindakan merancang dan menulis program sebagai fungsi, yang masing-masing melakukan
fungsi tunggal yang terdefinisi dengan baik, dan yang memiliki interaksi minimal di antara mereka.
Itu adalah, isi dari setiap fungsi kohesif, dan ada hubungan yang rendah antar fungsi.

3
 Pemrograman Modular mencegah penggunaan variabel kontrol dan flag dalam parameter;
kehadiran mereka cenderung menunjukkan bahwa penelepon perlu tahu terlalu banyak tentang
caranya fungsi tersebut diimplementasikan. Ini mendorong pemisahan fungsionalitas menjadi dua
jenis: fungsi "Master" mengontrol aliran program dan terutama berisi panggilan ke fungsi "Slave"
yang menangani detail tingkat rendah, seperti memindahkan data antar struktur.

Dua metode dapat digunakan untuk pemrograman modular. Mereka dikenal sebagai top-
down dan bottom-up, yang telah kita bahas pada bagian di atas. Terlepas dari apakah metode top-
down atau bottom-up digunakan, hasil akhirnya adalah program modular. Akhir ini hasil penting,
karena tidak semua kesalahan dapat dideteksi pada saat pengujian awal. Kemungkinan masih ada
bug dalam program. Jika kesalahan ditemukan setelah program seharusnya telah diuji sepenuhnya,
maka modul yang bersangkutan dapat diisolasi dan diuji ulang oleh mereka.

Terlepas dari metode desain yang digunakan, jika suatu program telah ditulis dalam
modular bentuk, lebih mudah untuk mendeteksi sumber kesalahan dan mengujinya secara terpisah,
daripada jika program ditulis sebagai satu fungsi.

1.5. Desain Algoritma Top-Down

Prinsip-prinsip desain top-down menentukan bahwa program harus dibagi menjadi: modul
utama dan modul terkait. Setiap modul juga harus dibagi menjadi sub modul sesuai dengan
rekayasa perangkat lunak dan gaya pemrograman. Pembagian modul proses sampai modul hanya
terdiri dari proses dasar yang secara intrinsik dipahami dan tidak dapat dibagi lagi.

4
Desain algoritma top-down adalah teknik untuk mengatur dan mengkodekan program dalam di
mana hierarki modul digunakan, dan memecah spesifikasi menjadi lebih sederhana dan potongan
yang lebih sederhana, masing-masing memiliki satu entri dan satu titik keluar, dan di mana control
dilewatkan ke bawah melalui struktur tanpa cabang tanpa syarat ke tingkat yang lebih tinggi dari
struktur. Itu adalah pemrograman top-down cenderung menghasilkan modul yang berdasarkan
fungsionalitas, biasanya berupa fungsi atau prosedur atau metode.

Di (C), ide desain top-down dilakukan menggunakan fungsi. Program C terbuat dari satu atau lebih
fungsi, satu dan hanya satu yang harus diberi nama utama. Eksekusi dari program selalu dimulai
dan diakhiri dengan main, tetapi dapat memanggil fungsi lain untuk melakukan fungsi khusus.

1.6. Desain Algoritma Bottom-Up

Desain algoritma bottom-up adalah kebalikan dari desain top-down. Ini mengacu pada
gaya pemrograman di mana aplikasi dibangun dimulai dengan primitif yang ada dari bahasa
pemrograman, dan membangun fitur yang semakin rumit secara bertahap, sampai semua aplikasi
telah ditulis. Artinya, memulai desain dengan spesifik modul dan membangunnya menjadi struktur
yang lebih kompleks, berakhir di atas.

Metode bottom-up banyak digunakan untuk pengujian, karena masing-masing level

terendah fungsi ditulis dan diuji terlebih dahulu. Pengujian ini dilakukan oleh fungsi pengujian
khusus yang memanggil fungsi tingkat rendah, menyediakan mereka dengan parameter yang
berbeda dan memeriksa hasil untuk kebenaran. Setelah fungsi tingkat terendah diuji dan
diverifikasi kebenarannya, fungsi tingkat berikutnya dapat diuji. Karena fungsi level terendah
sudah telah diuji, kesalahan yang terdeteksi mungkin disebabkan oleh fungsi tingkat yang lebih
tinggi. Ini proses berlanjut, naik level, hingga akhirnya fungsi utama diuji.

1.7. Pemrograman Terstruktur

Ini adalah gaya pemrograman dan gaya pemrograman ini dikenal dengan beberapa nama:
Dekomposisi prosedural, Pemrograman terstruktur, dll. Pemrograman terstruktur tidak

5
pemrograman dengan struktur tetapi dengan menggunakan jenis struktur kode berikut untuk
menulis program:

1. Urutan pernyataan yang dieksekusi secara berurutan

2. Eksekusi pernyataan bersyarat (yaitu, pernyataan “if”)
3. Looping atau iterasi (yaitu, pernyataan "for, do ... while, dan while")
4. Panggilan subrutin terstruktur (misalnya Fungsi)

Secara khusus, penggunaan bahasa berikut dilarang:

1. Pernyataan “GoTo”
2. “Break” atau “continue” di tengah loop
3. Beberapa titik keluar ke function/procedure/subroutine (yaitu, beberapa pernyataan
"return")
4. Beberapa titik masuk ke function/procedure/subroutine/method.

Dalam gaya pemrograman ini ada risiko besar bahwa detail implementasi dari banyak struktur
data harus dibagi antar fungsi, dan dengan demikian terekspos secara global. Ini pada gilirannya
menggoda fungsi lain untuk menggunakan detail implementasi ini; dengan demikian menciptakan
ketergantungan yang tidak diinginkan antara bagian yang berbeda dari program.

Kerugian utama adalah bahwa semua keputusan yang dibuat dari awal proyek tergantung
secara langsung atau tidak langsung pada spesifikasi aplikasi tingkat tinggi. Ini adalah fakta yang
diketahui bahwa spesifikasi ini cenderung berubah dari waktu ke waktu. Ketika itu terjadi, disana
adalah risiko besar bahwa sebagian besar aplikasi perlu ditulis ulang.

1.8. Analisa Algoritma

Setelah merancang suatu algoritma, itu harus diperiksa dan kebenarannya perlu diprediksi,
ini dilakukan dengan menganalisis algoritma. Algoritma tersebut dapat dianalisis dengan
menelusuri semua instruksi langkah demi langkah, membaca algoritma untuk kebenaran logis, dan
mengujinya pada beberapa data dengan menggunakan teknik matematika untuk membuktikan

6
kebenarannya. Jenis lain dari analisis adalah untuk menganalisis kesederhanaan algoritma.
Artinya, rancang algoritme dalam sederhana sehingga menjadi lebih mudah untuk
diimplementasikan. Namun, yang paling sederhana dan paling cara langsung untuk memecahkan
masalah terkadang bukan yang terbaik. lebih-lebih lagi mungkin ada lebih dari satu algoritma
untuk memecahkan masalah. Pilihan tertentu algoritma tergantung pada analisis dan pengukuran
kinerja berikut:

1. Kompleksitas Ruang
2. Kompleksitas Waktu

1.8.1. Kompleksitas Ruang

Analisis kompleksitas ruang dari suatu algoritma atau program adalah jumlah memorinya perlu
dijalankan sampai selesai. Beberapa alasan untuk mempelajari kompleksitas ruang adalah:

1. Jika program akan dijalankan pada sistem multi-pengguna, mungkin diperlukan untuk
menentukan: jumlah memori yang akan dialokasikan untuk program.
2. Kami mungkin tertarik untuk mengetahui terlebih dahulu apakah memori yang cukup
adalah tersedia untuk menjalankan program.
3. Mungkin ada beberapa kemungkinan solusi dengan kebutuhan ruang yang berbeda.
4. Dapat digunakan untuk memperkirakan ukuran masalah terbesar yang dapat dipecahkan
oleh suatu program.

Ruang yang dibutuhkan oleh sebuah program terdiri dari komponen-komponen berikut:

❖ Ruang instruksi: Ruang yang dibutuhkan untuk menyimpan versi program yang dapat
dieksekusi dan itu tetap.
❖ Ruang data: Ruang yang dibutuhkan untuk menyimpan semua konstanta, nilai variabel dan
memiliki lebih lanjut dua komponen:

(a) Ruang yang dibutuhkan oleh konstanta dan variabel sederhana. Ruang ini tetap.

(b) Ruang yang dibutuhkan oleh variabel struktural berukuran tetap, seperti array dan
struktur.

7
 (c) Ruang yang dialokasikan secara dinamis. Ruang ini biasanya bervariasi.

❖ Ruang tumpukan lingkungan: Ruang ini diperlukan untuk menyimpan informasi untuk
dilanjutkan fungsi yang ditangguhkan (sebagian selesai). Setiap kali suatu fungsi dipanggil
data berikut disimpan di tumpukan lingkungan:

(a) Alamat pengirim: yaitu, dari mana ia harus melanjutkan setelah menyelesaikan disebut
fungsi.

(b) Nilai semua variabel utama dan nilai parameter formal dalam fungsi yang dipanggil.

Jumlah ruang yang dibutuhkan oleh fungsi rekursif disebut tumpukan rekursi ruang angkasa.
Untuk setiap fungsi rekursif, ruang ini tergantung pada ruang yang dibutuhkan oleh lokal variabel
dan parameter formal. Selain itu, ruang ini tergantung pada maksimum kedalaman rekursi yaitu,
jumlah maksimum panggilan rekursif bersarang.

1.8.2. Kompleksitas Waktu

Kompleksitas waktu dari suatu algoritma atau program adalah jumlah waktu yang
dibutuhkan untuk lari sampai selesai. Waktu yang tepat akan tergantung pada implementasi
algoritma, bahasa pemrograman, optimalisasi kemampuan compiler yang digunakan, kecepatan
CPU, karakteristik/spesifikasi perangkat keras lainnya dan sebagainya. Untuk mengukur
kompleksitas waktu akurat, kita harus menghitung semua jenis operasi yang dilakukan dalam suatu
algoritma. Jika kita tahu waktu untuk masing-masing operasi primitif yang dilakukan di komputer
tertentu, kita dapat dengan mudah menghitung waktu yang dibutuhkan oleh suatu algoritma untuk
menyelesaikan eksekusinya. Kali ini akan bervariasi dari mesin ke mesin. Dengan menganalisis
suatu algoritme, sulit untuk menemukan waktu yang tepat diperlukan. Untuk mengetahui
kompleksitas waktu yang tepat, kita perlu mengetahui instruksi yang tepat yang dijalankan oleh
perangkat keras dan waktu yang dibutuhkan untuk instruksi tersebut. Kompleksitas waktu juga
tergantung pada jumlah data yang dimasukkan ke suatu algoritma. Tapi kita bisa menghitung
urutan besarnya untuk waktu yang dibutuhkan.

Artinya, niat kami adalah untuk memperkirakan waktu eksekusi suatu algoritma terlepas
dari mesin komputer yang akan digunakan. Di sini, metode yang lebih canggih adalah untuk

8
mengidentifikasi operasi kunci dan menghitung operasi yang dilakukan sampai program
menyelesaikan eksekusinya. Operasi kunci dalam algoritme kami adalah operasi yang
membutuhkan waktu maksimum waktu di antara semua operasi yang mungkin dalam algoritma.
Pendekatan teoritis dan abstrak semacam itu tidak hanya berguna untuk mendiskusikan dan
membandingkan algoritma, tetapi juga berguna untuk meningkatkan solusi untuk masalah praktis.
Kompleksitas waktu sekarang dapat dinyatakan sebagai Fungsi dari jumlah operasi kunci yang
dilakukan. Sebelum kita melanjutkan pembahasan kita, penting untuk memahami analisis laju
pertumbuhan suatu algoritma, seperti yang ditunjukkan pada Gambar. 1.3.

Fungsi yang melibatkan 'n' sebagai eksponen, yaitu, 2n, nn, n! disebut eksponensial fungsi,
yang terlalu lambat kecuali untuk fungsi input ukuran kecil di mana pertumbuhannya kurang dari
atau sama dengan nc , (di mana 'c' adalah konstanta) yaitu; n3, n2, n log2n, n, log2 n dikatakan
polinom. Algoritma dengan waktu polinomial dapat memecahkan masalah berukuran wajar jika
konstanta dalam eksponennya kecil.

Ketika kami menganalisis suatu algoritma, itu tergantung pada data input, ada tiga kasus:

1. Kasus terbaik
2. Kasus rata-rata
3. Kasus terburuk

Dalam kasus terbaik, jumlah waktu yang diharapkan dari sebuah program untuk mengambil yang
terbaik data masukan yang mungkin.

9
Dalam kasus rata-rata, jumlah waktu yang diharapkan untuk diambil oleh suatu program data
masukan tipikal (atau rata-rata).

Dalam kasus terburuk, jumlah waktu yang dibutuhkan sebuah program untuk kemungkinan
terburuk konfigurasi masukan.

1.8.3. Kompleksitas Amstrong

Dalam banyak situasi, struktur data tunduk pada urutan instruksi daripada satu set instruksi.
Dalam urutan ini, satu instruksi dapat melakukan tertentu modifikasi yang berdampak pada
instruksi lain dalam urutan pada waktu berjalan diri. Misalnya dalam for loop ada 100 instruksi
dalam pernyataan if. Jika kondisi salah maka 100 instruksi ini tidak akan dieksekusi. Jika kita
menerapkan kompleksitas waktu analisis dalam kasus terburuk, seluruh urutan dianggap
menghitung efisiensi, yaitu analisis efisiensi yang terlalu besar dan tidak realistis. Tapi ketika kita
menerapkan diamortisasi kompleksitas, kompleksitas dihitung ketika instruksi dieksekusi (yaitu,
ketika jika kondisi benar)

Di sini waktu yang diperlukan untuk melakukan urutan operasi (terkait) dirata-ratakan
semua operasi yang dilakukan. Analisis diamortisasi dapat digunakan untuk menunjukkan bahwa
rata-rata biaya operasi kecil, jika rata-rata atas urutan operasi, meskipun operasi sederhana
mungkin mahal. Analisis yang diamortisasi menjamin kinerja rata-rata dari setiap operasi dalam
kasus terburuk.

1.9. Trade Off Ruang-Waktu

Mungkin ada lebih dari satu pendekatan (atau algoritma) untuk memecahkan masalah.
Terbaik algoritma (atau program) untuk memecahkan masalah yang diberikan adalah salah satu
yang membutuhkan lebih sedikit ruang dalam memori dan membutuhkan waktu lebih sedikit untuk
menyelesaikan eksekusinya. Tetapi dalam praktiknya, tidak selalu mungkin untuk mencapai kedua
tujuan tersebut.

Satu algoritma mungkin memerlukan lebih banyak ruang tetapi lebih sedikit waktu untuk
menyelesaikan eksekusinya sementara algoritma lainnya membutuhkan lebih sedikit ruang waktu

10
tetapi membutuhkan lebih banyak waktu untuk menyelesaikan eksekusinya. Jadi, kita mungkin
harus mengorbankan satu dengan mengorbankan yang lain. Jika ruang adalah kendala kita, maka
kita harus memilih program yang membutuhkan lebih sedikit ruang dengan biaya lebih banyak
waktu eksekusi. Di sisi lain, jika waktu adalah kendala kita seperti di sistem waktu nyata, kita
harus memilih program yang membutuhkan waktu lebih sedikit untuk menyelesaikan eksekusinya
dengan biaya lebih banyak ruang.

1.10. Notasi Big “OH”

Big Oh adalah skema karakteristik yang mengukur properti dari kompleksitas algoritma
persyaratan kinerja dan/atau memori. Kompleksitas algoritma dapat ditentukan dengan
menghilangkan faktor konstan dalam analisis algoritma. Jelas, kerumitannya fungsi f(n) dari suatu
algoritma meningkat dengan meningkatnya 'n'.

Mari kita cari tahu kompleksitas algoritma dengan menganalisis algoritma pencarian
sekuensial. Dalam algoritma pencarian sekuensial, kami hanya mencoba mencocokkan nilai target
dengan setiap nilai dalam memori. Proses ini akan terus berlanjut sampai kita menemukan
kecocokan atau finish memindai seluruh elemen dalam array. Jika array berisi elemen 'n',
maksimum kemungkinan jumlah perbandingan dengan nilai target akan menjadi 'n' yaitu, kasus
terburuk. Itu adalah nilai target akan ditemukan pada posisi ke-n dari array.

f (n) = n

yaitu, kasus terburuk adalah ketika suatu algoritma membutuhkan jumlah maksimum
iterasi atau langkah-langkah untuk mencari dan mengetahui nilai target dalam array.

Kasus terbaik adalah ketika jumlah langkah kurang mungkin. Jika nilai target adalah
ditemukan dalam larik pencarian berurutan dari posisi pertama (yaitu, kita perlu membandingkan
target nilai dengan hanya satu elemen dari array)—kami telah menemukan elemen hanya dengan
mengeksekusi satu iterasi (atau dengan pernyataan yang paling tidak mungkin)

f (n) = 1

11
 Kasus rata-rata berada di antara dua ekstrem ini (yaitu, terbaik dan terburuk). Jika sasaran
nilai ditemukan pada posisi ke-n/2, rata-rata kita perlu membandingkan nilai target dengan hanya
setengah dari elemen dalam array, jadi

f (n) = n/2

Fungsi kompleksitas f(n) dari suatu algoritma meningkat dengan meningkatnya 'n'.
Fungsinya f (n)= O(n) dapat dibaca sebagai “f dari n adalah besar Oh dari n” atau sebagai “f (n)
adalah orde n”. Jumlah seluruhnya waktu berjalan (atau kompleksitas waktu) termasuk inisialisasi
dan beberapa iterasi lainnya pernyataan melalui loop.

Bentuk umum dari teorema tersebut adalah:

f (n) = cknk + ck–1nk –1 + ck–2nk–2 + ...... + c2n2 + c1n1 + c0n0

Dimana konstanta ck > 0 Maka, f (n) = O(nk)

Berdasarkan representasi kompleksitas waktu dari notasi Oh besar, algoritme dapat dikategorikan
sebagai:

1. Waktu konstan O (1)

2. Waktu logaritma Olog (n)
3. Waktu linier O (n)
4. Waktu polinomial O (nc)
5. Waktu eksponensial O (cn)

1.11. Batasan dari Notasi BIG “OH”

Notasi big oh memiliki dua batasan dasar berikut:

1. Tidak ada upaya untuk meningkatkan metodologi pemrograman. Notasi Oh Besar tidak
membahas cara dan sarana untuk meningkatkan efisiensi program, tetapi membantu untuk
menganalisis dan menghitung efisiensi (dengan menemukan kompleksitas waktu) dari
program.
2. Itu tidak menunjukkan potensi konstanta. Misalnya, satu algoritma adalah mengambil
1000n2 waktu untuk mengeksekusi dan waktu n3 lainnya. Algoritma pertama adalah

12
 O(n2), yang menyiratkan bahwa itu akan memakan waktu lebih sedikit daripada algoritma
lain yaitu O(n3). Namun dalam eksekusi aktual algoritma kedua akan lebih cepat untuk n
< 1000.

Kami akan menganalisis dan merancang masalah dalam struktur data. Seperti yang telah kita bahas
untuk mengembangkan program algoritma, kita harus memilih struktur data yang sesuai untuk itu
algoritma.

1.12. Klasifikasi Struktur Data

Struktur data secara garis besar dibagi menjadi dua:

1. Struktur data primitif: Ini adalah struktur data dasar dan secara langsung dioperasikan oleh
instruksi mesin, yang berada di tingkat primitif. Mereka adalah bilangan bulat, angka
floating point, karakter, konstanta string, pointer, dll. Struktur data primitif ini menjadi
dasar pembahasan struktur data yang lebih canggih (non-primitif) dalam buku ini.
2. Struktur data non-primitif: Ini adalah struktur data yang lebih canggih yang menekankan
pada penataan sekelompok homogen (tipe yang sama) atau heterogeny (tipe berbeda) item
data. Array, daftar, file, daftar tertaut, pohon, dan grafik termasuk Dalam kategori ini.

13
Gambar 1.4 akan menjelaskan secara singkat klasifikasi lain dari struktur data. Operasi dasar pada
struktur data adalah membuat struktur data (non-primitif); yang dianggap menjadi langkah awal
penulisan program. Misalnya, dalam Pascal, C dan C++, variabelnya adalah dibuat dengan
menggunakan pernyataan deklarasi.

int Int_Variabel;

Dalam C/C++, ruang memori dialokasikan untuk variabel "Int_Variable" ketika di atas pernyataan
deklarasi dijalankan. Itu adalah struktur data yang dibuat. Diskusi tentang struktur data primitif
berada di luar cakupan buku ini. Mari kita pertimbangkan non-primitif struktur data.

1.13. Array

Array paling sering digunakan dalam pemrograman. Masalah matematika seperti matrix,
aljabar dan lain-lain dapat dengan mudah ditangani oleh array. Array adalah kumpulan elemen
data homogen yang dijelaskan oleh satu nama. Setiap elemen array direferensikan oleh variabel
atau nilai subskrip, yang disebut subskrip atau indeks yang diapit tanda kurung.

Jika elemen array direferensikan oleh satu subscript, maka array dikenal sebagai satu array
dimensi atau array linier dan jika dua subskrip diperlukan untuk mereferensikan suatu elemen,
array tersebut dikenal sebagai array dua dimensi dan seterusnya. Secara analog array yang
elemennya direferensikan oleh dua atau lebih subskrip disebut multidimensi susunan.

1.13.1. Array Satu Dimensi

Array satu dimensi (atau array linier) adalah sekumpulan 'jumlah tak terbatas dari homogen'
elemen data seperti:

1. Elemen array direferensikan masing-masing oleh set indeks yang terdiri dari: dari 'n' angka
berurutan.
2. Elemen array disimpan masing-masing di lokasi memori yang berurutan.

'n' jumlah elemen disebut panjang atau ukuran array. Elemen array 'A' dapat dilambangkan dalam
C sebagai:

A [0], A [1], A [2], ...... A [n -1]. 14

Angka 'n' dalam A[n] disebut subskrip atau indeks dan A[n] disebut subskrip variabel. Jika 'n'
adalah 10, maka elemen array A [0], A [1] ......A [9] disimpan secara berurutan lokasi memori
sebagai berikut:

Dalam C, array selalu dapat dibaca atau ditulis melalui loop. Untuk membaca satu dimensi array,
diperlukan satu loop untuk membaca dan menulis array, misalnya:

Untuk membaca array elemen 'n’:

for (i = 0; i < n; i ++)

scanf (“%d”,&a[i]);

Untuk menulis array:

for (i = 0; i < n; i ++)

printf (“%d”, &a[i]);

15
CONTOH PROGRAM yakni (Array 1 Dimensi):

#include <iostream>

using namespace std;

int main(){

int bilangan[10];

int jumlah = 0;

cout<<"====program array 1 dimensi====\n";

for(int i=0; i<10; i++){

cout<<"isi indeks ke ["<<i<<"]= ";

cin>> bilangan[i];

for(int i=0; i<10; i++){

cout<<endl<<"nilai indeks ke ["<<i<<"]= "<<bilangan[i];

for(int i=0; i<10; i++){

jumlah = jumlah + bilangan[i];

16
 cout<<"\ntotal penjumlahan seluruh bilangan : "<<
jumlah;

return 0;

// KELOMPOK 4_STRUKTUR DATA_KELAS B

// M FARI ARTHA YUDHA (202031048)

// UFIE RAHMA (202031068)

// PUPUT AMALIYAH (202031069)

Output :

17
1.13.2. Array Multi Dimensi

Jika kita membaca atau menulis array dua dimensi, diperlukan dua loop. Demikian pula array
dimensi 'n' akan membutuhkan loop 'n'. Struktur dua dimensi array diilustrasikan pada gambar
berikut:

int A [10][10];

Contoh Codingan Array Multi Dimensi :

#include <iostream>
#include <string>

using namespace std;

int main(){
string data_mahasiswa[5][2];
string choice;

18
 cout << " ===== Kelompok 4 =====\n";
cout << "Program penyimpanan data mahasiswa\n\n";

for(int a = 0; a < 5; a++){

cout << "Mahasiswa " << a + 1 << "\n";

cout << "Silakan masukkan nama mahasiswa : ";

cin >> data_mahasiswa[a][0];

cout << "Silakan masukkan NIM mahasiswa : ";

cin >> data_mahasiswa[a][1];

cout << "\n\n";

}

system("cls");

cout << "===== Data Mahasiswa =====\n\n";

for(int a = 0; a < 5; a++){

cout << "=== Mahasiswa " << a + 1 << " ===\n";
cout << "Nama : " << data_mahasiswa[a][0] << "\n";
cout << "NIM : " << data_mahasiswa[a][1] << "\n\n";
}
}

19
Output Array Multi Dimensi :

1.13.3. Array Jarang

Array jarang adalah aplikasi penting dari array. Array jarang adalah array di mana hampir
semua elemen memiliki nilai yang sama (biasanya nol) dan nilai ini adalah konstan. Array jarang
satu dimensi disebut vektor jarang dan array jarang dua dimensi disebut matriks jarang.

Tujuan utama menggunakan array adalah untuk meminimalkan kebutuhan ruang memori
dan untuk meningkatkan kecepatan eksekusi suatu program. Hal ini dapat dicapai dengan
mengalokasikan ruang memori hanya untuk elemen bukan nol.

Misalnya array jarang dapat dilihat sebagai berikut:

20
Kami hanya akan menyimpan elemen bukan nol dalam matriks sparse di atas karena menyimpan
semua elemen dari sparse array akan terdiri dari memory sparse. Elemen bukan nol disimpan
dalam larik formulir.
A[0......n] [1......3]
Di mana 'n' adalah jumlah elemen bukan nol dalam array. Pada Gambar 1.4 di atas 'n = 7'. Larik
spasi yang diberikan pada Gambar 1.4 dapat direpresentasikan dalam larik A [0......7] [1....3]

Elemen A [0][1] dan A [0][2] berisi jumlah baris dan kolom dari susunan yang jarang. A [0][3]
berisi jumlah total elemen bukan nol dalam sparse array A [1][1] berisi jumlah baris di mana
elemen bukan nol pertama ada di susunan yang jarang. A [1][2] berisi nomor kolom dari bukan
nol yang sesuai elemen. A [1][3] berisi nilai elemen bukan nol. Pada Gambar. 1.4, bukan nol
pertama elemen dapat ditemukan di baris ke-1 di kolom ke-3.

21
Contoh Codingan Array Jarang :

#include <iostream>

using namespace std;

int main(){

int row = 10;

int col = 10;

int zero_count = 0;

int data[10][10] = {

{4, 3, 0, 0, 0, 3, 1, 0, 3, 0},

{1, 4, 0, 1, 3, 4, 0, 0, 9, 7},

{5, 0, 2, 0, 2, 3, 0, 1, 0, 9},

{0, 0, 0, 0, 3, 6, 0, 6, 0, 5},

{0, 1, 4, 5, 3, 0, 0, 0, 0, 0},

{0, 4, 7 ,8 ,6, 5, 8, 9, 3, 1},

{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},

{4, 0, 3, 0, 4, 0, 2, 0, 2, 0},

{0, 1, 0, 2, 0, 3, 0, 4, 0, 5},

{9, 0, 8, 0, 7, 0, 6, 0, 5, 0}

};

cout << "===== Kelompok 4 =====\n";

22
 cout << "Program matriks sparse\n\n";

cout << "Matriks :\n";

for(int a = 0; a < row; a++){

for(int b = 0; b < col; b++){

if(data[a][b] == 0){

zero_count++;

cout << data[a][b] << " ";

cout << "\n\n";

cout << "Jumlah angka 0 didalam matriks adalah : " <<

zero_count << "\n";

if(zero_count > (row * col) / 2){

cout << "Ini adalah matriks sparse";

}else{

cout << "Ini bukan matriks sparse";

23
Output Array Jarang :

1.14. Vektor

Vektor adalah kumpulan bilangan terurut satu dimensi. Biasanya, sejumlah lokasi memori
yang berdekatan secara berurutan dialokasikan ke vektor. Ukuran vektor adalah tetap dan, oleh
karena itu, membutuhkan sejumlah lokasi memori yang tetap. Sebuah vektor dapat menjadi kolom
vektor yang mewakili 'n' oleh 1 koleksi terurut, atau vektor baris yang mewakili a 1 oleh 'n' koleksi
yang dipesan.

Vektor kolom muncul secara simbolis sebagai berikut:

24
Sebuah vektor baris muncul secara simbolis sebagai berikut:

A = (A1, A2, A3, ...... An)

Vektor dapat berisi bilangan real atau kompleks. Ketika mereka mengandung bilangan real,
mereka kadang-kadang disebut vektor nyata. Ketika mereka mengandung bilangan kompleks,
mereka adalah disebut vektor kompleks.

Contoh Codingan Vektor :

#include <iostream>

#include <vector>

using namespace std;

int main(){

double banyak_bilangan;

double jumlah = 0;

cout << " ===== Kelompok 4 =====\n";

cout << "Program mencari nilai rata rata\n\n";

cout << "Berapa bilangan yang ingin kamu masukkan? : ";

25
 cin >> banyak_bilangan;

vector <int> bilangan(banyak_bilangan);

system("cls");

for(int a = 0; a < bilangan.size(); a++){

cout << "Masukkan bilangan ke " << a + 1 << " : ";

cin >> bilangan[a];

for(int a = 0; a < bilangan.size(); a++){

jumlah += bilangan[a];

cout << "Rata rata : " << jumlah / banyak_bilangan;

26
Output Vektor :

1.15. List

Seperti yang telah kita bahas, array adalah himpunan terurut, yang terdiri dari sejumlah
elemen. Tidak ada operasi penghapusan atau penyisipan yang dilakukan pada array. Keuntungan
utama lainnya adalah panjangnya yang tetap; kita tidak dapat menambahkan elemen ke array.
Daftar mengatasi semua batasan di atas. Daftar adalah himpunan terurut yang terdiri dari sejumlah
elemen yang bervariasi untuk penyisipan dan penghapusan mana yang dapat dilakukan.

Daftar yang direpresentasikan dengan menampilkan hubungan antara elemen yang

berdekatan dikatakan sebagai daftar linier. Daftar lain dikatakan tidak linier. Daftar dapat
diimplementasikan dengan menggunakan pointer. Setiap elemen disebut sebagai node; oleh karena
itu daftar dapat didefinisikan sebagai kumpulan node seperti yang ditunjukkan di bawah ini:

27
1.16. File Dan Records

File biasanya berupa daftar besar yang disimpan di memori eksternal (mis disk) dari komputer.

Catatan adalah kumpulan informasi (atau item data) tentang entitas tertentu. Lagi khusus, catatan
adalah kumpulan item data terkait, yang masing-masing disebut file atau atribut dan file adalah
kumpulan catatan serupa.

Meskipun record adalah kumpulan item data, ini berbeda dari array linier di cara berikut:

(a) Suatu catatan dapat berupa kumpulan data yang tidak homogen; yaitu, item data dalam a record
mungkin memiliki tipe data yang berbeda.

(b) Item data dalam catatan diindeks oleh nama atribut, jadi mungkin tidak ada urutan alami dari
unsur-unsurnya.

1.17. Karakteristik String

Dalam terminologi komputer istilah 'string' mengacu pada urutan karakter. Terbatas
himpunan urutan (abjad, angka atau karakter khusus) dari nol atau lebih karakter disebut Sebuah
benang. Jumlah karakter dalam sebuah string disebut panjang string. Jika panjang string adalah
nol maka disebut string kosong atau string nol.

28
1.17.1. Representasi String

String disimpan atau direpresentasikan dalam memori dengan menggunakan tiga jenis struktur
berikut:

1. Struktur panjang tetap

2. Struktur panjang variabel dengan maksimum tetap
3. Struktur linier

Representasi Panjang Tetap: Dalam penyimpanan dengan panjang tetap, setiap baris dipandang
sebagai record, dimana semua record memiliki panjang yang sama. Artinya setiap record
menampung maksimal jumlah karakter yang sama.

❖ Keuntungan utama merepresentasikan string dengan cara di atas adalah:

1. Untuk mengakses data dari catatan yang diberikan dengan mudah.
2. Sangat mudah untuk memperbarui data dalam catatan tertentu.

❖ Kerugian utama adalah:

1. Seluruh catatan akan dibaca meskipun sebagian besar penyimpanan terdiri dari blanko
yang tidak penting ruang angkasa. Waktu terbuang sia-sia untuk membaca ruang kosong
ini.
2. Panjang catatan tertentu akan lebih dari panjang tetap. Itu pasti catatan mungkin
memerlukan lebih banyak ruang memori daripada yang tersedia.

29
Gambar 1.9 merupakan representasi dari input data (yang ada pada Gambar 1.8) dalam panjang
tetap (rekaman) media penyimpanan di komputer.

Representasi Panjang Variabel: Dalam representasi panjang variabel, string adalah disimpan
dalam media penyimpanan yang panjangnya tetap. Ini dilakukan dengan dua cara.

1. Seseorang dapat menggunakan spidol, (karakter khusus apa saja) seperti tanda dua dolar
($$), untuk menandakan akhir string.
2. Daftar panjang string di tempat pertama adalah cara lain untuk mewakili string dalam
metode ini.

Representasi Daftar Tertaut: Dalam daftar tertaut merepresentasikan setiap karakter dalam a
string disusun secara berurutan dalam sel memori, yang disebut node, di mana setiap node berisi
item dan tautan, yang menunjuk ke simpul berikutnya dalam daftar (yaitu, tautan berisi alamat
simpul berikutnya).

30
 .

1.17.2. Sub String

Sekelompok elemen atau karakter berurutan dalam string (atau kalimat) disebut sub rangkaian.
Kelompok elemen berurutan ini mungkin tidak memiliki arti khusus. Untuk mengakses sub string
dari string yang diberikan kita membutuhkan informasi berikut:

(a) Nama string.

(b) Posisi karakter pertama dari substring dalam string yang diberikan.

(c) Panjang substring.

Menemukan apakah sub string tersedia dalam string dengan mencocokkan karakternya adalah
disebut pencocokan pola.

LINK YOUTUBE
kami lampirkan juga link YouTube kami yg menjelaskan tentang array 1 dimensi, array multi
dimensi, array sparse(jarang), dan vector sebagai berikut :
1. Array 1 dimensi : https://youtu.be/J2KNKqoN6s8
2. Array Multi Dimensi : https://youtu.be/wa7ep4i0CL0
3. Array Sparse (jarang) : https://youtu.be/cocGBvi0oU4
4. Vector : https://youtu.be/ibFmkW6xoM8

31
32