Subscribe to DeepL Pro to translate larger documents.

Visit www.DeepL.com/pro for more information.

Rekursi
Apa yang dimaksud dengan Rekursi?
Proses di mana sebuah fungsi memanggil dirinya sendiri secara langsung atau
tidak langsung disebut rekursi dan fungsi yang sesuai disebut sebagai fungsi
rekursif. Dengan menggunakan algoritma rekursif, beberapa masalah dapat
diselesaikan dengan mudah. Contoh masalah tersebut adalah Towers of Hanoi
(TOH), Penjelajahan Pohon Inorder/Preorder/Postorder, DFS dari Graf, dll.

Properti
Fungsi rekursif dapat berjalan tanpa batas seperti perulangan. Untuk menghindari
berjalannya fungsi rekursif yang tak terbatas, ada dua properti yang harus dimiliki oleh
fungsi rekursif -
• Kriteria dasar - Harus ada setidaknya satu kriteria atau kondisi dasar, sehingga, ketika
kondisi ini terpenuhi, fungsi akan berhenti memanggil dirinya sendiri secara rekursif.
• Pendekatan progresif - Panggilan rekursif harus berkembang sedemikian rupa
sehingga setiap kali panggilan rekursif dibuat, ia semakin mendekati kriteria dasar.
Banyak bahasa pemrograman mengimplementasikan rekursi dengan menggunakan
tumpukan. Umumnya, setiap kali sebuah fungsi (pemanggil) memanggil fungsi lain
(penerima) atau dirinya sendiri sebagai penerima, fungsi pemanggil mentransfer kontrol
eksekusi ke penerima. Proses transfer ini mungkin juga melibatkan beberapa data yang
akan diteruskan dari pemanggil ke penerima.

Ketika sebuah fungsi dipanggil dari main(), memori dialokasikan ke fungsi tersebut
pada stack. Fungsi rekursif memanggil dirinya sendiri, memori untuk fungsi yang
dipanggil dialokasikan di atas memori yang dialokasikan untuk memanggil fungsi
dan salinan variabel lokal yang berbeda dibuat untuk setiap pemanggilan fungsi.
Ketika kasus dasar tercapai, fungsi mengembalikan nilainya ke fungsi yang
memanggilnya dan memori tidak dialokasikan dan proses berlanjut.
Mari kita ambil contoh bagaimana rekursi bekerja dengan mengambil sebuah fungsi
sederhana.
// Program C++ untuk mendemonstrasikan cara kerja
// rekursi #include
<bits/stdc++.h>
menggunakan ruang nama std;

void printFun(int test)

{
if (tes < 1)
kembali
; else
{
cout << test << " ";
printFun(test-1); // pernyataan
2 cout << test << " ";
kembali;
}
}

int main()
{
int test = 3;
printFun(test);
}

Keluaran :
321123
Ketika printFun(3) dipanggil dari main(), memori dialokasikan ke printFun(3) dan
sebuah variabel lokal test diinisialisasi ke 3 dan pernyataan 1 sampai 4 di-push ke
stack seperti yang ditunjukkan pada diagram di bawah ini. Pernyataan pertama
mencetak '3'. Pada pernyataan 2, printFun(2) dipanggil dan memori dialokasikan
ke printFun(2) dan sebuah variabel lokal test diinisialisasi ke 2 dan pernyataan 1
sampai 4 di-push ke stack.
Demikian pula, printFun(2) memanggil printFun(1) dan printFun(1) memanggil
printFun(0). printFun
(0) menuju ke pernyataan if dan kembali ke printFun(1). Pernyataan-pernyataan yang
tersisa
dari printFun(1) dieksekusi dan kembali ke printFun(2) dan seterusnya. Pada
output, nilai dari 3 sampai 1 dicetak dan kemudian 1 sampai 3 dicetak. Tumpukan
memori telah ditunjukkan pada diagram di bawah ini.
ARRAY ADT
Array adalah sebuah wadah yang dapat menampung sejumlah item dan item-item
tersebut harus memiliki tipe yang sama. Sebagian besar struktur data
menggunakan larik untuk mengimplementasikan algoritmanya. Berikut ini adalah
istilah-istilah penting untuk memahami konsep Array.
• Elemen - Setiap item yang disimpan dalam larik disebut elemen.
• Indeks - Setiap lokasi elemen dalam larik memiliki indeks numerik, yang digunakan untuk
mengidentifikasi elemen.

Representasi Larik
Larik dapat dideklarasikan dengan berbagai cara dalam berbagai bahasa. Sebagai
ilustrasi, mari kita lihat deklarasi larik C.

Larik dapat dideklarasikan dengan berbagai cara dalam berbagai bahasa. Sebagai
ilustrasi, mari kita lihat deklarasi larik C.

Sesuai dengan ilustrasi di atas, berikut ini adalah poin-poin penting yang perlu
dipertimbangkan.
• Indeks dimulai dengan 0.
• Panjang larik adalah 10 yang berarti dapat menyimpan 10 elemen.
• Setiap elemen dapat diakses melalui indeksnya. Sebagai contoh, kita dapat mengambil
elemen pada indeks 6 sebagai 9.

Operasi Dasar
Berikut ini adalah operasi dasar yang didukung oleh larik.
• Traverse - mencetak semua elemen larik satu per satu.
• Penyisipan - Menambahkan elemen pada indeks yang diberikan.
• Penghapusan - Menghapus elemen pada indeks yang diberikan.
• Cari - Mencari elemen menggunakan indeks yang diberikan atau berdasarkan nilai.
• Update - Memperbarui elemen pada indeks yang diberikan.
Operasi Penyisipan
Operasi insert adalah menyisipkan satu atau beberapa elemen data ke dalam larik.
Berdasarkan kebutuhan, elemen baru dapat ditambahkan pada awal, akhir, atau
indeks tertentu dari larik.
Di sini, kita melihat implementasi praktis dari operasi penyisipan, di mana kita
menambahkan data
di akhir larik -
Algoritma
Biarkan Array menjadi larik linier tak berurutan dari elemen MAX.
Contoh
Hasil
Misalkan LA adalah sebuah Larik Linier (tak terurut) dengan N elemen dan K
adalah sebuah bilangan bulat positif sehingga K<=N. Berikut ini adalah algoritma di
mana ITEM dimasukkan ke d a l a m posisi Kth dari LA -
1. Mulai
2. Tetapkan J = N
3. Tetapkan N = N + 1
4. Ulangi langkah 5 dan 6 saat J >= K
5. Tetapkan LA [J+1] = LA [J]
6. Tetapkan J = J-1
7. Tetapkan LA[K] = ITEM
8. Berhenti.

