Struktur Referensi Diri dalam C

Halo teman-teman, para ahli coding masa depan! Hari ini, kita akan mengemban perjalanan menarik ke dunia struktur referensi diri dalam C. Jangan khawatir jika itu terdengar sedikit menakutkan - saya berjanji kita akan memecahkannya menjadi bagian-bagian kecil yang bahkan nenek saya bisa mengerti (dan percayalah, dia masih berpikir bahwa mouse adalah hanya seekor hewan bulu kecil).

Apa Itu Struktur Referensi Diri?

Imaginasikan Anda di sebuah pesta, dan Anda ingin memperkenalkan teman Anda kepada seseorang. Anda mungkin akan katakan, "Ini adalah teman saya Alex, dan Alex juga seorang pengembang perangkat lunak." Dalam pengenalan ini, Anda merujuk kepada Alex dua kali - sekali dengan nama dan sekali dengan profesi. Ini adalah hal yang mirip dengan bagaimana struktur referensi diri bekerja dalam C!

Sebuah struktur referensi diri adalah struktur yang mengandung pointer ke struktur yang sama jenis dalam definisinya. Itu seperti boneka Rusia beranak-anak, tetapi bukan boneka kecil di dalamnya, melainkan jenis yang sama dari struktur sepanjang waktu.

Mendefinisikan Struktur Referensi Diri

Ayo masuk kedalam bagaimana kita benar-benar mendefinisikan struktur ini. Ini adalah contoh sederhana:

struct Node {
int data;
struct Node* next;
};

Dalam contoh ini, kita mendefinisikan sebuah struktur yang disebut Node. Itu mengandung dua anggota:

1. Sebuah integer data untuk menyimpan beberapa informasi.
2. Sebuah pointer next yang menunjuk ke struktur Node lainnya.

Ini adalah esensi dari struktur referensi diri - itu merujuk kepada dirinya sendiri dalam definisinya sendiri.

Contoh Struktur Referensi Diri

Sekarang, mari kita lihat beberapa contoh praktis di mana kita mungkin menggunakan struktur referensi diri.

1. Node Daftar Tautan

Kita sudah melihat ini sebelumnya, tapi mari kita perincik lebih lanjut:

struct ListNode {
int data;
struct ListNode* next;
};

Struktur ini sempurna untuk membuat daftar tautan. Setiap node mengandung beberapa data dan pointer ke node berikutnya dalam daftar.

2. Node Pohon

Pohon adalah kasus penggunaan lain yang umum untuk struktur referensi diri:

struct TreeNode {
int data;
struct TreeNode* left;
struct TreeNode* right;
};

Di sini, setiap node dalam pohon dapat memiliki hingga dua anak (kiri dan kanan), memungkinkan kita untuk membuat pohon biner.

3. Node Graf

Untuk yang berani, ini adalah bagaimana kita mungkin merepresentasikan node dalam graf:

struct GraphNode {
int data;
struct GraphNode** neighbors;
int neighborCount;
};

Dalam kasus ini, kita memiliki array pointer ke struktur GraphNode lainnya, merepresentasikan koneksi dalam graf kita.

Membuat Daftar Tautan dengan Struktur Referensi Diri

Sekarang kita mengerti dasarnya, mari kita buat daftar tautan sederhana menggunakan struktur referensi diri. Jangan khawatir jika Anda belum mengerti semua hal itu segera - Romawi tidak dibangun dalam satu hari, dan begitu pula keahlian coding Anda!

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

struct Node {
int data;
struct Node* next;
};

// Fungsi untuk membuat node baru
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}

// Fungsi untuk mencetak daftar tautan
void printList(struct Node* head) {
struct Node* current = head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}

int main() {
struct Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);

printf("Daftar tautan kita: ");
printList(head);

return 0;
}

mari kitauraikan ini:

1. Kita mendefinisikan struktur Node seperti sebelumnya.
2. Kita membuat fungsi createNode yang mengalokasikan memori untuk node baru dan menginisialisasi data.
3. Kita memiliki fungsi printList yang menelusuri daftar dan mencetak data setiap node.
4. Di main, kita membuat daftar tautan dengan tiga node dan mencetaknya.

Ketika Anda menjalankan program ini, Anda seharusnya melihat:

