Struktur data tree dalam bahasa C

Tree adalah struktur data yang terdiri dari simpul-simpul yang terhubung, di mana setiap simpul memiliki satu simpul induk (parent) dan nol atau lebih simpul anak (children). Tree digunakan secara luas dalam komputer sains untuk merepresentasikan hierarki, seperti struktur direktori dalam sistem file, hierarki dokumen dalam HTML, atau struktur organisasi dalam perusahaan.
 
Berikut merupakan implementasi kode Struktur data tree dalam beberapa kasus
 
1.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Struktur untuk merepresentasikan informasi buku
struct Book {
    char title[100];
    char author[50];
    int year;
    struct Book* left;
    struct Book* right;
};

// Fungsi untuk membuat simpul baru dalam tree
struct Book* createNode(char title[], char author[], int year) {
    struct Book* newNode = (struct Book*)malloc(sizeof(struct Book));
    strcpy(newNode->title, title);
    strcpy(newNode->author, author);
    newNode->year = year;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Fungsi untuk memasukkan buku baru ke dalam tree
struct Book* insertBook(struct Book* root, char title[], char author[], int year) {
    // Jika tree kosong, buat simpul baru sebagai root
    if (root == NULL) {
        return createNode(title, author, year);
    }

    // Jika judul buku lebih kecil, masukkan ke anak kiri
    if (strcmp(title, root->title) < 0) {
        root->left = insertBook(root->left, title, author, year);
    }
        // Jika judul buku lebih besar, masukkan ke anak kanan
    else if (strcmp(title, root->title) > 0) {
        root->right = insertBook(root->right, title, author, year);
    }

    return root;
}

// Fungsi untuk menemukan buku dengan judul tertentu dan menghapusnya dari tree
struct Book* deleteBook(struct Book* root, char title[]) {
    // Jika tree kosong, tidak ada yang dihapus
    if (root == NULL) {
        return root;
    }

    // Cari buku dengan judul yang sesuai
    if (strcmp(title, root->title) < 0) {
        // Buku berada di anak kiri
        root->left = deleteBook(root->left, title);
    } else if (strcmp(title, root->title) > 0) {
        // Buku berada di anak kanan
        root->right = deleteBook(root->right, title);
    } else {
        // Buku ditemukan, hapus buku
        if (root->left == NULL) {
            struct Book* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            struct Book* temp = root->left;
            free(root);
            return temp;
        }

        // Jika buku memiliki dua anak, cari anak terkecil di anak kanan
        struct Book* temp = root->right;
        while (temp->left != NULL) {
            temp = temp->left;
        }

        // Salin informasi anak terkecil ke root
        strcpy(root->title, temp->title);
        strcpy(root->author, temp->author);
        root->year = temp->year;

        // Hapus anak terkecil
        root->right = deleteBook(root->right, temp->title);
    }

    return root;
}

// Fungsi untuk melakukan traversal inorder pada tree
void inorderTraversal(struct Book* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("Judul: %s | Penulis: %s | Tahun Terbit: %d\n", root->title, root->author, root->year);
        inorderTraversal(root->right);
    }
}

