Nama : Farid andesta pratama

Nim : 23063007
Uas pengantar coding
1.be rikutdiberikan algoritma sebuah program:
Input: Array angka
Output: Array angka yang telah terurut

Langkah-langkah:
Mulai dari indeks terakhir array, bandingkan dua angka yang berurutan.
Jika angka pertama lebih besar dari angka kedua, tukar posisi kedua angka tersebut.
Turunkan indeks terakhir array sebesar 1.
Ulangi langkah 1-3 sampai indeks terakhir array sama dengan 0.
Pseudocode:
ALGORITMA bubble_sort(angka)
BAGIAN INPUT
angka ← Array angka
BAGIAN ALGORITMA
untuk i ← len(angka) - 1 s.d. 0
untuk j ← len(angka) - i - 1 s.d. 0
jika angka[j] > angka[j + 1]
angka[j], angka[j + 1] ← angka[j + 1], angka[j]
BAGIAN OUTPUT
kembalikan angka
Jelaskan bagaimana cara kerja algoritma ini dan untuk apa digunakan
Jawaban:
#include <iostream>
using namespace std;

void bubbleSort(int angka[], int n) {

for (int i = n - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (angka[j] > angka[j + 1]) {
// Tukar posisi jika angka[j] lebih besar dari angka[j + 1]
int temp = angka[j];
angka[j] = angka[j + 1];
angka[j + 1] = temp;
}
}
}
}

int main() {
int angka[] = {5, 3, 8, 2, 1, 9}; // Contoh array
int length = sizeof(angka) / sizeof(angka[0]); // Menghitung panjang array

bubbleSort(angka, length); // Panggil fungsi bubbleSort

// Cetak array setelah diurutkan

cout << "Array setelah diurutkan: ";
for (int i = 0; i < length; i++) {
cout << angka[i] << " ";
}
cout << endl;

return 0;
}
Cara kerja algoritma ini yaitu
Algoritma bubble sort bekerja dengan membandingkan dua elemen adjacent dalam array,
kemudian menukar posisi jika urutannya tidak sesuai. Algoritma ini melakukan iterasi
melalui array beberapa kali hingga semua elemen sudah berada di posisi yang tepat.
Algoritma memulai dengan membandingkan dua elemen pertama dari array. Jika elemen
pertama lebih besar dari elemen kedua, maka keduanya ditukar posisinya.
Algoritma kemudian membandingkan elemen kedua dan ketiga, dan seterusnya, hingga
mencapai elemen terakhir.
Langkah-langkah ini diulang untuk setiap pasangan elemen adjacent di array, hingga seluruh
array terurut.
Pada setiap iterasi, elemen terbesar di array akan "menggelembung" ke posisi yang benar
seperti gelembung naik ke permukaan air, sehingga algoritma dinamakan "bubble sort".
Proses ini terus berlanjut hingga tidak ada lagi pertukaran yang dilakukan dalam satu iterasi,
menandakan bahwa array sudah terurut.
Bubble sort adalah algoritma pengurutan sederhana yang dapat digunakan untuk
mengurutkan elemen-elemen dalam sebuah array. Meskipun sederhana, bubble sort memiliki
kelemahan dalam hal efisiensi, terutama pada jumlah besar data. Namun, algoritma ini masih
digunakan dalam beberapa kasus, terutama ketika jumlah data yang diurutkan relatif kecil
atau jika implementasi yang sederhana lebih diutamakan daripada efisiensi.

2. Berikut diberikan algoritma sebuah program