Daftar tautan kita: 1 -> 2 -> 3 -> NULL

Membuat Daftar Tautan Ganda dengan Struktur Referensi Diri

Sekarang, mari kita tingkatkan dan buat daftar tautan ganda. Ini seperti daftar tautan biasa, tetapi setiap node juga memiliki pointer ke node sebelumnya. Itu seperti jalan dua arah bukan jalan satu arah!

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

struct DoubleNode {
int data;
struct DoubleNode* next;
struct DoubleNode* prev;
};

// Fungsi untuk membuat node baru
struct DoubleNode* createDoubleNode(int data) {
struct DoubleNode* newNode = (struct DoubleNode*)malloc(sizeof(struct DoubleNode));
newNode->data = data;
newNode->next = NULL;
newNode->prev = NULL;
return newNode;
}

// Fungsi untuk mencetak daftar tautan maju
void printForward(struct DoubleNode* head) {
struct DoubleNode* current = head;
printf("Maju: ");
while (current != NULL) {
printf("%d <-> ", current->data);
current = current->next;
}
printf("NULL\n");
}

// Fungsi untuk mencetak daftar tautan mundur
void printBackward(struct DoubleNode* tail) {
struct DoubleNode* current = tail;
printf("Mundur: ");
while (current != NULL) {
printf("%d <-> ", current->data);
current = current->prev;
}
printf("NULL\n");
}

int main() {
struct DoubleNode* head = createDoubleNode(1);
head->next = createDoubleNode(2);
head->next->prev = head;
head->next->next = createDoubleNode(3);
head->next->next->prev = head->next;

struct DoubleNode* tail = head->next->next;

printForward(head);
printBackward(tail);

return 0;
}

Dalam contoh ini:

1. Struktur DoubleNode sekarang memiliki kedua pointer next dan prev.
2. Kita membuat fungsi untuk mencetak daftar tautan kedua arah maju dan mundur.
3. Di main, kita membuat daftar tautan ganda dan mengatur kedua pointer next dan prev.

Menjalankan program ini seharusnya memberikan Anda:

Maju: 1 <-> 2 <-> 3 <-> NULL
Mundur: 3 <-> 2 <-> 1 <-> NULL

Membuat Pohon dengan Struktur Referensi Diri

Akhirnya, mari kita buat pohon sederhana menggunakan struktur referensi diri. P想象它作为一个家族树，其中每个人可以有两个孩子。

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

struct TreeNode {
int data;
struct TreeNode* left;
struct TreeNode* right;
};

// Fungsi untuk membuat node baru
struct TreeNode* createTreeNode(int data) {
struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}

// Fungsi untuk melakukan traversal in-order
void inOrderTraversal(struct TreeNode* root) {
if (root != NULL) {
inOrderTraversal(root->left);
printf("%d ", root->data);
inOrderTraversal(root->right);
}
}

int main() {
struct TreeNode* root = createTreeNode(1);
root->left = createTreeNode(2);
root->right = createTreeNode(3);
root->left->left = createTreeNode(4);
root->left->right = createTreeNode(5);

printf("Traversal in-order dari pohon: ");
inOrderTraversal(root);
printf("\n");

return 0;
}

Dalam contoh ini:

1. Struktur TreeNode memiliki left dan right pointer untuk node anak.
2. Kita membuat fungsi untuk melakukan traversal in-order, yang mengunjungi subtree kiri, kemudian root, kemudian subtree kanan.
3. Di main, kita membuat pohon biner sederhana dan melakukan traversal in-order.

Menjalankan program ini seharusnya mengeluarkan:

Traversal in-order dari pohon: 4 2 5 1 3

Dan itu adalah semua, teman-teman! Kita telah mengemban perjalanan ke dunia struktur referensi diri, dari daftar tautan sederhana hingga daftar tautan ganda dan bahkan pohon biner. Ingat, latihan membuat sempurna, jadi jangan khawatir untuk mencoba eksperimen dengan struktur ini dan menciptakan variasi Anda sendiri. Siapa tahu? Anda mungkin menjadi orang berikutnya yang menciptakan struktur data inovatif!

Semoga Anda senang coding, dan may the self-referential structures be with you!

Credits: Image by storyset