// Fungsi utama
int main() {
    struct Book* root = NULL;
    int choice;
    char title[100], author[50];
    int year;

    do {
        // Menu
        printf("\n=== Sistem Manajemen Buku ===\n");
        printf("1. Tambah Buku\n");
        printf("2. Hapus Buku\n");
        printf("3. Tampilkan Seluruh Buku\n");
        printf("0. Keluar\n");
        printf("Pilihan Anda: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                // Menambahkan buku baru ke dalam tree
                printf("Masukkan judul buku: ");
                scanf(" %[^\n]", title);
                printf("Masukkan penulis buku: ");
                scanf(" %[^\n]", author);
                printf("Masukkan tahun terbit: ");
                scanf("%d", &year);
                root = insertBook(root, title, author, year);
                printf("Buku dengan judul '%s' ditambahkan.\n", title);
                break;
            case 2:
                // Menghapus buku berdasarkan judul
                printf("Masukkan judul buku yang ingin dihapus: ");
                scanf(" %[^\n]", title);
                root = deleteBook(root, title);
                break;
            case 3:
                // Menampilkan seluruh buku dalam tree
                printf("Seluruh Buku:\n");
                inorderTraversal(root);
                break;
            case 0:
                // Keluar dari program
                printf("Program berakhir.\n");
                break;
            default:
                printf("Pilihan tidak valid. Coba lagi.\n");
        }

    } while (choice != 0);

    // Dealokasi memori setelah program selesai
    // (Dapat diimplementasikan sebagai fungsi terpisah jika perlu)
    while (root != NULL) {
        struct Book* temp = root;
        root = deleteBook(root, temp->title);
    }

    return 0;
}
  
 output :



 

Penjelasan singkat program:

  1. Program menggunakan struktur struct Book untuk merepresentasikan informasi setiap buku.
  2. Fungsi createNode membuat simpul baru dalam tree.
  3. Fungsi insertBook memasukkan buku baru ke dalam tree.
  4. Fungsi deleteBook mencari dan menghapus buku dari tree berdasarkan judul.
  5. Fungsi inorderTraversal melakukan traversal inorder pada tree untuk menampilkan buku secara terurut.
  6. Fungsi utama menyediakan menu untuk menambahkan buku baru, menghapus buku, dan menampilkan seluruh buku dalam tree. Program berjalan dalam loop hingga pengguna memilih untuk keluar (memasukkan pilihan 0).
  7. Setelah program selesai, memori yang dialokasikan untuk tree akan di-dealokasi.
 
2.  
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Struktur untuk merepresentasikan informasi karyawan
struct Employee {
    char name[100];
    int employeeID;
    char position[50];
    float salary;
    struct Employee* left;
    struct Employee* right;
};

// Fungsi untuk membuat simpul baru dalam tree
struct Employee* createNode(char name[], int employeeID, char position[], float salary) {
    struct Employee* newNode = (struct Employee*)malloc(sizeof(struct Employee));
    strcpy(newNode->name, name);
    newNode->employeeID = employeeID;
    strcpy(newNode->position, position);
    newNode->salary = salary;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Fungsi untuk memasukkan karyawan baru ke dalam tree
struct Employee* insertEmployee(struct Employee* root, char name[], int employeeID, char position[], float salary) {
    // Jika tree kosong, buat simpul baru sebagai root
    if (root == NULL) {
        return createNode(name, employeeID, position, salary);
    }

    // Jika ID karyawan lebih kecil, masukkan ke anak kiri
    if (employeeID < root->employeeID) {
        root->left = insertEmployee(root->left, name, employeeID, position, salary);
    }
        // Jika ID karyawan lebih besar, masukkan ke anak kanan
    else if (employeeID > root->employeeID) {
        root->right = insertEmployee(root->right, name, employeeID, position, salary);
    }

    return root;
}

// Fungsi untuk mencari karyawan dengan ID tertentu dan menghapusnya dari tree
struct Employee* deleteEmployee(struct Employee* root, int employeeID) {
    // Jika tree kosong, tidak ada yang dihapus
    if (root == NULL) {
        return root;
    }

    // Cari karyawan dengan ID yang sesuai
    if (employeeID < root->employeeID) {
        // Karyawan berada di anak kiri
        root->left = deleteEmployee(root->left, employeeID);
    } else if (employeeID > root->employeeID) {
        // Karyawan berada di anak kanan
        root->right = deleteEmployee(root->right, employeeID);
    } else {
        // Karyawan ditemukan, hapus karyawan
        if (root->left == NULL) {
            struct Employee* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            struct Employee* temp = root->left;
            free(root);
            return temp;
        }

        // Jika karyawan memiliki dua anak, cari anak terkecil di anak kanan
        struct Employee* temp = root->right;
        while (temp->left != NULL) {
            temp = temp->left;
        }

        // Salin informasi anak terkecil ke root
        strcpy(root->name, temp->name);
        root->employeeID = temp->employeeID;
        strcpy(root->position, temp->position);
        root->salary = temp->salary;

        // Hapus anak terkecil
        root->right = deleteEmployee(root->right, temp->employeeID);
    }