Contoh
Berikut ini adalah penerapan algoritme di atas -
Demo
Langsung
# include <stdio.h>

main() {
int LA[] = {1,3,5,7,8};
int item = 10, k = 3, n = 5;
int i = 0, j = n;

printf("Elemen larik asli adalah :\n");

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

printf("LA[%d] = %d \n", i, LA[i]);
}

n = n + 1;

while( j >= k)

{
LA[j+1] = LA[j];
j = j - 1;
}
 LA[k] = item;

printf("Elemen-elemen larik setelah penyisipan

:\n"); for(i = 0; i<n; i++) {

printf("LA[%d] = %d \n", i, LA[i]);
}
}
Ketika kita mengkompilasi dan menjalankan program di atas, program tersebut
menghasilkan hasil sebagai berikut -
Keluaran
Elemen larik asli adalah :
LA [0] = 1
LA [1] = 3
LA [2] = 5
LA [3] = 7
LA [4] = 8
Elemen array setelah penyisipan :
LA [0] = 1
LA [1] = 3
LA [2] = 5
LA [3] = 10
LA [4] = 7
LA [5] = 8

Operasi Penghapusan
Penghapusan mengacu pada menghapus elemen yang ada dari larik dan mengatur
ulang semua elemen larik.
Algoritma
Anggap LA adalah sebuah larik linear dengan N elemen dan K adalah sebuah
bilangan bulat positif sehingga K<=N. Berikut ini adalah algoritma untuk menghapus
sebuah elemen y a n g tersedia pada posisi Kth dari LA.
1. Mulai
2. Tetapkan J = K
3. Ulangi langkah 4 dan 5 selama J < N
4. Tetapkan LA [J] = LA [J + 1]
5. Tetapkan J = J + 1
6. Tetapkan N = N-1
7. Berhenti.

Contoh
Berikut ini adalah penerapan algoritme di atas -
# include <stdio.h>

void main() {
 int LA[] = {1,3,5,7,8};
int k = 3, n =
5; int i, j;

printf("Elemen larik asli adalah :\n");

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

printf("LA[%d] = %d \n", i, LA[i]);
}

j = k;

while( j < n) {
LA[j-1] = LA[j];
j = j + 1;
}

n = n -1;

printf("Elemen larik setelah penghapusan :\n");

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

printf("LA[%d] = %d \n", i, LA[i]);
}
}
Ketika kita mengkompilasi dan menjalankan program di atas, program tersebut
menghasilkan hasil sebagai berikut -
Keluaran
Elemen larik asli adalah :
LA [0] = 1
LA [1] = 3
LA [2] = 5
LA [3] = 7
LA [4] = 8
Elemen larik setelah penghapusan :
LA [0] = 1
LA [1] = 3
LA [2] = 7
LA [3] = 8
Ditemukan elemen 5 pada posisi 3

DAFTAR TERLINK
Senarai berantai adalah urutan struktur data, yang dihubungkan bersama melalui
tautan.
Senarai Berantai adalah urutan tautan yang berisi item. Setiap tautan berisi koneksi
ke tautan lain. Senarai Berantai adalah struktur data kedua yang paling banyak
digunakan setelah larik. Berikut ini adalah istilah-istilah penting untuk memahami
konsep Senarai Berantai.
• Tautan - Setiap tautan dari sebuah daftar taut dapat menyimpan data yang disebut elemen.
 • Berikutnya - Setiap tautan dari daftar taut berisi tautan ke tautan berikutnya yang disebut
Berikutnya.
• LinkedList - Senarai Berantai berisi tautan koneksi ke tautan pertama yang disebut First.

Representasi Senarai Berantai

Senarai berantai dapat divisualisasikan sebagai sebuah rantai node, di mana setiap
node menunjuk ke node berikutnya.

Sesuai dengan ilustrasi di atas, berikut ini adalah poin-poin penting yang perlu
dipertimbangkan.
• Senarai Berantai berisi elemen tautan yang disebut pertama.
• Setiap tautan membawa bidang data dan bidang tautan yang disebut next.
• Setiap tautan dihubungkan dengan tautan berikutnya menggunakan tautan berikutnya.
• Tautan terakhir membawa tautan sebagai null untuk menandai akhir daftar.

Jenis-jenis Senarai Berantai

Berikut ini adalah berbagai jenis daftar taut.
• Senarai Berantai Sederhana - Navigasi item hanya maju.
• Daftar Berantai Ganda - Item dapat dinavigasi ke depan dan ke belakang.
• Senarai Berantai Melingkar - Item terakhir berisi tautan elemen pertama sebagai elemen
berikutnya dan pertama
memiliki tautan ke elemen terakhir seperti sebelumnya.

Operasi Dasar
Berikut ini adalah operasi dasar yang didukung oleh daftar.
• Penyisipan - Menambahkan elemen di awal daftar.
• Penghapusan - Menghapus elemen di awal daftar.
• Tampilan - Menampilkan daftar lengkap.
• Cari - Mencari elemen menggunakan kunci yang diberikan.
• Menghapus - Menghapus elemen menggunakan kunci yang diberikan.

Operasi Penyisipan
Menambahkan simpul baru di dalam sebuah linked list merupakan sebuah aktivitas
yang lebih dari satu langkah. Kita akan mempelajari hal ini dengan diagram di sini.
Pertama, buatlah sebuah simpul dengan menggunakan struktur yang sama dan
temukan lokasi di mana simpul tersebut harus disisipkan.
Bayangkan bahwa kita adalah menyisipkan
anoda B(NewNode), di antaraA (LeftNode) dan C (RightNode).
Kemudian tunjuk B.di sebelah C -
NewNode.next -> RightNode;
Seharusnya terlihat seperti ini -