Input: Array angka, nilai yang dicari
Output: Indeks nilai yang dicari, atau -1 jika nilai tidak ditemukan
Langkah-langkah:
Set indeks awal pencarian ke 0.
Bandingkan nilai di indeks awal dengan nilai yang dicari.
Jika nilai di indeks awal sama dengan nilai yang dicari, maka nilai ditemukan dan
kembalikan indeks awal.Jika nilai di indeks awal tidak sama dengan nilai yang dicari, maka
indeks awal bertambah 1.Ulangi langkah 2-4 sampai indeks awal sama dengan panjang array
atau nilai yang dicari ditemukan.
Pseudocode:
ALGORITMA searching(angka, nilai)
BAGIAN INPUT
angka ← Array angka
nilai ← Nilai yang dicari
BAGIAN ALGORITMA
indeks_awal ← 0
while indeks_awal < len(angka)
jika angka[indeks_awal] = nilai
kembalikan indeks_awal
indeks_awal ← indeks_awal + 1
kembalikan -1
Jelaskan bagaimana cara kerja algoritma ini dan untuk apa digunakan.
Jawaban:
#include <iostream>
using namespace std;

int searching(int angka[], int panjang, int nilai) {

int indeks = 0;
while (indeks < panjang && angka[indeks] != nilai) {
indeks++;
}
if (indeks == panjang) {
return -1; // Jika mencapai akhir array dan nilai belum ditemukan, kembalikan -1
} else {
return indeks; // Nilai ditemukan, kembalikan indeks
}
}

int main() {
int angka[] = { 1, 3, 5, 7, 9 };
int panjang = sizeof(angka) / sizeof(angka[0]);
int nilai = 5;
int hasil = searching(angka, panjang, nilai);
if (hasil != -1) {
cout << "Nilai ditemukan pada indeks: " << hasil << endl;
} else {
cout << "Nilai tidak ditemukan" << endl;
}
return 0;
}

Cara kerja algoritma ini

Algoritma pencarian linear (linear search) bekerja dengan cara sebagai berikut:
1. Inisialisasi indeks awal (biasanya disebut `indeks_awal`) dengan nilai 0, yang menandakan
bahwa pencarian dimulai dari elemen pertama dalam array.
2. Lakukan perulangan (biasanya menggunakan loop `while` atau `for`) untuk memeriksa
setiap elemen dalam array secara berurutan.
3. Pada setiap iterasi perulangan, bandingkan nilai elemen saat ini dengan nilai yang ingin
dicari.
- Jika nilai elemen saat ini sama dengan nilai yang dicari, maka pencarian selesai dan indeks
elemen tersebut dikembalikan sebagai hasil pencarian.
- Jika tidak sama, lanjutkan ke elemen berikutnya dengan meningkatkan indeks (misalnya,
`indeks_awal = indeks_awal + 1`).
4. Jika perulangan selesai tanpa menemukan nilai yang dicari, artinya nilai tersebut tidak ada
dalam array, dan algoritma mengembalikan nilai yang menandakan bahwa nilai tidak
ditemukan (biasanya -1).

Algoritma ini sederhana dan efektif untuk array yang tidak terlalu besar atau tidak terurut.
Namun, untuk array yang besar atau terurut, algoritma ini mungkin tidak efisien karena
memerlukan pemeriksaan setiap elemen satu per satu.
Algoritma pencarian linear (linear search) digunakan untuk mencari nilai tertentu dalam
sebuah array. Beberapa contoh penggunaan algoritma ini antara lain:
1.Pencarian dalam Array Tidak Terurut: Ketika kita memiliki array yang tidak terurut,
algoritma pencarian linear dapat digunakan untuk mencari nilai tertentu tanpa memerlukan
pengurutan terlebih dahulu.
2. Pencarian Nilai Spesifik: Misalnya, dalam sebuah daftar nama, kita dapat menggunakan
algoritma pencarian linear untuk mencari apakah sebuah nama tertentu ada di dalam daftar.
3. Pencarian dalam Array yang Tidak Terlalu Besar: Algoritma ini cocok digunakan untuk
array dengan jumlah elemen yang tidak terlalu besar, karena kompleksitas waktu algoritma
ini adalah O(n), di mana n adalah jumlah elemen dalam array. Artinya, waktu yang
dibutuhkan untuk mencari nilai meningkat secara linear dengan jumlah elemen dalam array.
Namun, perlu diingat bahwa algoritma ini mungkin tidak efisien untuk digunakan pada array
yang sangat besar atau jika pencarian nilai tersebut sering dilakukan.