    return root;
}

// Fungsi untuk melakukan traversal inorder pada tree
void inorderTraversal(struct Employee* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("Nama: %s | ID: %d | Jabatan: %s | Gaji: %.2f\n", root->name, root->employeeID, root->position, root->salary);
        inorderTraversal(root->right);
    }
}

// Fungsi utama
int main() {
    struct Employee* root = NULL;
    int choice, employeeID;
    char name[100], position[50];
    float salary;

    do {
        // Menu
        printf("\n=== Sistem Manajemen Organisasi Perusahaan ===\n");
        printf("1. Tambah Karyawan\n");
        printf("2. Hapus Karyawan\n");
        printf("3. Tampilkan Seluruh Karyawan\n");
        printf("0. Keluar\n");
        printf("Pilihan Anda: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                // Menambahkan karyawan baru ke dalam tree
                printf("Masukkan nama karyawan: ");
                scanf(" %[^\n]", name);
                printf("Masukkan ID karyawan: ");
                scanf("%d", &employeeID);
                printf("Masukkan jabatan: ");
                scanf(" %[^\n]", position);
                printf("Masukkan gaji: ");
                scanf("%f", &salary);
                root = insertEmployee(root, name, employeeID, position, salary);
                printf("Karyawan dengan ID %d ditambahkan.\n", employeeID);
                break;
            case 2:
                // Menghapus karyawan berdasarkan ID
                printf("Masukkan ID karyawan yang ingin dihapus: ");
                scanf("%d", &employeeID);
                root = deleteEmployee(root, employeeID);
                break;
            case 3:
                // Menampilkan seluruh karyawan dalam tree
                printf("Seluruh Karyawan:\n");
                inorderTraversal(root);
                break;
            case 0:
                // Keluar dari program
                printf("Program berakhir.\n");
                break;
            default:
                printf("Pilihan tidak valid. Coba lagi.\n");
        }

    } while (choice != 0);

    // Dealokasi memori setelah program selesai
    // (Dapat diimplementasikan sebagai fungsi terpisah jika perlu)
    while (root != NULL) {
        struct Employee* temp = root;
        root = deleteEmployee(root, temp->employeeID);
    }

    return 0;
}
 output :



Penjelasan singkat program:

  1. Program menggunakan struktur struct Employee untuk merepresentasikan informasi setiap karyawan.
  2. Fungsi createNode membuat simpul baru dalam tree.
  3. Fungsi insertEmployee memasukkan karyawan baru ke dalam tree.
  4. Fungsi deleteEmployee mencari dan menghapus karyawan dari tree berdasarkan ID.
  5. Fungsi inorderTraversal melakukan traversal inorder pada tree untuk menampilkan karyawan secara terurut.
  6. Fungsi utama menyediakan menu untuk menambahkan karyawan baru, menghapus karyawan, dan menampilkan seluruh karyawan dalam tree. Program berjalan dalam loop hingga pengguna memilih untuk keluar (memasukkan pilihan 0).
  7. Setelah program selesai, memori yang dialokasikan untuk tree akan di-dealokasi.

3.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Struktur untuk merepresentasikan informasi anggota keluarga
struct FamilyMember {
    char name[100];
    int age;
    char relationship[50];
    struct FamilyMember* left;
    struct FamilyMember* right;
};