Sekarang, simpul berikutnya di sebelah kiri harus menunjuk ke simpul baru.

LeftNode.next -> NewNode;

Ini akan menempatkan simpul baru di tengah-tengah keduanya. Daftar yang baru
akan terlihat seperti ini
-
Langkah yang sama harus dilakukan jika simpul disisipkan di awal daftar. Ketika
menyisipkannya di akhir, simpul terakhir kedua dari daftar harus mengarah ke
simpul baru dan simpul baru akan mengarah ke NULL.

Operasi Penghapusan
Penghapusan juga merupakan proses yang terdiri dari lebih dari satu langkah. Kita
akan belajar dengan representasi gambar. Pertama, cari node target yang akan
dihapus, dengan menggunakan algoritma pencarian.

Simpul kiri (sebelumnya) dari simpul target sekarang harus menunjuk ke simpul
berikutnya dari
simpul target -
LeftNode.next -> TargetNode.next;

Ini akan menghapus tautan yang mengarah ke node target. Sekarang, dengan
menggunakan kode berikut, kita akan menghapus apa yang dituju oleh simpul
target.
TargetNode.next -> NULL;

Kita perlu menggunakan simpul yang telah dihapus. Kita dapat menyimpannya
dalam memori atau kita dapat dengan mudah mengalokasikan memori dan
menghapus simpul target sepenuhnya.

DAFTAR TERTAUT GANDA

Senarai Berantai Ganda adalah variasi dari Senarai Berantai di mana navigasi
dapat dilakukan dengan dua arah, baik maju maupun mundur dengan mudah
dibandingkan dengan Senarai Berantai Tunggal. Berikut ini adalah istilah-istilah
penting untuk memahami konsep Senarai Berantai Ganda.
• Tautan - Setiap tautan dari sebuah daftar taut dapat menyimpan data yang disebut elemen.
• Berikutnya - Setiap tautan dari daftar taut berisi tautan ke tautan berikutnya yang disebut
Berikutnya.
• Prev - Setiap tautan dari daftar taut berisi tautan ke tautan sebelumnya yang disebut Prev.
• LinkedList - Senarai Berantai berisi tautan koneksi ke tautan pertama yang disebut
Pertama dan ke
tautan terakhir yang disebut Last.

Representasi Senarai Berantai Ganda

Sesuai dengan ilustrasi di atas, berikut ini adalah poin-poin penting yang perlu
dipertimbangkan.
• Senarai Berantai Ganda berisi elemen tautan yang disebut pertama dan terakhir.
• Setiap tautan membawa bidang data dan dua bidang tautan yang disebut next dan prev.
• Setiap tautan dihubungkan dengan tautan berikutnya menggunakan tautan berikutnya.
• Setiap tautan dihubungkan dengan tautan sebelumnya menggunakan tautan sebelumnya.
• Tautan terakhir membawa tautan sebagai null untuk menandai akhir daftar.

Operasi Penyisipan
Kode berikut ini mendemonstrasikan operasi penyisipan di awal dari sebuah daftar
berantai ganda.
Contoh
//menyisipkan tautan pada lokasi
pertama void insertFirst(int key,
int data) {

//buat tautan
struct node *link = (struct node*) malloc(sizeof(struct
node));
link->key = key;
link->data = data;

if(isEmpty()) {
//jadikan itu tautan
terakhir last = link;
} else {
//update link prev
pertama head->prev =
link;
}
 //pengarah ke tautan pertama
yang lama link->next = head;

//penunjuk pertama ke tautan

pertama yang baru head = link;
}

Operasi Penghapusan
Kode berikut ini mendemonstrasikan operasi penghapusan pada awal dari sebuah
daftar yang terhubung ganda.
Contoh
//hapus item pertama
struct node* deleteFirst() {

//simpan referensi ke tautan

pertama struct node *tempLink
= head;

//jika hanya satu tautan

if(head->next == NULL) {
last = NULL;
} else {
head->next->prev = NULL;
}

head = head->next;

//kembalikan tautan yang

telah dihapus kembalikan
tempLink;
}

Penyisipan pada Akhir Operasi

Kode berikut ini mendemonstrasikan operasi penyisipan pada posisi terakhir dari
sebuah daftar berantai ganda.
Contoh
//menyisipkan tautan di lokasi
terakhir void insertLast(int key,
int data) {

//buat tautan
struct node *link = (struct node*) malloc(sizeof(struct
node));
link->key = key;
link->data = data;

if(isEmpty()) {
//jadikan itu tautan
terakhir last = link;
} else {
//membuat tautan menjadi tautan terakhir yang baru
 last->next = link;

//tandai simpul terakhir yang lama

sebagai prev dari tautan baru link->prev
= last;
}

//point last ke node

terakhir yang baru last =
link;
}

TUMPUKAN ADT
Tumpukan adalah Tipe Data Abstrak (ADT), yang biasa digunakan di sebagian
besar bahasa pemrograman. Dinamakan stack karena berperilaku seperti
tumpukan di dunia nyata, misalnya - setumpuk kartu atau tumpukan piring, dll.
Fitur ini membuatnya menjadi struktur data LIFO. LIFO adalah singkatan dari Last-
in-first-out. Di sini, elemen yang ditempatkan (disisipkan atau ditambahkan) terakhir,
akan diakses pertama kali. Dalam terminologi stack, operasi penyisipan disebut
operasi PUSH dan operasi penghapusan disebut operasi POP.

Representasi Tumpukan
Diagram berikut ini menggambarkan tumpukan dan operasinya -

Stack dapat diimplementasikan dengan menggunakan Array, Struktur, Pointer, dan

