PRAKTIKUM 11: Menggunakan struktur data tree dalam pemrograman
Alat/Bahan
• Komputer dengan lingkungan pemrograman C (misalnya, GCC atau Dev-C++).
• Editor teks untuk menulis kode C. Code::Blocks
• Compiler atau interpreter untuk menjalankan kode C.
• Buku atau materi referensi tentang pemrograman dalam bahasa C.
• .Modul 11 Menggunakan struktur data tree dalam pemrograman.
V. Prosedur Praktikum
Praktekan Latihan Berikut:
Soal Praktek 1: Sistem Manajemen Buku
1) Buatlah program yang menggunakan struktur data tree untuk mengimplementasikan sistem
manajemen buku. Setiap buku memiliki informasi seperti judul, penulis, dan tahun terbit.
Program tersebut harus memiliki fitur sebagai berikut:
• Menambahkan buku baru ke dalam struktur data tree.
• Menghapus buku dari struktur data tree berdasarkan judul.
• Menampilkan seluruh buku dalam struktur data tree.
Soal Praktek 2: Sistem Organisasi Perusahaan
2) Buatlah program yang menggunakan struktur data tree untuk mengimplementasikan sistem
organisasi perusahaan. Setiap simpul dalam tree mewakili seorang karyawan dan memiliki
informasi seperti nama, ID, jabatan, dan gaji. Program tersebut harus memiliki fitur sebagai
berikut:
• Menambahkan karyawan baru ke dalam struktur data tree.
• Menghapus karyawan dari struktur data tree berdasarkan ID.
• Menampilkan seluruh karyawan dalam struktur data tree.
Soal Praktek 3: Sistem Pohon Keluarga
3) Buatlah program yang menggunakan struktur data tree untuk mengimplementasikan sistem
pohon keluarga. Setiap simpul dalam tree mewakili seorang anggota keluarga dan memiliki
informasi seperti nama, usia, dan hubungan dengan anggota keluarga lainnya. Program
tersebut harus memiliki fitur sebagai berikut:
• Menambahkan anggota keluarga baru ke dalam struktur data tree.
• Menghapus anggota keluarga dari struktur data tree berdasarkan nama.
• Menampilkan seluruh anggota keluarga dalam struktur data tree.
Dengan melakukan praktek pada soal-soal di atas, Anda akan memperoleh pemahaman yang baik
tentang implementasi struktur data tree dalam bahasa C dan bagaimana memanfaatkannya dalam
pemecahan masalah nyata.
1. Jawaban Soal Praktek 1: Sistem Manajemen Buku
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Buku {
char judul[100];
char penulis[100];
int tahunTerbit;
struct Buku* left;
struct Buku* right;
} Buku;
Buku* createNode(char judul[], char penulis[], int tahunTerbit) {
Buku* newNode = (Buku*)malloc(sizeof(Buku));
strcpy(newNode->judul, judul);
strcpy(newNode->penulis, penulis);
newNode->tahunTerbit = tahunTerbit;
newNode->left = newNode->right = NULL;
return newNode;
}
Buku* tambahBuku(Buku* root, char judul[], char penulis[], int tahunTerbit) {
if (root == NULL) {
return createNode(judul, penulis, tahunTerbit);
}
if (strcmp(judul, root->judul) < 0) {
root->left = tambahBuku(root->left, judul, penulis, tahunTerbit);
} else if (strcmp(judul, root->judul) > 0) {
root->right = tambahBuku(root->right, judul, penulis, tahunTerbit);
}
return root;
}
Buku* cariBuku(Buku* root, char judul[]) {
if (root == NULL || strcmp(judul, root->judul) == 0) {
return root;
}
if (strcmp(judul, root->judul) < 0) {
return cariBuku(root->left, judul);
} else {
return cariBuku(root->right, judul);
}
}
Buku* findMinBuku(Buku* root) {
Buku* current = root;
while (current && current->left != NULL) {
current = current->left;
}
return current;
}
Buku* hapusBuku(Buku* root, char judul[]) {
if (root == NULL) {
return root;
}
if (strcmp(judul, root->judul) < 0) {
root->left = hapusBuku(root->left, judul);
} else if (strcmp(judul, root->judul) > 0) {
root->right = hapusBuku(root->right, judul);
} else {
if (root->left == NULL && root->right == NULL) {
free(root);
root = NULL;
} else if (root->left == NULL) {
Buku* temp = root;
root = root->right;
free(temp);
} else if (root->right == NULL) {
Buku* temp = root;
root = root->left;
free(temp);
} else {
Buku* temp = findMinBuku(root->right);
strcpy(root->judul, temp->judul);
strcpy(root->penulis, temp->penulis);
root->tahunTerbit = temp->tahunTerbit;
root->right = hapusBuku(root->right, temp->judul);
}
}
return root;
}
void tampilkanBuku(Buku* root) {
if (root != NULL) {
tampilkanBuku(root->left);
printf("Judul: %s\n", root->judul);
printf("Penulis: %s\n", root->penulis);
printf("Tahun Terbit: %d\n", root->tahunTerbit);
printf("----------------------\n");
tampilkanBuku(root->right);
}
}
int main() {
Buku* root = NULL;
root = tambahBuku(root, "Harry Potter", "J.K. Rowling", 1997);
root = tambahBuku(root, "The Hobbit", "J.R.R. Tolkien", 1937);
root = tambahBuku(root, "To Kill a Mockingbird", "Harper Lee", 1960);
printf("Daftar Buku:\n");
tampilkanBuku(root);
root = tambahBuku(root, "1984", "George Orwell", 1949);
printf("Daftar Buku setelah penambahan:\n");
tampilkanBuku(root);
root = hapusBuku(root, "The Hobbit");
printf("Daftar Buku setelah penghapusan:\n");
tampilkanBuku(root);
return 0;
}
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
Program di atas merupakan implementasi dari sistem manajemen
buku menggunakan struktur data tree dalam bahasa C. Program
ini memiliki tiga fitur utama: menambahkan buku baru ke dalam
tree (tambahBuku), menghapus buku dari tree berdasarkan judul
(hapusBuku), dan menampilkan seluruh buku dalam tree
(tampilkanBuku).
Pada awalnya, program sudah memiliki beberapa buku awal yang
ditambahkan ke dalam tree menggunakan fungsi tambahBuku.
Kemudian, program menampilkan seluruh buku dalam tree
menggunakan fungsi tampilkanBuku.
Selanjutnya, program menambahkan buku baru ke dalam tree
menggunakan fungsi tambahBuku. Setelah penambahan, program
kembali menampilkan seluruh buku dalam tree untuk
memperlihatkan buku baru yang ditambahkan.
Kemudian, program menghapus buku dari tree menggunakan fungsi
hapusBuku berdasarkan judul. Setelah penghapusan, program
kembali menampilkan seluruh buku dalam tree untuk
memperlihatkan buku yang telah dihapus.
Program ini menggambarkan cara penggunaan struktur data tree
dalam implementasi sistem manajemen buku. Dengan menggunakan
operasi dasar pada tree seperti penambahan, penghapusan, dan
pencarian elemen, program dapat mengelola data buku dengan
efisien.
2. Jawaban Soal Praktek 2: Sistem Organisasi Perusahaan
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Karyawan {
char nama[50];
int ID;
char jabatan[50];
double gaji;
struct Karyawan* left;
struct Karyawan* right;
} Karyawan;
Karyawan* buatKaryawan(char nama[], int ID, char jabatan[], double gaji) {
Karyawan* karyawan = (Karyawan*)malloc(sizeof(Karyawan));
strcpy(karyawan->nama, nama);
karyawan->ID = ID;
strcpy(karyawan->jabatan, jabatan);
karyawan->gaji = gaji;
karyawan->left = NULL;
karyawan->right = NULL;
return karyawan;
}
Karyawan* tambahKaryawan(Karyawan* root, char nama[], int ID, char jabatan[], double gaji) {
if (root == NULL) {
return buatKaryawan(nama, ID, jabatan, gaji);
}
if (ID < root->ID) {
root->left = tambahKaryawan(root->left, nama, ID, jabatan, gaji);
} else if (ID > root->ID) {
root->right = tambahKaryawan(root->right, nama, ID, jabatan, gaji);
}
return root;
}
Karyawan* cariKaryawan(Karyawan* root, int ID) {
if (root == NULL || root->ID == ID) {
return root;
}
if (ID < root->ID) {
return cariKaryawan(root->left, ID);
}
return cariKaryawan(root->right, ID);
}
void tampilkanKaryawan(Karyawan* root) {
if (root != NULL) {
tampilkanKaryawan(root->left);
printf("Nama: %s\n", root->nama);
printf("ID: %d\n", root->ID);
printf("Jabatan: %s\n", root->jabatan);
printf("Gaji: %.2lf\n", root->gaji);
printf("----------------------\n");
tampilkanKaryawan(root->right);
}
}
Karyawan* hapusKaryawan(Karyawan* root, int ID) {
if (root == NULL) {
return root;
}
if (ID < root->ID) {
root->left = hapusKaryawan(root->left, ID);
} else if (ID > root->ID) {
root->right = hapusKaryawan(root->right, ID);
} else {
if (root->left == NULL) {
Karyawan* temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
Karyawan* temp = root->left;
free(root);
return temp;
}
Karyawan* temp = root->right;
while (temp && temp->left != NULL) {
temp = temp->left;
}
strcpy(root->nama, temp->nama);
root->ID = temp->ID;
strcpy(root->jabatan, temp->jabatan);
root->gaji = temp->gaji;
root->right = hapusKaryawan(root->right, temp->ID);
}
return root;
}
int main() {
Karyawan* root = NULL;
root = tambahKaryawan(root, "Andi", 1001, "Manager", 5000.00);
root = tambahKaryawan(root, "Budi", 1002, "Supervisor", 4000.00);
root = tambahKaryawan(root, "Cindy", 1003, "Staff", 3000.00);
root = tambahKaryawan(root, "Dewi", 1004, "Staff", 3000.00);
root = tambahKaryawan(root, "Eko", 1005, "Staff", 3000.00);
printf("Daftar Karyawan:\n");
tampilkanKaryawan(root);
int ID = 1003;
root = hapusKaryawan(root, ID);
printf("Karyawan dengan ID %d telah dihapus.\n", ID);
printf("Daftar Karyawan setelah penghapusan:\n");
tampilkanKaryawan(root);
return 0;
}
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
▪ berikut hasilnya
Program di atas mengimplementasikan sistem organisasi
perusahaan menggunakan struktur data tree. Setiap simpul dalam
tree mewakili seorang karyawan dengan informasi seperti nama,
ID, jabatan, dan gaji. Program ini memiliki fitur penambahan
karyawan baru ke dalam tree, penghapusan karyawan dari tree
berdasarkan ID, dan penampilan seluruh daftar karyawan dalam
tree.
Pada awalnya, beberapa karyawan ditambahkan ke dalam tree
menggunakan fungsi tambahKaryawan(). Kemudian, seluruh daftar
karyawan ditampilkan menggunakan fungsi tampilkanKaryawan().
Selanjutnya, salah satu karyawan dihapus dari tree berdasarkan
ID menggunakan fungsi hapusKaryawan(). Akhirnya, daftar
karyawan yang tersisa ditampilkan kembali untuk memperlihatkan
karyawan yang telah dihapus.
Program ini menggambarkan cara penggunaan struktur data tree
dalam implementasi sistem organisasi perusahaan. Dengan
menggunakan operasi dasar pada tree seperti penambahan,
penghapusan, dan pencarian elemen, program dapat mengelola
data karyawan dengan efisien.
3. Jawaban Soal Praktek 3: Sistem Pohon Keluarga
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct AnggotaKeluarga {
char nama[50];
int usia;
char hubungan[50];
struct AnggotaKeluarga* anak;
struct AnggotaKeluarga* saudara;
} AnggotaKeluarga;
AnggotaKeluarga* buatAnggotaKeluarga(char nama[], int usia, char hubungan[]) {
AnggotaKeluarga* anggota = (AnggotaKeluarga*)malloc(sizeof(AnggotaKeluarga));
strcpy(anggota->nama, nama);
anggota->usia = usia;
strcpy(anggota->hubungan, hubungan);
anggota->anak = NULL;
anggota->saudara = NULL;
return anggota;
}
AnggotaKeluarga* tambahAnggotaKeluarga(AnggotaKeluarga* root, char nama[], int usia, char hubungan[]) {
if (root == NULL) {
return buatAnggotaKeluarga(nama, usia, hubungan);
}
if (root->anak == NULL) {
root->anak = tambahAnggotaKeluarga(root->anak, nama, usia, hubungan);
} else {
AnggotaKeluarga* temp = root->anak;
while (temp->saudara != NULL) {
temp = temp->saudara;
}
temp->saudara = tambahAnggotaKeluarga(temp->saudara, nama, usia, hubungan);
}
return root;
}
AnggotaKeluarga* cariAnggotaKeluarga(AnggotaKeluarga* root, char nama[]) {
if (root == NULL || strcmp(root->nama, nama) == 0) {
return root;
}
AnggotaKeluarga* temp = root->anak;
while (temp != NULL) {
AnggotaKeluarga* result = cariAnggotaKeluarga(temp, nama);
if (result != NULL) {
return result;
}
temp = temp->saudara;
}
return NULL;
}
void tampilkanAnggotaKeluarga(AnggotaKeluarga* root) {
if (root != NULL) {
printf("Nama: %s\n", root->nama);
printf("Usia: %d\n", root->usia);
printf("Hubungan: %s\n", root->hubungan);
printf("----------------------\n");
AnggotaKeluarga* temp = root->anak;
while (temp != NULL) {
tampilkanAnggotaKeluarga(temp);
temp = temp->saudara;
}
}
}
AnggotaKeluarga* hapusAnggotaKeluarga(AnggotaKeluarga* root, char nama[]) {
if (root == NULL) {
return root;
}
if (strcmp(root->nama, nama) == 0) {
return NULL;
}
AnggotaKeluarga* temp = root->anak;
if (temp != NULL && strcmp(temp->nama, nama) == 0) {
root->anak = temp->saudara;
free(temp);
} else {
while (temp != NULL && temp->saudara != NULL) {
if (strcmp(temp->saudara->nama, nama) == 0) {
AnggotaKeluarga* toDelete = temp->saudara;
temp->saudara = toDelete->saudara;
free(toDelete);
break;
}
temp = temp->saudara;
}
}
temp = root->anak;
while (temp != NULL) {
temp->anak = hapusAnggotaKeluarga(temp->anak, nama);
temp = temp->saudara;
}
return root;
}
int main() {
AnggotaKeluarga* keluarga = NULL;
keluarga = tambahAnggotaKeluarga(keluarga, "Andi", 30, "Ayah");
keluarga = tambahAnggotaKeluarga(keluarga, "Cindy", 28, "Ibu");
keluarga = tambahAnggotaKeluarga(keluarga, "Budi", 10, "Anak");
printf("Daftar Anggota Keluarga:\n");
tampilkanAnggotaKeluarga(keluarga);
char nama[] = "Cindy";
keluarga = hapusAnggotaKeluarga(keluarga, nama);
printf("Anggota keluarga dengan nama %s telah dihapus.\n", nama);
printf("Daftar Anggota Keluarga setelah penghapusan:\n");
tampilkanAnggotaKeluarga(keluarga);
return 0;
}
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
▪ berikut hasilnya
Program di atas mengimplementasikan sistem pohon keluarga menggunakan struktur data
tree. Setiap simpul dalam tree mewakili seorang anggota keluarga dengan informasi seperti
nama, usia, dan hubungan dengan anggota keluarga lainnya. Program ini memiliki fitur
penambahan anggota keluarga baru ke dalam tree, penghapusan anggota keluarga dari tree
berdasarkan nama, dan penampilan seluruh daftar anggota keluarga dalam tree.
Pada awalnya, beberapa anggota keluarga ditambahkan ke dalam tree menggunakan fungsi
tambahAnggotaKeluarga(). Kemudian, seluruh daftar anggota keluarga ditampilkan
menggunakan fungsi tampilkanAnggotaKeluarga(). Selanjutnya, salah satu anggota
keluarga dihapus dari tree berdasarkan nama menggunakan fungsi
hapusAnggotaKeluarga(). Akhirnya, daftar anggota keluarga yang tersisa ditampilkan
kembali untuk memperlihatkan anggota keluarga yang telah dihapus.
Program ini menggambarkan cara penggunaan struktur data tree dalam implementasi sistem
pohon keluarga. Dengan menggunakan operasi dasar pada tree seperti penambahan,
penghapusan, dan pencarian elemen, kita dapat memanajemen anggota keluarga dalam
struktur data yang terorganisir.
Studi Kasus operasi dasar pada struktur data tree
Andi memiliki sebuah program untuk mengelola daftar kontak teman-temannya menggunakan
struktur data tree. Program tersebut memiliki fitur penambahan kontak baru, penghapusan kontak
berdasarkan nama, dan pencarian kontak berdasarkan nama. Tugas Anda adalah
mengimplementasikan operasi dasar berikut dalam bahasa C:
1. Tambahkan fungsi tambahKontak() yang menerima input nama dan nomor telepon dari
pengguna, dan menambahkan kontak baru ke dalam struktur data tree.
2. Tambahkan fungsi hapusKontak() yang menerima input nama dari pengguna, dan
menghapus kontak dengan nama tersebut dari struktur data tree.
3. Tambahkan fungsi cariKontak() yang menerima input nama dari pengguna, dan mencari
kontak dengan nama tersebut dalam struktur data tree. Fungsi ini harus mengembalikan
informasi kontak jika ditemukan, atau pesan bahwa kontak tidak ditemukan.
Tugas Anda adalah melengkapi program dengan operasi dasar di atas, serta menjelaskan cara kerja
program tersebut.
Silakan implementasikan jawaban programnya dalam bahasa C.
1. Jawaban Soal
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Kontak {
char nama[50];
char nomorTelepon[15];
struct Kontak* kiri;
struct Kontak* kanan;
} Kontak;
void tambahKontak(Kontak** root, char nama[], char nomorTelepon[]) {
Kontak* kontakBaru = (Kontak*)malloc(sizeof(Kontak));
strcpy(kontakBaru->nama, nama);
strcpy(kontakBaru->nomorTelepon, nomorTelepon);
kontakBaru->kiri = NULL;
kontakBaru->kanan = NULL;
if (*root == NULL) {
*root = kontakBaru;
} else {
Kontak* current = *root;
Kontak* parent = NULL;
while (current != NULL) {
parent = current;
if (strcmp(nama, current->nama) < 0) {
current = current->kiri;
} else {
current = current->kanan;
}
}
if (strcmp(nama, parent->nama) < 0) {
parent->kiri = kontakBaru;
} else {
parent->kanan = kontakBaru;
}
}
}
Kontak* cariKontak(Kontak* root, char nama[]) {
if (root == NULL || strcmp(nama, root->nama) == 0) {
return root;
}
if (strcmp(nama, root->nama) < 0) {
return cariKontak(root->kiri, nama);
}
return cariKontak(root->kanan, nama);
}
Kontak* hapusKontak(Kontak* root, char nama[]) {
if (root == NULL) {
return root;
}
if (strcmp(nama, root->nama) < 0) {
root->kiri = hapusKontak(root->kiri, nama);
} else if (strcmp(nama, root->nama) > 0) {
root->kanan = hapusKontak(root->kanan, nama);
} else {
if (root->kiri == NULL) {
Kontak* temp = root->kanan;
free(root);
return temp;
} else if (root->kanan == NULL) {
Kontak* temp = root->kiri;
free(root);
return temp;
}
Kontak* temp = root->kanan;
while (temp->kiri != NULL) {
temp = temp->kiri;
}
strcpy(root->nama, temp->nama);
strcpy(root->nomorTelepon, temp->nomorTelepon);
root->kanan = hapusKontak(root->kanan, temp->nama);
}
return root;
}
void tampilkanKontak(Kontak* root) {
if (root != NULL) {
tampilkanKontak(root->kiri);
printf("Nama: %s, Nomor Telepon: %s\n", root->nama, root->nomorTelepon);
tampilkanKontak(root->kanan);
}
}
int main() {
Kontak* root = NULL;
tambahKontak(&root, "Andi", "08123456789");
tambahKontak(&root, "Budi", "08234567890");
tambahKontak(&root, "Cindy", "08345678901");
printf("Daftar Kontak:\n");
tampilkanKontak(root);
printf("\n");
char namaCari[50];
strcpy(namaCari, "Budi");
Kontak* hasilCari = cariKontak(root, namaCari);
if (hasilCari != NULL) {
printf("Kontak dengan nama '%s' ditemukan!\n", namaCari);
printf("Nama: %s, Nomor Telepon: %s\n", hasilCari->nama, hasilCari->nomorTelepon);
} else {
printf("Kontak dengan nama '%s' tidak ditemukan.\n", namaCari);
}
printf("\n");
char namaHapus[50];
strcpy(namaHapus, "Budi");
root = hapusKontak(root, namaHapus);
printf("Setelah menghapus kontak dengan nama '%s':\n", namaHapus);
tampilkanKontak(root);
return 0;
}
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
▪ berikut hasilnya
Program di atas mengimplementasikan operasi dasar pada
struktur data tree untuk mengelola daftar kontak teman. Pada
program ini, setiap simpul dalam tree mewakili seorang
kontak dengan informasi nama dan nomor telepon.
✓ Fungsi tambahKontak() digunakan untuk menambahkan kontak
baru ke dalam tree. Fungsi ini memeriksa posisi yang tepat
untuk menambahkan kontak baru sesuai dengan urutan
alfabet nama kontak.
✓ Fungsi cariKontak() digunakan untuk mencari kontak
berdasarkan nama. Fungsi ini melakukan pencarian rekursif
dalam tree dan mengembalikan kontak jika ditemukan.
✓ Fungsi hapusKontak() digunakan untuk menghapus kontak
berdasarkan nama. Fungsi ini mencari kontak yang akan
dihapus, dan kemudian mengatur kembali pointer pada
simpul-simpul terkait.
✓ Fungsi tampilkanKontak() digunakan untuk menampilkan
semua kontak dalam tree secara inorder, yaitu
menghasilkan urutan nama yang terurut secara alfabet.
Program ini juga menunjukkan contoh penggunaan dengan
menambahkan beberapa kontak, mencari kontak berdasarkan
nama, dan menghapus kontak tertentu.
Comments
Post a Comment