// Fungsi untuk membuat simpul baru dalam tree
struct FamilyMember* createNode(char name[], int age, char relationship[]) {
    struct FamilyMember* newNode = (struct FamilyMember*)malloc(sizeof(struct FamilyMember));
    strcpy(newNode->name, name);
    newNode->age = age;
    strcpy(newNode->relationship, relationship);
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Fungsi untuk memasukkan anggota keluarga baru ke dalam tree
struct FamilyMember* insertFamilyMember(struct FamilyMember* root, char name[], int age, char relationship[]) {
    // Jika tree kosong, buat simpul baru sebagai root
    if (root == NULL) {
        return createNode(name, age, relationship);
    }

    // Jika nama anggota keluarga lebih kecil, masukkan ke anak kiri
    if (strcmp(name, root->name) < 0) {
        root->left = insertFamilyMember(root->left, name, age, relationship);
    }
        // Jika nama anggota keluarga lebih besar, masukkan ke anak kanan
    else if (strcmp(name, root->name) > 0) {
        root->right = insertFamilyMember(root->right, name, age, relationship);
    }

    return root;
}

// Fungsi untuk mencari anggota keluarga dengan nama tertentu dan menghapusnya dari tree
struct FamilyMember* deleteFamilyMember(struct FamilyMember* root, char name[]) {
    // Jika tree kosong, tidak ada yang dihapus
    if (root == NULL) {
        return root;
    }

    // Cari anggota keluarga dengan nama yang sesuai
    if (strcmp(name, root->name) < 0) {
        // Anggota keluarga berada di anak kiri
        root->left = deleteFamilyMember(root->left, name);
    } else if (strcmp(name, root->name) > 0) {
        // Anggota keluarga berada di anak kanan
        root->right = deleteFamilyMember(root->right, name);
    } else {
        // Anggota keluarga ditemukan, hapus anggota keluarga
        if (root->left == NULL) {
            struct FamilyMember* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            struct FamilyMember* temp = root->left;
            free(root);
            return temp;
        }

        // Jika anggota keluarga memiliki dua anak, cari anak terkecil di anak kanan
        struct FamilyMember* temp = root->right;
        while (temp->left != NULL) {
            temp = temp->left;
        }

        // Salin informasi anak terkecil ke root
        strcpy(root->name, temp->name);
        root->age = temp->age;
        strcpy(root->relationship, temp->relationship);

        // Hapus anak terkecil
        root->right = deleteFamilyMember(root->right, temp->name);
    }

    return root;
}

// Fungsi untuk melakukan traversal inorder pada tree
void inorderTraversal(struct FamilyMember* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("Nama: %s | Usia: %d | Hubungan: %s\n", root->name, root->age, root->relationship);
        inorderTraversal(root->right);
    }
}

// Fungsi utama
int main() {
    struct FamilyMember* root = NULL;
    int choice, age;
    char name[100], relationship[50];

    do {
        // Menu
        printf("\n=== Sistem Pohon Keluarga ===\n");
        printf("1. Tambah Anggota Keluarga\n");
        printf("2. Hapus Anggota Keluarga\n");
        printf("3. Tampilkan Seluruh Anggota Keluarga\n");
        printf("0. Keluar\n");
        printf("Pilihan Anda: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                // Menambahkan anggota keluarga baru ke dalam tree
                printf("Masukkan nama anggota keluarga: ");
                scanf(" %[^\n]", name);
                printf("Masukkan usia anggota keluarga: ");
                scanf("%d", &age);
                printf("Masukkan hubungan dengan anggota keluarga lainnya: ");
                scanf(" %[^\n]", relationship);
                root = insertFamilyMember(root, name, age, relationship);
                printf("Anggota keluarga dengan nama '%s' ditambahkan.\n", name);
                break;
            case 2:
                // Menghapus anggota keluarga berdasarkan nama
                printf("Masukkan nama anggota keluarga yang ingin dihapus: ");
                scanf(" %[^\n]", name);
                root = deleteFamilyMember(root, name);
                break;
            case 3:
                // Menampilkan seluruh anggota keluarga dalam tree
                printf("Seluruh Anggota Keluarga:\n");
                inorderTraversal(root);
                break;
            case 0:
                // Keluar dari program
                printf("Program berakhir.\n");
                break;
            default:
                printf("Pilihan tidak valid. Coba lagi.\n");
        }

    } while (choice != 0);

    // Dealokasi memori setelah program selesai
    // (Dapat diimplementasikan sebagai fungsi terpisah jika perlu)
    while (root != NULL) {
        struct FamilyMember* temp = root;
        root = deleteFamilyMember(root, temp->name);
    }

    return 0;
}
output :