Senarai Berantai. Stack dapat berupa ukuran tetap atau dapat juga berupa ukuran
dinamis. Di sini, kita akan mengimplementasikan stack menggunakan array, yang
membuatnya menjadi implementasi stack dengan ukuran tetap.
Operasi Dasar
Operasi stack dapat melibatkan inisialisasi stack, menggunakannya, dan kemudian
melakukan de-inisialisasi. Selain dari hal-hal dasar ini, stack digunakan untuk dua
operasi utama berikut ini -
• push() - Mendorong (menyimpan) sebuah elemen pada tumpukan.
• pop() - Menghapus (mengakses) sebuah elemen dari tumpukan.
Ketika data DIDORONG ke tumpukan.
Untuk menggunakan stack secara efisien, kita perlu memeriksa status stack juga.
Untuk
tujuan yang sama, fungsionalitas berikut ditambahkan ke tumpukan -
• peek() - mendapatkan elemen data teratas dari tumpukan, tanpa menghapusnya.
• isFull() - memeriksa apakah tumpukan sudah penuh.
• isEmpty() - memeriksa apakah tumpukan kosong.
Setiap saat, kita mempertahankan penunjuk ke data terakhir yang di-PUSH pada
tumpukan. Karena penunjuk ini selalu mewakili bagian atas tumpukan, maka
dinamakan top. Pointer top memberikan nilai teratas dari tumpukan tanpa benar-
benar menghapusnya.
Pertama, kita harus belajar tentang prosedur untuk mendukung fungsi stack -

Operasi Dorong
Proses meletakkan elemen data baru ke dalam tumpukan dikenal sebagai Push
Operasi. Operasi push melibatkan serangkaian langkah -
• Langkah 1 - Memeriksa apakah tumpukan sudah penuh.
• Langkah 2 - Jika tumpukan penuh, menghasilkan kesalahan dan keluar.
• Langkah 3 - Jika tumpukan tidak penuh, naikkan dari atas ke titik ruang kosong berikutnya.
• Langkah 4 - Menambahkan elemen data ke lokasi tumpukan, di mana bagian atas
menunjuk.
• Langkah 5 - Mengembalikan keberhasilan.

Jika senarai berantai digunakan untuk mengimplementasikan stack, maka pada

langkah 3, kita perlu mengalokasikan ruang secara dinamis.
Algoritma untuk Operasi PUSH
Algoritme sederhana untuk operasi Push dapat diturunkan sebagai berikut -
mulai prosedur push: stack, data

jika tumpukan
penuh
kembalikan
null
endif

top ← top + 1
stack[top] ← data

prosedur akhir
Implementasi algoritma ini dalam bahasa C sangat mudah. Lihat kode berikut ini -
Contoh
void push(int data) {
if(!isFull()) {
top = top + 1;
stack[top] = data;
} else {
printf("Tidak dapat memasukkan data, Tumpukan penuh.\n");
}
}

Operasi Pop
Mengakses konten sambil menghapusnya dari stack, dikenal sebagai Operasi Pop.
Dalam implementasi larik operasi pop(), elemen data tidak benar-benar dihapus,
melainkan bagian atas dikurangi ke posisi yang lebih rendah dalam tumpukan
untuk menunjuk ke nilai berikutnya. Tetapi dalam implementasi linked-list, pop()
benar-benar menghapus elemen data dan mengalokasikan ruang memori.
Operasi Pop dapat melibatkan langkah-langkah berikut -
• Langkah 1 - Memeriksa apakah tumpukan kosong.
• Langkah 2 - Jika stack kosong, menghasilkan kesalahan dan keluar.
• Langkah 3 - Jika tumpukan tidak kosong, mengakses elemen data yang menjadi tujuan
atas.
• Langkah 4 - Mengurangi nilai top sebesar 1.
• Langkah 5 - Mengembalikan keberhasilan.
Algoritma untuk Operasi Pop
Algoritme sederhana untuk operasi Pop dapat diturunkan sebagai berikut -
mulai prosedur pop: tumpukan

jika tumpukan
kosong
kembalikan
null
endif

data ← stack[top]
top ← top - 1
kembalikan data

prosedur akhir
Implementasi algoritma ini dalam bahasa C, adalah sebagai berikut -
Contoh
int pop(int data) {

if(!isempty()) {
data =
stack[top]; top =
top - 1; return
data;
} else {
printf("Tidak dapat mengambil data, Tumpukan kosong.\n");
}
}

ANTRIAN
Antrian adalah struktur data abstrak, agak mirip dengan Tumpukan. Tidak seperti tumpukan,
antrean terbuka di kedua ujungnya. Salah satu ujungnya selalu digunakan untuk
memasukkan data (enqueue) dan ujung lainnya digunakan untuk menghapus data (dequeue).
Queue mengikuti metodologi First-In-First-Out, yaitu item data yang disimpan pertama kali
akan diakses pertama kali.
Contoh antrean di dunia nyata dapat berupa jalan satu arah dengan satu jalur, di mana
kendaraan yang masuk lebih dulu, keluar lebih dulu. Contoh dunia nyata lainnya dapat
dilihat sebagai antrian di loket tiket dan halte bus.

Representasi Antrian
Seperti yang telah kita pahami bahwa dalam antrian, kita mengakses kedua ujungnya untuk
alasan yang berbeda. Diagram berikut yang diberikan di bawah ini mencoba menjelaskan
representasi antrean sebagai struktur data -

Seperti pada stack, antrian juga bisa diimplementasikan menggunakan Array, Senarai
Berantai, Pointer dan Struktur. Demi kesederhanaan, kita akan mengimplementasikan
antrian menggunakan larik satu dimensi.

Operasi Dasar
Operasi antrean dapat melibatkan inisialisasi atau pendefinisian antrean, menggunakannya,
dan kemudian menghapusnya dari memori. Di sini kita akan mencoba memahami operasi
dasar yang terkait dengan antrean -
• enqueue() - menambahkan (menyimpan) sebuah item ke dalam antrian.
• dequeue() - menghapus (mengakses) item dari antrian.
Beberapa fungsi lagi diperlukan untuk membuat operasi antrian yang disebutkan di atas
menjadi efisien.
Ini adalah -
• peek() - Mendapatkan elemen di bagian depan antrean tanpa menghapusnya.
• isfull() - Memeriksa apakah antrean sudah penuh.
• isempty() - Memeriksa apakah antrian kosong.
Dalam antrean, kita selalu melakukan dequeue (atau mengakses) data, yang ditunjuk oleh
pointer depan dan saat melakukan enqueue (atau menyimpan) data dalam antrean, kita
menggunakan bantuan pointer belakang.
Operasi Antrian
Antrian mempertahankandua penunjuk data , depan dan belakang, oleh
karena itu, nya operasi relatif lebih sulit
diimplementasikan dibandingkan dengan stack.
Langkah-langkah berikut ini harus dilakukan untuk memasukkan data ke dalam antrean -
• Langkah 1 - Periksa apakah antrean sudah penuh.
• Langkah 2 - Jika antrean penuh, buat kesalahan overflow dan keluar.
• Langkah 3 - Jika antrean tidak penuh, naikkan penunjuk belakang untuk menunjuk
ruang kosong berikutnya.
• Langkah 4 - Tambahkan elemen data ke lokasi antrean, di mana bagian belakang
menunjuk.
• Langkah 5 - kembalikan kesuksesan.