Penjelasan singkat program:

  1. Program menggunakan struktur struct FamilyMember untuk merepresentasikan informasi setiap anggota keluarga.
  2. Fungsi createNode membuat simpul baru dalam tree.
  3. Fungsi insertFamilyMember memasukkan anggota keluarga baru ke dalam tree.
  4. Fungsi deleteFamilyMember mencari dan menghapus anggota keluarga dari tree berdasarkan nama.
  5. Fungsi inorderTraversal melakukan traversal inorder pada tree untuk menampilkan anggota keluarga secara terurut.
  6. Fungsi utama menyediakan menu untuk menambahkan anggota keluarga baru, menghapus anggota keluarga, dan menampilkan seluruh anggota keluarga dalam tree. Program berjalan dalam loop hingga pengguna memilih untuk keluar (memasukkan pilihan 0).
  7. Setelah program selesai, memori yang dialokasikan untuk tree akan di-dealokasi.














 
 
 
 
 
 

Comments

Post a Comment

Popular posts from this blog

If, If-else, For Loop, While Loop, Do-While Loop dengan Bahasa C

Image
If, If-else, For Loop, While Loop, Do-While Loop dengan Bahasa C daftar isi : 1. pengertian struktur kontrol 2. If Statment 3. If-Else Statment 4. For Loop 5. While Loop 6. Do-While Loop 1. Pngertian Struktur Kontrol Di dalam pemrograman ada istilah yang di sebut struktur kontrol, apa itu struktur kontrol?. Struktur kontrol di dalam bahasa pemrograman adalah  perintah dengan bentuk (struktur) tertentu yang digunakan untuk mengatur (mengontrol) jalannya program . kali ini kita akan mempraktekan apa itu struktur kontrol 2. If Statment Pemilihan if digunakan untuk menjalankan suatu blok kode jika kondisi tertentu terpenuhi. Jika kondisi evaluasi bernilai benar (true), blok kode di dalam if akan dieksekusi. Jika kondisi evaluasi bernilai salah (false), blok kode di dalam if akan dilewati. kita akan membuat sebuah Flowchart, Pseudocode, dan Code Program dari If Statmnet Flowchart Pseudocode Suruh User memasukan nilai     jika nilai di bagi 2 = 0        ...
Read more

konsep dasar algoritma graf

Image
Algoritma graf dalam bahasa C Algoritma graf adalah algoritma yang digunakan untuk memproses dan memanipulasi struktur data graf. Graf adalah kumpulan simpul (node) yang terhubung oleh sisi (edge). Algoritma graf berfungsi untuk menemukan jalur, menghitung jarak terpendek, mencari lintasan tertentu, atau melakukan operasi lainnya pada struktur data graf. Dalam bahasa C, beberapa algoritma graf populer melibatkan struktur data graf berarah dan tidak berarah. Berikut adalah beberapa algoritma graf umum yang dapat diimplementasikan dalam bahasa C: 1. **Depth-First Search (DFS):**    - DFS digunakan untuk menjelajahi atau mencari jalur dalam graf.    - Pada setiap simpul, DFS akan menelusuri sepanjang satu cabang hingga mencapai simpul leaf sebelum kembali dan menjelajahi cabang lain. 2. **Breadth-First Search (BFS):**    - BFS digunakan untuk menjelajahi atau mencari jalur dalam graf.    - Pada setiap level dari graf, BFS akan menelusuri semua simpul...
Read more