Terkadang, kami juga memeriksa untuk melihat apakah antrean sudah diinisialisasi atau
belum, untuk menangani situasi yang tidak terduga.
Algoritme untuk operasi enqueue
prosedur enqueue (data)

jika antrean penuh,

kembalilah meluap
endif

belakang ←
belakang + 1
antrian[belakang]
← data return
true

prosedur akhir
Implementasi enqueue() dalam bahasa pemrograman C -
Contoh
int enqueue(int data)
if(isfull())
kembali 0;

belakang = belakang + 1;
antrian[belakang] =
data;

kembali 1;
akhiri
prosedur

Operasi Dequeue
Mengakses data dari antrean adalah proses dari dua tugas - mengakses data di mana bagian
depan menunjuk dan menghapus data setelah akses. Langkah-langkah berikut ini dilakukan
untuk melakukan operasi dequeue -
• Langkah 1 - Periksa apakah antrean kosong.
• Langkah 2 - Jika antrean kosong, hasilkan kesalahan underflow dan keluar.
• Langkah 3 - Jika antrean tidak kosong, akses data di mana bagian depan menunjuk.
• Langkah 4 - Kenaikan penunjuk depan untuk menunjuk ke elemen data berikutnya
yang tersedia.
• Langkah 5 - Kembalikan keberhasilan.

Algoritma untuk operasi dequeue

prosedur dequeue

jika antrean kosong

kembalikan
aliran bawah
akhir jika

data = antrian [depan]

 front ← front + 1
return true

prosedur akhir
Implementasi dequeue() dalam bahasa pemrograman C -
Contoh
int dequeue() {
if(isempty())
kembali 0;

int data =
antrian[front]; front =
front + 1;

mengembalikan data;
}

Antrean adalah tipe data abstrak yang dapat diimplementasikan sebagai daftar
linier atau melingkar. Ia memiliki bagian depan dan belakang.

Ada empat jenis Antrian:

1. Antrian Sederhana
2. Antrian Melingkar
3. Antrian Prioritas
4. Dequeue (Antrian Berujung Ganda)

1. Antrian Sederhana
Antrian sederhana mendefinisikan operasi sederhana antrian di mana
penyisipan terjadi di bagian belakang daftar dan penghapusan terjadi di bagian
depan daftar.

Contoh: Program untuk Antrian Sederhana

#include <stdio.h>
#define N 6
int antrian[N]={0};
int
belakang=0,depan
=0;

void insert(void);
void delete(void);
void display(void);
void create(void);

void main()
{
int ch=0;
while(ch!=4)
{

printf("\n Ukuran Antrian adalah :

%d",N); printf("\n 1.Insert");
printf("\n 2.Delete");
printf("\n 3.Display");
printf("\n 4.Exit");
printf("\n 5.Create\n");
printf("\n Masukkan Pilihan Anda :
\n"); scanf("\n %d",&ch);
sakelar (ch)
{
kasus 1:
insert();
break;
kasus 2:
menghapus(
); istirahat;
kasus 3:
display();
break;
 kasus 4:
create();
break;
kasus 5:
printf("\n\t
Keluar"); break;
}
}
}
void insert(void) //Menyisipkan Fungsi
{
int t;
if(belakang<
N);
if(belakang<
N)
{
printf("\n\t Masukkan Elemen dalam
Antrian : "); scanf("%d",&t);
antrian
[belakang] = t;
belakang++;
}
lain
{
printf("\n\t Antrian Melimpah");
}
}
void delet(void) //Menghapus Fungsi
{
int i;
printf("\n\t %d akan dihapus...........",antrian[depan]);
antrian[front]=0;
front++;
}
void display(void) //Display Fungsi
{
int i;
for(i=depan;i<belakang;i+
+)
 {
printf("\n\t %d",antrian[i]);
}
}
void create(void) //Membuat Fungsi
{
int t;
printf("\n\t Masukkan Elemen dalam Antrian
: "); scanf("%d",&t);
depan=0;
antrian[depan]=t;
belakang=depan+1;
}

Keluaran:

1. Menyisipkan

2. Tampilan
 3. Menghapus

Antrian Melingkar

• Dalam antrian melingkar, semua node diperlakukan sebagai melingkar.

Node terakhir terhubung kembali ke node pertama.
• Antrian melingkar juga disebut sebagai Ring Buffer.
• Ini adalah tipe data abstrak.
• Antrian melingkar berisi kumpulan data yang memungkinkan penyisipan data
di akhir antrian dan penghapusan data di awal antrian.
 Gambar di atas menunjukkan struktur antrean melingkar. Antrian ini
menyimpan elemen dengan cara melingkar dan melakukan operasi sesuai
dengan struktur FIFO-nya.

Antrian Prioritas

• Antrian prioritas berisi item data yang memiliki beberapa prioritas yang telah
ditetapkan. Saat menghapus elemen dari antrean prioritas, item data dengan
prioritas tertinggi akan dihapus terlebih dahulu.
• Dalam antrean prioritas, penyisipan dilakukan sesuai urutan
kedatangan dan penghapusan dilakukan berdasarkan prioritas.

Dequeue (Antrian Berujung Ganda)

Pada Double Ended Queue, operasi insert dan delete dapat dilakukan di
kedua ujung antrian yaitu depan dan belakang.

APLIKASI DARI DAFTAR TERTAUT

1. ADT polinomial
 2. Urutan Radix

3. Multilist

MANIPULASI POLINOMIAL
Representasi
Penjumlahan
Perkalian
Representasi Polinomial: Polinomial adalah ekspresi yang mengandung lebih
dari dua suku. Suku terdiri dari koefisien dan eksponen. Contoh polinomial
adalah
P(x) = 4x3 +6x +7x+92

Dengan demikian, polinomial dapat direpresentasikan menggunakan larik atau

senarai bertautan. Representasi larik mengasumsikan bahwa eksponen dari
ekspresi yang diberikan disusun dari 0 hingga nilai tertinggi (derajat), yang
diwakili oleh subskrip larik yang dimulai dengan 0. Koefisien dari masing-
masing eksponen ditempatkan pada indeks yang sesuai dalam larik.
Representasi larik untuk ekspresi polinomial di atas diberikan di bawah ini:

Polinomial juga dapat direpresentasikan dengan menggunakan sebuah daftar

taut. Sebuah struktur dapat didefinisikan sedemikian rupa sehingga mengandung
dua bagian - satu adalah koefisien dan yang kedua adalah eksponen yang sesuai.
Definisi struktur dapat diberikan seperti yang ditunjukkan di bawah ini:

struct polinomial
{

int koefisien; int eksponen;

struct polinomial * next; };

Dengan demikian, polinomial di atas dapat direpresentasikan dengan

menggunakan linked list seperti yang ditunjukkan di bawah ini:

Penjumlahan dua Polinomial:

Untuk menjumlahkan dua polinomial menggunakan larik adalah metode yang
mudah, karena kedua larik dapat dijumlahkan secara elemen per elemen mulai
dari 0 hingga n-1, sehingga menghasilkan penjumlahan dua polinomial.
Penjumlahan dua polinomial menggunakan senarai berantai membutuhkan
perbandingan eksponen, dan di mana pun eksponennya ditemukan sama,
koefisiennya dijumlahkan. Untuk suku dengan eksponen yang berbeda, suku
yang lengkap cukup ditambahkan ke hasil sehingga menjadikannya bagian dari
hasil penjumlahan. Program lengkap untuk menjumlahkan dua polinomial
diberikan pada bagian selanjutnya.

Perkalian dua Polinomial:

Perkalian dua polinomial membutuhkan manipulasi setiap simpul sehingga

eksponennya dijumlahkan dan koefisiennya dikalikan. Setelah setiap suku dari
polinomial pertama dioperasikan dengan setiap suku dari polinomial kedua,
maka hasilnya harus dijumlahkan dengan membandingkan eksponen dan
menambahkan koefisien untuk eksponen yang sama dan memasukkan suku-
suku yang memiliki eksponen yang berbeda ke dalam hasil. Program 'C' untuk
polinom diberikan di bawah ini:

Urutan radix
Radix sort adalah salah satu algoritma pengurutan yang digunakan untuk mengurutkan daftar
bilangan bulat secara berurutan. Dalam algoritma radix sort, daftar bilangan bulat akan diurutkan
berdasarkan digit dari masing-masing angka. Pengurutan dilakukan dari angka yang paling
kecil ke angka yang paling besar. Algoritma radix sort membutuhkan jumlah lintasan yang
sama dengan jumlah digit yang ada pada angka terbesar di antara daftar angka. Sebagai contoh,
jika angka terbesar adalah 3 digit angka maka daftar tersebut diurutkan dengan 3 lintasan.

Proses Langkah demi Langkah

Algoritma pengurutan Radix dilakukan dengan menggunakan langkah-langkah berikut...

• Langkah 1 - Tentukan 10 antrian yang masing-masing mewakili bucket untuk setiap digit
dari 0 hingga 9.
• Langkah 2 - Pertimbangkan digit paling kecil dari setiap nomor dalam daftar yang akan
diurutkan.
• Langkah 3 - Masukkan setiap nomor ke dalam antrean masing-masing berdasarkan
angka paling kecil.
• Langkah 4 - Kelompokkan semua nomor dari antrian 0 hingga antrian 9 sesuai urutan
yang telah dimasukkan ke dalam antrian masing-masing.
• Langkah 5 - Ulangi dari langkah 3 berdasarkan angka paling kecil berikutnya.
• Langkah 6 - Ulangi dari langkah 2 sampai semua angka dikelompokkan berdasarkan
digit yang paling signifikan.

Contoh
Kompleksitas Algoritma Pengurutan Radix
Untuk mengurutkan daftar yang belum diurutkan dengan jumlah elemen 'n', algoritma pengurutan
Radix membutuhkan kompleksitas berikut...
Kasus Terburuk: O(n)
Kasus Terbaik: O(n)
Kasus Rata-rata: O(n)

Pengantar Algoritme Penelusuran

Mencari elemen dalam larik yang diberikan, ada dua algoritme populer yang tersedia:

1. Pencarian Linier

2. Pencarian Biner

Pencarian linear adalah algoritma pencarian yang sangat sederhana. Dalam jenis
pencarian ini, pencarian berurutan dilakukan terhadap semua item satu per satu.
Setiap item diperiksa dan jika ditemukan kecocokan, maka item tersebut akan
dikembalikan, jika tidak, pencarian akan berlanjut hingga akhir pengumpulan data.

Algoritma
Pencarian Linier (Larik A, Nilai x)

Langkah 1: Tetapkan i ke 1
Langkah 2: jika i > n maka lanjutkan
ke langkah 7 Langkah 3: jika A[i] = x
maka lanjutkan ke langkah 6 Langkah
4: Tetapkan i ke i + 1
Langkah 5: Pergi ke Langkah 2
Langkah 6: Cetak Elemen x yang ditemukan pada indeks i dan
lanjutkan ke langkah 8 Langkah 7: Elemen cetak tidak
ditemukan
Langkah 8: Keluar

Pseudocode
prosedur linear_search (daftar, nilai)

untuk setiap item dalam

daftar jika item yang
cocok == nilai
kembalikan lokasi akhir
item jika
akhir untuk
 prosedur akhir
Pencarian biner adalah algoritma pencarian cepat dengan kompleksitas run-time
sebesar Ο(log n). Algoritma pencarian ini bekerja berdasarkan prinsip bagi dan
taklukkan. Agar algoritma ini dapat bekerja dengan baik, pengumpulan data harus
dalam bentuk terurut.
Pencarian biner mencari item tertentu dengan membandingkan item paling tengah
dari koleksi. Jika ada kecocokan, maka indeks item dikembalikan. Jika item tengah
lebih besar dari item tersebut, maka item tersebut dicari dalam sub-larik di sebelah
kiri item tengah. Jika tidak, item tersebut dicari di sub-larik di sebelah kanan item
tengah. Proses ini berlanjut pada sub-larik hingga ukuran sub-larik berkurang
menjadi nol.

Bagaimana Cara Kerja Pencarian Biner?

Agar pencarian biner dapat bekerja, larik target harus diurutkan. Kita akan
mempelajari proses pencarian biner dengan sebuah contoh bergambar. Berikut ini
adalah larik terurut kita dan kita asumsikan bahwa kita perlu mencari lokasi nilai 31
menggunakan pencarian biner.

Pertama, kita akan menentukan setengah dari larik dengan menggunakan rumus ini -
pertengahan = rendah + (tinggi - rendah) / 2
Ini dia, 0 + (9 - 0) / 2 = 4 (nilai bilangan bulat 4,5). Jadi, 4 adalah nilai tengah dari larik.

Sekarang kita bandingkan nilai yang tersimpan di lokasi 4, dengan nilai yang sedang
dicari, yaitu
31. Kita menemukan bahwa nilai di lokasi 4 adalah 27, yang bukan merupakan
kecocokan. Karena nilainya lebih besar dari 27 dan kita memiliki larik terurut, maka
kita juga tahu bahwa nilai target harus berada di bagian atas larik.

Kita ubah nilai terendah ke nilai tengah + 1 dan menemukan nilai tengah yang baru
lagi.
rendah = pertengahan + 1
pertengahan = rendah + (tinggi - rendah) / 2
Nilai tengah baru kita sekarang adalah 7. Kita bandingkan nilai yang tersimpan di
lokasi 7 dengan nilai target 31.

Nilai yang disimpan di lokasi 7 bukanlah sebuah kecocokan, melainkan lebih dari
y a n g kita cari. Jadi, nilainya harus berada di bagian bawah dari lokasi ini.

Oleh karena itu, kami menghitung nilai tengahnya lagi. Kali ini nilainya adalah 5.

Kami membandingkan nilai yang tersimpan di lokasi 5 dengan nilai target kami. Kami
menemukan bahwa nilai tersebut cocok.

Kami menyimpulkan bahwa nilai target 31 disimpan di lokasi 5.

Pencarian biner membagi dua item yang dapat dicari dan dengan demikian
mengurangi jumlah perbandingan yang harus dibuat menjadi sangat sedikit.

Pseudocode
Pseudocode algoritma pencarian biner akan terlihat seperti ini -
Prosedur binary_search
A ← larik terurut
n ← ukuran larik
x ← nilai yang akan dicari

Set lowerBound = 1
Set upperBound = n

sementara x tidak ditemukan

if upperBound < lowerBound
KELUAR: x tidak ada.
 set midPoint = lowerBound + (upperBound - lowerBound) / 2

if A[midPoint] < x
set lowerBound = titik tengah + 1

jika A [titik tengah] > x

set upperBound = titik tengah - 1

jika A[titik tengah] = x

KELUAR: x ditemukan di lokasi titik
tengah ujung sementara

prosedur akhir

APLIKASI TUMPUKAN

Menara Hanoi, adalah teka-teki matematika yang terdiri dari tiga menara (pasak) dan
lebih dari satu cincin seperti yang digambarkan -

Cincin-cincin ini memiliki ukuran yang berbeda dan ditumpuk dengan urutan
menaik, yaitu cincin yang lebih kecil berada di atas cincin yang lebih besar. Ada
variasi lain dari teka-teki ini di mana jumlah cakramnya bertambah, tetapi jumlah
menaranya tetap sama.

Aturan
Misinya adalah memindahkan semua disk ke menara lain tanpa melanggar urutan
susunan. Beberapa aturan yang harus diikuti untuk Menara Hanoi adalah -

• Hanya satu disk yang dapat dipindahkan di antara menara pada waktu tertentu.
• Hanya disk "atas" yang dapat dilepas.
• Tidak ada disk besar yang dapat diletakkan di atas disk kecil.
Berikut ini adalah representasi animasi untuk memecahkan teka-teki Menara Hanoi
dengan tiga disk.
Teka-teki Menara Hanoi dengan n disk dapat diselesaikan dalam minimal 2n -1
langkah. Presentasi ini menunjukkan bahwa teka-teki dengan 3 disk membutuhkan
23 - 1 = 7 langkah.

Algoritma
Untuk menulis algoritma untuk Tower of Hanoi, pertama-tama kita perlu
mempelajari bagaimana menyelesaikan masalah ini dengan jumlah disk yang lebih
sedikit, katakanlah → 1 atau 2. Kita tandai tiga menara dengan nama, sumber,
tujuan dan aux (hanya untuk membantu memindahkan disk). Jika kita hanya
memiliki satu disk, maka disk tersebut dapat dengan mudah dipindahkan dari pasak
sumber ke pasak tujuan.
Jika kita memiliki 2 disk -

• Pertama, kita pindahkan disk yang lebih kecil (atas) ke aux peg.
• Kemudian, kita pindahkan disk yang lebih besar (bagian bawah) ke pasak tujuan.
• Dan terakhir, kami memindahkan disk yang lebih kecil dari aux ke pasak tujuan.

Jadi sekarang, kami berada dalam posisi untuk merancang algoritma untuk Tower
of Hanoi dengan lebih dari dua disk. Kita membagi tumpukan disk menjadi dua
bagian. Disk terbesar (nth disk) berada di satu bagian dan semua disk lainnya (n-1)
berada di bagian kedua.
Tujuan utama kita adalah memindahkan disk n dari sumber ke tujuan dan kemudian
meletakkan semua disk lainnya (n1) ke dalamnya. Kita dapat membayangkan untuk
menerapkan hal yang sama dengan cara rekursif untuk semua kumpulan disk yang
diberikan.
Langkah-langkah yang harus diikuti adalah -
Langkah 1 - Memindahkan n-1 disk dari sumber
ke aux Langkah 2 - Memindahkan disk ke-n
dari sumber ke tujuan Langkah 3 -
Memindahkan n-1 disk dari aux ke tujuan
MENGEVALUASI EKSPRESI ARITMATIKA

Organisasi tumpukan sangat efektif dalam mengevaluasi ekspresi aritmatika.

Ekspresi biasanya direpresentasikan dalam apa yang dikenal sebagai notasi Infix,
di mana setiap operator ditulis di antara dua operan (yaitu, A + B). Dengan notasi
ini, kita harus membedakan antara (A + B) * C dan A + (B * C) dengan
menggunakan tanda kurung atau konvensi operator-prioritas. Dengan demikian,
urutan operator dan operan dalam ekspresi aritmatika tidak secara unik
menentukan urutan operasi yang akan dilakukan.
1. Notasi Polandia (notasi awalan) -
Ini mengacu pada notasi di mana operator ditempatkan sebelum dua operan . Di
sini tidak diperlukan tanda kurung, yaitu,
+ AB
2. Notasi Polandia terbalik (notasi postfix) -
Ini mengacu pada notasi analog di mana operator ditempatkan setelah dua
operan. Sekali lagi, tidak ada tanda kurung yang diperlukan dalam notasi
Polandia Terbalik

Komputer yang terorganisir dengan tumpukan lebih cocok untuk notasi post-fix
dibandingkan dengan notasi infix tradisional. Oleh karena itu, notasi infix harus
dikonversi ke notasi post-fix. Konversi dari notasi infix ke notasi post-fix harus
mempertimbangkan hirarki operasional.
Ada 3 tingkat prioritas untuk 5 operator biner seperti yang diberikan di bawah ini:
3. Tertinggi: Eksponensial (^)
4. Tertinggi berikutnya: Perkalian (*) dan pembagian (/)
5. Terendah: Penambahan (+) dan Pengurangan (-)

Berikut ini adalah ringkasan dari peraturan tersebut:

1. Mencetak operan saat operan tiba.

2. Jika tumpukan kosong atau berisi tanda kurung kiri di atas, dorong operator
yang masuk ke tumpukan.

3. Jika simbol yang masuk adalah tanda kurung kiri, dorong simbol tersebut ke atas
tumpukan.

4. Jika simbol yang masuk adalah tanda kurung kanan, keluarkan

tumpukan dan cetak operator sampai Anda melihat tanda kurung kiri.
Buang pasangan tanda kurung tersebut.

5. Jika simbol yang masuk memiliki prioritas yang lebih tinggi daripada bagian
atas tumpukan, dorong simbol tersebut ke atas tumpukan.

6. Jika simbol yang masuk memiliki prioritas yang sama dengan bagian atas
tumpukan, gunakan asosiasi. Jika asosiasinya dari kiri ke kanan, munculkan dan
cetak bagian atas tumpukan lalu dorong operator yang masuk. Jika asosiasinya
dari kanan ke kiri, dorong operator yang masuk.
7. Jika simbol yang masuk memiliki prioritas yang lebih rendah dari simbol di
puncak tumpukan, keluarkan tumpukan dan cetak operator teratas. Kemudian uji
operator yang masuk terhadap puncak tumpukan yang baru.

8. Pada akhir ekspresi, munculkan dan cetak semua operator pada stack.
(Tidak ada tanda kurung yang tersisa.)

A * (B + C * D) + E menjadi A B C D * + * E +

simboloperator saat ini stackpostfix string

1 A A
2 * * A

3 ( *( A

4 B *( AB

5 + *(+ AB

6 C *(+ ABC

7 * *(+* ABC

8 D *(+* ABCD

9 ) * ABCD*+

10 + + ABCD*+*

11 E + ABCD*+*E
12 ABCD*+*E+

Contoh 2

A * B ^ C + D menjadi A B C ^ * D +

Di sini, eksponensial dan perkalian harus dilakukan sebelum penjumlahan.

simboloperator saat ini stackpostfix string

1 A A
 2 * * A
3 B * AB

4 ^ *^ AB

5 C *^ ABC

6 + + ABC^*

7 D + ABC^*D
8 ABC^*D+

MENGEVALUASI EKSPRESI POSTFIX

Sekarang kita perlu menghitung nilai dari operasi aritmatika ini dengan
menggunakan stack. Prosedur untuk mendapatkan hasilnya adalah:
1. Ubah ekspresi dalam notasi Polandia Terbalik (notasi setelah perbaikan).
2. Dorong operan ke dalam tumpukan sesuai urutan kemunculannya.
3. Ketika ada operator yang ditemui, maka munculkan dua operand paling atas
untuk menjalankan operasi.
4. Setelah eksekusi, dorong hasil yang diperoleh ke dalam stack.
5. Setelah eksekusi ekspresi selesai, hasil akhir tetap berada di bagian atas
tumpukan.
Sebagai contoh -
Notasi infiks: (2+4) * (4+6)
Notasi pasca-perbaikan: 2 4 + 4 6 + *
Hasil: 60
Operasi tumpukan untuk evaluasi ekspresi ini ditunjukkan di bawah ini:
SIMBOL PENYEIMBANG
Diberikan sebuah ekspresi string exp , tuliskan sebuah program untuk memeriksa
apakah pasangan dan
urutan "{","}","(",")","[","]" sudah benar dalam exp.
Contoh:
Masukan: exp = "[()]{}{[()()]()}"
Keluaran Seimbang
Masukan: exp = "[(])"
Keluaran: Tidak
Seimbang
Algoritma:
• Mendeklarasikan tumpukan karakter S.
• Sekarang melintasi string ekspresi exp.
1. Jika karakter saat ini adalah kurung awal ('(' atau '{' atau '['), maka dorong karakter
tersebut ke tumpukan.
2. Jika karakter saat ini adalah tanda kurung tutup (')' atau '}' atau ']') maka pop
dari tumpukan dan jika karakter yang muncul adalah tanda kurung awal yang
cocok maka tidak masalah jika tanda kurung tidak seimbang.
• Setelah penjelajahan selesai, jika ada beberapa braket awal yang tersisa
dalam tumpukan maka "tidak seimbang"
Gambar di bawah ini adalah uji coba pendekatan di atas: