Praktikum 8 (Implementasi Struktur Data Stack)
A. Persoalan
1. Stack Menggunakan Array:
Buatlah program dalam bahasa C yang mengimplementasikan stack menggunakan array untuk menyimpan bilangan bulat. Program tersebut harus memiliki fungsi-fungsi berikut:
• push(): Untuk menambahkan elemen ke dalam stack.
• pop(): Untuk menghapus elemen teratas dari stack.
• peek(): Untuk mengambil nilai elemen teratas dari stack tanpa menghapusnya.
• isEmpty(): Untuk memeriksa apakah stack kosong.
• isFull(): Untuk memeriksa apakah stack penuh.
2. Input String:
Buatlah program dalam bahasa C yang menerima input string dari pengguna dan menggunakan stack untuk memeriksa keseimbangan tanda kurung dalam string tersebut. Program harus memberikan output "Keseimbangan Tanda Kurung Benar" jika tanda kurung dalam string seimbang, dan "Keseimbangan Tanda Kurung Salah" jika tanda kurung tidak seimbang.
3. Membalikkan Urutan Kata Dalam Kalimat:
Buatlah program dalam bahasa C yang mengimplementasikan stack untuk membalikkan
urutan kata dalam sebuah kalimat. Program harus menerima input kalimat dari pengguna dan mengeluarkan kalimat dengan urutan kata yang terbalik.
4. Mengubah Notasi Infix:
Buatlah program dalam bahasa C yang mengimplementasikan stack untuk mengubah notasi
infix (contoh: 3 + 4) menjadi notasi postfix (contoh: 3 4 +). Program harus menerima input
ekspresi matematika dalam notasi infix dari pengguna dan mengeluarkan ekspresi dalam notasi postfix.
5. Menghitung Hasil Ekspresi Infix:
Buatlah program dalam bahasa C yang menggunakan stack untuk menghitung hasil dari
ekspresi postfix. Program harus menerima input ekspresi matematika dalam notasi postfix dari pengguna dan mengeluarkan hasil perhitungannya.
B. Jawaban
1. Stack Menggunakan Array:
- Koding Bahasa C:
#include <stdio.h>
#define MAX_SIZE 100
// Struktur Stack
struct Stack {
int data[MAX_SIZE];
int top;
};
// Fungsi push: Menambahkan elemen ke dalam stack
void push(struct Stack *stack, int element) {
if (stack->top == MAX_SIZE - 1) {
printf("Stack overflow, tidak dapat menambahkan elemen\n");
} else {
stack->top++;
stack->data[stack->top] = element;
printf("Elemen %d ditambahkan ke dalam stack\n", element);
}
}
// Fungsi pop: Menghapus elemen teratas dari stack
void pop(struct Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow, tidak ada elemen yang dapat dihapus\n");
} else {
int element = stack->data[stack->top];
stack->top--;
printf("Elemen %d dihapus dari stack\n", element);
}
}
// Fungsi peek: Mengambil nilai elemen teratas dari stack tanpa menghapusnya
int peek(struct Stack stack) {
if (stack.top == -1) {
printf("Stack kosong\n");
return -1;
} else {
return stack.data[stack.top];
}
}
// Fungsi isEmpty: Memeriksa apakah stack kosong
int isEmpty(struct Stack stack) {
if (stack.top == -1) {
return 1; // True, stack kosomg
} else {
return 0; // False, stack tidak kosong
}
}
// Fungsi isFull: Memeriksa apakah stack penuh
int isFull(struct Stack stack) {
if (stack.top == MAX_SIZE -1) {
return -1; // True, stack penuh
} else {
return 0; // False, stack tidak penuh
}
}
int main() {
struct Stack stack;
stack.top = -1;
push(&stack, 10);
push(&stack, 20);
push(&stack, 30);
printf("Elemen teratas stack: %d\n", peek(stack));
pop(&stack);
printf("Elemen teratas stack setelah pop: %d\n", peek(stack));
printf("Apakah stack kosong? %s\n", isEmpty(stack) ? "Ya" : "Tidak");
printf("Apakah stack penuh? %s\n", isFull(stack) ? "Ya" : "Tidak");
return 0;
}
- Hasil Koding:
2. Input String:
- Koding Bahasa C:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
// Struktur Stack
struct Stack {
char data[MAX_SIZE];
int top;
};
// Fungsi push: Menambahkan elemen ke dalam stack
void push(struct Stack *stack, char element) {
if (stack->top == MAX_SIZE - 1) {
printf("Stack overflow, tidak dapat menambahkan elemen\n");
} else {
stack->top++;
stack->data[stack->top] = element;
}
}
// Fungsi pop: Menghapus elemen teratas dari stack
void pop(struct Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow, tidak ada elemen yang dapat dihapus\n");
} else {
stack->top--;
}
}
// Fungsi peek: Mengambil nilai elemen teratas dari stack tanpa menghapusnya
char peek(struct Stack stack) {
if (stack.top == -1) {
return '\0';
} else {
return stack.data[stack.top];
}
}
// Fungsi isEmpty: Memeriksa apkah stack kosong
int isEmpty(struct Stack stack) {
if (stack.top == -1) {
return 1; // True, stack kosong
} else {
return 0; // False, stack tidak kosong
}
}
// Fungsi isBalanced: Memeriksa keseimbangan tanda kurung dalam string
int isBalanced(char string[]) {
struct Stack stack;
stack.top = -1;
int i;
for (i = 0; i < strlen(string); i++) {
if (string[i] == '(' || string[i] == '[' || string[i] == '{') {
push(&stack, string[i]);
} else if (string[i] == ')' || string[i] == ']' || string[i] == '}') {
if (isEmpty(stack)) {
return 0; // Kurung tidak seimbang
} else if ((string[i] == ')' && peek(stack) == '(') ||
(string[i] == ']' && peek(stack) == '[') ||
(string[i] == '}' && peek(stack) == '{')) {
pop(&stack);
} else {
return 0; // Kurung tidak seimbang
}
}
}
if (isEmpty(stack)) {
return 1; // Kurung seimbang
} else {
return 0; // Kurung tidak seimbang
}
}
int main() {
char string[MAX_SIZE];
printf("Masukkan string: ");
fgets(string, sizeof(string), stdin);
// Menghapus karakter newline pada akhir string
if (string[strlen(string) - 1] == '\n') {
string[strlen(string) - 1] = '\0';
}
if (isBalanced(string)) {
printf("Keseimbangan Tanda Kurung Benar\n");
} else {
printf("Keseimbangan Tanda Kurung Salah\n");
}
return 0;
}
- Hasil Koding:
3. Membalikkan Urutan Kata Dalam Kalimat:
- Koding Bahasa C:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
// Struktur Stack
struct Stack {
char data[MAX_SIZE];
int top;
};
// Fungsi push: Menambahkan elemen ke dalam stack
void push(struct Stack *stack, char element) {
if (stack->top == MAX_SIZE - 1) {
printf("Stack overflow, tidak dapat menambahkan elemen\n");
} else {
stack->top++;
stack->data[stack->top] = element;
}
}
// Fungsi pop: Menghapus elemen teratas dari stack
void pop(struct Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow, tidak ada elemen yang dapat dihapus\n");
} else {
stack->top--;
}
}
// Fungsi peek: Mengambil nilai teratas dari stack tanpa menghapusnya
char peek(struct Stack stack) {
if (stack.top == -1) {
return '\0';
} else {
return stack.data[stack.top];
}
}
// Fungsi isEmpty: Memeriksa apakah stack kosong
int isEmpty(struct Stack stack) {
return stack.top == -1;
}
// Fungsi reverseWord: Membalikkan urutan kata dalam kalimat menggunakan stack
void reverseWord(char sentence[]) {
struct Stack stack;
stack.top = -1;
// Memasukkan setiap kata ke dalam stack
char *word = strtok(sentence, " ");
while (word != NULL) {
int i;
for (i = 0; i < strlen(word); i++) {
push(&stack, word[i]);
}
push(&stack, ' '); // Menyisipkan spasi antara kata
word = strtok(NULL, " ");
}
// Membaca kata dari stack dan mencetaknya
while (!isEmpty(stack)) {
char ch = peek(stack);
pop(&stack);
printf("%c", ch);
}
}
int main() {
char sentence[MAX_SIZE];
printf("Masukkan kalimat: ");
fgets(sentence, sizeof(sentence), stdin);
// Menghapus karakter newline pada akhir kalimat
if (sentence[strlen(sentence) - 1] == '\n') {
sentence[strlen(sentence) - 1] = '\0';
}
printf("Kalimat terbalik: ");
reverseWord(sentence);
printf("\n");
return 0;
}
- Hasil Koding:
4. Mengubah Notasi Infix:
- Koding Bahasa C:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
// Struktur Stack
struct Stack {
char data[MAX_SIZE];
int top;
};
// Fungsi push: Menambahkan elemen ke dalam stack
void push(struct Stack *stack, char element) {
if (stack->top == MAX_SIZE - 1) {
printf("Stack overflow, tidak dapat menambahkan elemen\n");
} else {
stack->top++;
stack->data[stack->top] = element;
}
}
// Fungsi pop: Menghapus elemen teratas dari stack
void pop(struct Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow, tisak ada elemen yang dapat dihapus\n");
} else {
stack->top--;
}
}
// Fungsi peek: Mengambil nilai elemen teratas dari stack tanpa menghapusnya
char peek(struct Stack stack) {
if (stack.top == -1) {
return '\0';
} else {
return stack.data[stack.top];
}
}
// Fungsi isEmpty: Memeriksa apakah stack kosong
int isEmpty(struct Stack stack) {
return stack.top == -1;
}
// Fungsi isOperator: Memeriksa apakah karakter merupakan operator
int isOperator(char ch) {
return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}
// Fungsi precedence: Mengembalikan prioritas operator
int precedence(char ch) {
if (ch == '+' || ch == '-')
return 1;
else if (ch == '*' || ch == '/')
return 2;
return 0;
}
// Fungsi infixToPostFix: Mengubah notasi infix menjadi notasi postfix
void infixToPostFix(char infix[], char postfix[]) {
struct Stack stack;
stack.top = -1;
int i, j;
for (i = 0, j = 0; i < strlen(infix); i++) {
char ch = infix[i];
if (ch == ' ')
continue;
if (isdigit(ch) || isalpha(ch)) {
postfix[j++] = ch;
} else if (isOperator(ch)) {
while (!isEmpty(stack) && precedence(peek(stack)) >= precedence(ch)) {
postfix[j++] = peek(stack);
pop(&stack);
}
push(&stack, ch);
} else if (ch == '(') {
push(&stack, ch);
} else if (ch == ')') {
while (!isEmpty(stack) && peek(stack) != '(') {
postfix[j++] = peek(stack);
pop(&stack);
}
pop(&stack);
}
}
while (!isEmpty(stack)) {
postfix[j++] = peek(stack);
pop(&stack);
}
postfix[j] = '\0';
}
int main() {
char infix[MAX_SIZE];
char postfix[MAX_SIZE];
printf("Masukkan ekspresi infix: ");
fgets(infix, sizeof(infix), stdin);
// Menghapus karakter newline pada akhir ekspresi infix
if (infix[strlen(infix) - 1] == '\n'){
infix[strlen(infix) - 1] = '\0';
}
infixToPostFix(infix, postfix);
printf("Ekspresi postfix: %s\n", postfix);
return 0;
}
- Hasil Koding:
5. Menghitung Hasil Ekspresi Infix:
- Koding Bahasa C:
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define MAX_SIZE 100
// Struktur Stack
struct Stack {
int data[MAX_SIZE];
int top;
};
// Fungsi push: Menambahkan elemen ke dalam stack
void push(struct Stack *stack, int element) {
if (stack->top == MAX_SIZE - 1) {
printf("Stack overflow, tidak dapat menambahkan elemen\n");
} else {
stack->top++;
stack->data[stack->top] = element;
}
}
// Fungsi pop: Menghapus elemen teratas dari stack
void pop(struct Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow, tidak ada elemen yang dapat dihapus\n");
} else {
stack->top--;
}
}
// Fungsi peek: Mengambil nilai elemen teratas dari stack tanpa menghapusnya
int peek(struct Stack stack) {
if (stack.top == -1) {
return 0;
} else {
return stack.data[stack.top];
}
}
// Fungsi isEmpty: Memeriksa apakah stack kosong
int isEmpty(struct Stack stack) {
return stack.top == -1;
}
// Fungsi evaluatePostFix: Menghitung hasil dari ekspresi postfix
int evaluatePostFix(char postfix[]) {
struct Stack stack;
stack.top = -1;
int i;
for (i = 0; i < strlen(postfix); i++) {
char ch = postfix[i];
if (isdigit(ch)) {
push(&stack, ch - '0');
} else {
int operand2 = peek(stack);
pop(&stack);
int operand1 = peek(stack);
pop(&stack);
switch (ch) {
case '+':
push(&stack, operand1 + operand2);
break;
case '-':
push(&stack, operand1 - operand2);
break;
case '*':
push(&stack, operand1 * operand2);
break;
case '/':
push(&stack, operand1 / operand2);
break;
}
}
}
return peek(stack);
}
int main() {
char postfix[MAX_SIZE];
printf("Masukkan ekspresi postfix: ");
fgets(postfix, sizeof(postfix), stdin);
// Menghapus karakter newline pada akhir ekspresi postfix
if (postfix[strlen(postfix) - 1] == '\n') {
postfix[strlen(postfix) - 1] = '\0';
}
int result = evaluatePostFix(postfix);
printf("Hasil perhitungan: %d\n", result);
return 0;
}
- Hasil Koding:
Praktikum 9 (Implementasi Struktur Data Queue)
A. Persoalan
1. Queue Menyimpan Angka Bulat:
Implementasikan sebuah program yang menggunakan queue untuk menyimpan angka-angka bulat. Program tersebut harus memiliki fitur berikut:
-Enqueue: Menambahkan angka ke dalam queue.
-Dequeue: Menghapus angka teratas dari queue.
-Display: Menampilkan seluruh angka dalam queue.
2. Queue Antrian Pelanggan Toko:
Buatlah program yang menggunakan queue untuk menerapkan antrian pelanggan di suatu toko. Program tersebut harus memiliki fitur berikut:
-Enqueue: Menambahkan data pelanggan (nama dan nomor antrian) ke dalam queue.
-Dequeue: Menghapus data pelanggan teratas dari queue setelah selesai dilayani.
-Display: Menampilkan seluruh data pelanggan dalam queue.
3. Queue Simulasi Proses Penjadwalan CPU:
Implementasikan program yang menggunakan queue untuk mensimulasikan proses penjadwalan CPU. Program tersebut harus memiliki fitur berikut:
-Enqueue: Menambahkan proses (dalam bentuk nama atau ID) ke dalam queue.
-Dequeue: Menghapus proses teratas dari queue setelah selesai dieksekusi.
-Display: Menampilkan seluruh proses dalam queue.
4. Queue Algoritma Breadth-First Search (BFS) Pada Graf:
Buatlah program yang menggunakan queue untuk mengimplementasikan algoritma Breadth-First Search (BFS) pada graf. Program tersebut harus memiliki fitur berikut:
-Enqueue: Menambahkan simpul (dalam bentuk nama atau ID) ke dalam queue.
-Dequeue: Menghapus simpul teratas dari queue setelah dikunjungi.
-Display: Menampilkan seluruh simpul yang ada dalam queue.
-Enqueue: Menambahkan simpul (dalam bentuk nama atau ID) ke dalam queue.
-Dequeue: Menghapus simpul teratas dari queue setelah dikunjungi.
-Display: Menampilkan seluruh simpul yang ada dalam queue.
5. Queue Menyimpan KAta-kata Dlaam Sebuah Kalimat:
Implementasikan sebuah program yang menggunakan queue untuk menyimpan kata-kata dalam sebuah kalimat. Program tersebut harus memiliki fitur berikut:
-Enqueue: Menambahkan kata ke dalam queue.
-Dequeue: Menghapus kata teratas dari queue.
-Display: Menampilkan seluruh kata dalam queue.
-Enqueue: Menambahkan kata ke dalam queue.
-Dequeue: Menghapus kata teratas dari queue.
-Display: Menampilkan seluruh kata dalam queue.
B. Penyelesaian
1. Queue Menyimpan Angka Bulat:
- Koding Bahasa C:
#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int front;int rear;} Queue;void initializeQueue(Queue *q) {q->front = -1;q->rear = -1;}int isFull(Queue *q) {return (q->rear == MAX_SIZE - 1);}int isEmpty(Queue *q) {return (q->front == -1 || q->front > q->rear);}void enqueue(Queue *q, int item) {if (isFull(q)) {printf("Queue penuh, tidak bisa menambahkan elemen.\n");} else {if (q->front == -1) {q->front = 0;}q->rear++;q->data[q->rear] = item;printf("Angka %d ditambahkan ke dalam queue.\n", item);}}void dequeue(Queue *q) {if (isEmpty(q)) {printf("Queue kosong, tidak ada elemen yang dihapus.\n");} else {int item = q->data[q->front];q->front++;printf("Angka %d dihapus dari queue.\n", item);}}void displayQueue(Queue *q) {if (isEmpty(q)) {printf("Queue kosong.\n");} else {printf("Isi Queue: ");for (int i = q->front; i <= q->rear; i++) {printf("%d", q->data[i]);}printf("\n");}}int main() {Queue q;initializeQueue(&q);enqueue(&q, 10);enqueue(&q, 20);enqueue(&q, 30);enqueue(&q, 40);displayQueue(&q);dequeue(&q);dequeue(&q);displayQueue(&q);return 0;}
- Hasil:
2. Queue Antrian Pelanggan Toko:
- Koding Bahasa C:
#include <stdio.h>#include <stdlib.h>
#define MAX_SIZE 100
typedef struct { char nama[50]; int nomorAntrian;} Pelanggan;
typedef struct { Pelanggan data[MAX_SIZE]; int front; int rear;} Queue;
void initializeQueue(Queue *q) { q->front = -1; q->rear = -1;}
int isFull(Queue *q) { return (q->rear == MAX_SIZE - 1);}
int isEmpty(Queue *q) { return (q->front == -1 || q->front > q->rear);}
void enqueue(Queue *q, Pelanggan pelanggan) { if (isFull(q)) { printf("Antrian penuh, tidak bisa menambahkan pelanggan.\n"); } else { if (q->front == -1) { q->front =0; } q->rear++; q->data[q->rear] = pelanggan; printf("Pelanggan %s dengan nomor antrian %d ditambahkan ke dalam antrian.\n", pelanggan.nama, pelanggan.nomorAntrian); }}
void dequeue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong, tidak ada pelanggan yang dilayani.\n"); } else { Pelanggan pelanggan = q->data[q->front]; q->front++; printf("Pelanggan %s dengan nomor antrian %d telah dilayani dan dikeluarkan dari antrian.\n", pelanggan.nama, pelanggan.nomorAntrian); }}
void displayQueue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong.\n"); } else { printf("Data Pelanggan dalam Antrian.\n"); for (int i = q->front; i <= q->rear; i++) { Pelanggan pelanggan = q->data[i]; printf("Pelanggan %s dengan nomor antrian %d\n", pelanggan.nama, pelanggan.nomorAntrian); } }}
int main() { Queue q; initializeQueue(&q);
Pelanggan pelanggan1 = {"Budi Sudarsono", 1}; Pelanggan pelanggan2 = {"Egy Maulana", 2}; Pelanggan pelanggan3 = {"Andika Suroso", 3};
enqueue(&q, pelanggan1); enqueue(&q, pelanggan2); enqueue(&q, pelanggan3);
displayQueue(&q);
dequeue(&q); dequeue(&q);
displayQueue(&q);
return 0;}
- Hasil:
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
typedef struct {
char nama[50];
int nomorAntrian;
} Pelanggan;
typedef struct {
Pelanggan data[MAX_SIZE];
int front;
int rear;
} Queue;
void initializeQueue(Queue *q) {
q->front = -1;
q->rear = -1;
}
int isFull(Queue *q) {
return (q->rear == MAX_SIZE - 1);
}
int isEmpty(Queue *q) {
return (q->front == -1 || q->front > q->rear);
}
void enqueue(Queue *q, Pelanggan pelanggan) {
if (isFull(q)) {
printf("Antrian penuh, tidak bisa menambahkan pelanggan.\n");
} else {
if (q->front == -1) {
q->front =0;
}
q->rear++;
q->data[q->rear] = pelanggan;
printf("Pelanggan %s dengan nomor antrian %d ditambahkan ke dalam antrian.\n", pelanggan.nama, pelanggan.nomorAntrian);
}
}
void dequeue(Queue *q) {
if (isEmpty(q)) {
printf("Antrian kosong, tidak ada pelanggan yang dilayani.\n");
} else {
Pelanggan pelanggan = q->data[q->front];
q->front++;
printf("Pelanggan %s dengan nomor antrian %d telah dilayani dan dikeluarkan dari antrian.\n", pelanggan.nama, pelanggan.nomorAntrian);
}
}
void displayQueue(Queue *q) {
if (isEmpty(q)) {
printf("Antrian kosong.\n");
} else {
printf("Data Pelanggan dalam Antrian.\n");
for (int i = q->front; i <= q->rear; i++) {
Pelanggan pelanggan = q->data[i];
printf("Pelanggan %s dengan nomor antrian %d\n", pelanggan.nama, pelanggan.nomorAntrian);
}
}
}
int main() {
Queue q;
initializeQueue(&q);
Pelanggan pelanggan1 = {"Budi Sudarsono", 1};
Pelanggan pelanggan2 = {"Egy Maulana", 2};
Pelanggan pelanggan3 = {"Andika Suroso", 3};
enqueue(&q, pelanggan1);
enqueue(&q, pelanggan2);
enqueue(&q, pelanggan3);
displayQueue(&q);
dequeue(&q);
dequeue(&q);
displayQueue(&q);
return 0;
}
3. Queue Simulasi Proses Penjadwalan CPU:
- Koding Bahasa C:
#include <stdio.h>#include <stdlib.h>
#define MAX_SIZE 100
typedef struct { char nama[50];} Proses;
typedef struct { Proses data[MAX_SIZE]; int front; int rear;} Queue;
void initializeQueue(Queue *q) { q->front = -1; q->rear = -1;}
int isFull(Queue *q) { return (q->rear == MAX_SIZE - 1);}
int isEmpty(Queue *q) { return (q->front == -1 || q->front > q->rear);}
void enqueue(Queue *q, Proses proses) { if (isFull(q)) { printf("Antrian penuh, tidak bisa menambahkan proses.\n"); } else { if (q->front == -1) { q->front = 0; } q->rear++; q->data[q->rear] = proses; printf("Proses %s ditambahkan ke dalam antrian.\n", proses.nama); }}
void dequeue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong, tidak ada proses yang dieksekusi.\n"); } else { Proses proses = q->data[q->front]; q->front++; printf("Proses %s telah dieksekusi dan dikeluarkan dari antrian.\n", proses.nama); }}
void displayQueue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong.\n"); } else { printf("Data Proses dalam Antrian:\n"); for (int i = q->front; i <= q->rear; i++) { Proses proses = q->data[i]; printf("Proses %s\n", proses.nama); } }}
int main () { Queue q; initializeQueue(&q);
Proses proses1 = {"Proses A"}; Proses proses2 = {"Proses B"}; Proses proses3 = {"Proses C"};
enqueue(&q, proses1); enqueue(&q, proses2); enqueue(&q, proses3);
displayQueue(&q);
dequeue(&q); dequeue(&q);
displayQueue(&q);
return 0;}
- Hasil:
- Koding Bahasa C:#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {char nama[50];} Proses;typedef struct {Proses data[MAX_SIZE];int front;int rear;} Queue;void initializeQueue(Queue *q) {q->front = -1;q->rear = -1;}int isFull(Queue *q) {return (q->rear == MAX_SIZE - 1);}int isEmpty(Queue *q) {return (q->front == -1 || q->front > q->rear);}void enqueue(Queue *q, Proses proses) {if (isFull(q)) {printf("Antrian penuh, tidak bisa menambahkan proses.\n");} else {if (q->front == -1) {q->front = 0;}q->rear++;q->data[q->rear] = proses;printf("Proses %s ditambahkan ke dalam antrian.\n", proses.nama);}}void dequeue(Queue *q) {if (isEmpty(q)) {printf("Antrian kosong, tidak ada proses yang dieksekusi.\n");} else {Proses proses = q->data[q->front];q->front++;printf("Proses %s telah dieksekusi dan dikeluarkan dari antrian.\n", proses.nama);}}void displayQueue(Queue *q) {if (isEmpty(q)) {printf("Antrian kosong.\n");} else {printf("Data Proses dalam Antrian:\n");for (int i = q->front; i <= q->rear; i++) {Proses proses = q->data[i];printf("Proses %s\n", proses.nama);}}}int main () {Queue q;initializeQueue(&q);Proses proses1 = {"Proses A"};Proses proses2 = {"Proses B"};Proses proses3 = {"Proses C"};enqueue(&q, proses1);enqueue(&q, proses2);enqueue(&q, proses3);displayQueue(&q);dequeue(&q);dequeue(&q);displayQueue(&q);return 0;}
- Hasil:
4. Queue Algoritma Breadth-First Search (BFS) Pada Graf:
- Koding Bahasa C:
#include <stdio.h>#include <stdlib.h>
#define MAX_SIZE 100
typedef struct { int data;} Simpul;
typedef struct { Simpul data[MAX_SIZE]; int front; int rear;} Queue;
void initializeQueue(Queue *q) { q->front = -1; q->rear = -1;}
int isFull(Queue *q) { return (q->rear == MAX_SIZE - 1);}
int isEmpty(Queue *q) { return (q->front == -1 || q->front > q->rear);}
void enqueue(Queue *q, Simpul simpul) { if (isFull(q)) { printf("Antrian penuh, tidak bisa menambahkan simpul.\n"); } else { if (q->front == -1) { q->front = 0; } q->rear++; q->data[q->rear] = simpul; printf("Simpul %d ditambahkan ke dalam antrian.\n", simpul.data); }}
void dequeue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong, tidak ada simpul yang dikunjungi.\n"); } else { Simpul simpul = q->data[q->front]; q->front++; printf("Simpul %d telah dikunjungi dan dikeluarkan dari antrian.\n", simpul.data); }}
void displayQueue(Queue *q) { if (isEmpty(q)) { printf("Antrian kosong.\n"); } else { printf("Data Simpul dalam Antrian:\n"); for (int i = q->front; i <= q->rear; i++) { Simpul simpul = q->data[i]; printf("Simpul %d\n", simpul.data); } }}
void bfs(int graf[] [5], int start, int jumlah_simpul) { Queue q; initializeQueue(&q);
int visited[MAX_SIZE] = {0};
Simpul simpul; simpul.data = start; enqueue(&q, simpul); visited[start] = 1;
printf("Urutan kunjungan simpul BFS: %d", start);
while (!isEmpty(&q)) { Simpul current = q.data[q.front]; dequeue(&q);
for (int i = 0; i < jumlah_simpul; i++) { if (graf[current.data][i] == 1 && visited[i] == 0) { Simpul next; next.data = i; enqueue(&q, next); visited[i] = 1; printf("%d", next.data); } } } printf("\n");}
int main() { int graf[5][5] = {{0, 1, 0, 1, 0}, {1, 0, 1, 0, 1}, {0, 1, 0, 1, 0}, {1, 0, 1, 0, 1}, {0, 1, 0, 1, 0}};
int start_simpul =0; int jumlah_simpul = 5;
bfs(graf, start_simpul, jumlah_simpul);
return 0;}
- Hasil:
- Koding Bahasa C:#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data;} Simpul;typedef struct {Simpul data[MAX_SIZE];int front;int rear;} Queue;void initializeQueue(Queue *q) {q->front = -1;q->rear = -1;}int isFull(Queue *q) {return (q->rear == MAX_SIZE - 1);}int isEmpty(Queue *q) {return (q->front == -1 || q->front > q->rear);}void enqueue(Queue *q, Simpul simpul) {if (isFull(q)) {printf("Antrian penuh, tidak bisa menambahkan simpul.\n");} else {if (q->front == -1) {q->front = 0;}q->rear++;q->data[q->rear] = simpul;printf("Simpul %d ditambahkan ke dalam antrian.\n", simpul.data);}}void dequeue(Queue *q) {if (isEmpty(q)) {printf("Antrian kosong, tidak ada simpul yang dikunjungi.\n");} else {Simpul simpul = q->data[q->front];q->front++;printf("Simpul %d telah dikunjungi dan dikeluarkan dari antrian.\n", simpul.data);}}void displayQueue(Queue *q) {if (isEmpty(q)) {printf("Antrian kosong.\n");} else {printf("Data Simpul dalam Antrian:\n");for (int i = q->front; i <= q->rear; i++) {Simpul simpul = q->data[i];printf("Simpul %d\n", simpul.data);}}}void bfs(int graf[] [5], int start, int jumlah_simpul) {Queue q;initializeQueue(&q);int visited[MAX_SIZE] = {0};Simpul simpul;simpul.data = start;enqueue(&q, simpul);visited[start] = 1;printf("Urutan kunjungan simpul BFS: %d", start);while (!isEmpty(&q)) {Simpul current = q.data[q.front];dequeue(&q);for (int i = 0; i < jumlah_simpul; i++) {if (graf[current.data][i] == 1 && visited[i] == 0) {Simpul next;next.data = i;enqueue(&q, next);visited[i] = 1;printf("%d", next.data);}}}printf("\n");}int main() {int graf[5][5] = {{0, 1, 0, 1, 0},{1, 0, 1, 0, 1},{0, 1, 0, 1, 0},{1, 0, 1, 0, 1},{0, 1, 0, 1, 0}};int start_simpul =0;int jumlah_simpul = 5;bfs(graf, start_simpul, jumlah_simpul);return 0;}
- Hasil:
5. Queue Menyimpan Kata-kata Dalam Sebuah Kalimat:
- Koding Bahasa C:
#include <stdio.h>#include <stdlib.h>#include <string.h>
#define MAX_SIZE 100
typedef struct Node { char data[50]; struct Node* next;} Node;
typedef struct { Node* front; Node* rear;} Queue;
void initializeQueue(Queue* q) { q->front = q->rear = NULL;}
void enqueue(Queue* q, const char* word) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode == NULL) { printf("Memory allocation failed.\n"); exit(EXIT_FAILURE); }
strcpy(newNode->data, word); newNode->next = NULL;
if (q->rear == NULL) { q->front = q->rear = newNode; } else { q->rear->next = newNode; q->rear = newNode; }
printf("Enqueued: %s\n", word);}
void dequeue(Queue* q) { if (q->front == NULL) { printf("Queue is empty.\n"); return; }
Node* temp = q->front; q->front = q->front->next;
if (q->front == NULL) { q->rear = NULL; }
printf("Dequeued: %s\n", temp->data); free(temp);}
void displayQueue(Queue* q) { if (q->front == NULL) { printf("Queue is empty.\n"); return; }
printf("Queue elements: "); Node* current = q->front; while (current != NULL) { printf("%s ", current->data); current = current->next; } printf("\n");}
int main() { Queue myQueue; initializeQueue(&myQueue);
enqueue(&myQueue, "Abudzar"); enqueue(&myQueue, "Mohammad"); enqueue(&myQueue, "Al-Farizi"); displayQueue(&myQueue);
dequeue(&myQueue); displayQueue(&myQueue);
return 0;}
- Hasil:
- Koding Bahasa C:#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX_SIZE 100typedef struct Node {char data[50];struct Node* next;} Node;typedef struct {Node* front;Node* rear;} Queue;void initializeQueue(Queue* q) {q->front = q->rear = NULL;}void enqueue(Queue* q, const char* word) {Node* newNode = (Node*)malloc(sizeof(Node));if (newNode == NULL) {printf("Memory allocation failed.\n");exit(EXIT_FAILURE);}strcpy(newNode->data, word);newNode->next = NULL;if (q->rear == NULL) {q->front = q->rear = newNode;} else {q->rear->next = newNode;q->rear = newNode;}printf("Enqueued: %s\n", word);}void dequeue(Queue* q) {if (q->front == NULL) {printf("Queue is empty.\n");return;}Node* temp = q->front;q->front = q->front->next;if (q->front == NULL) {q->rear = NULL;}printf("Dequeued: %s\n", temp->data);free(temp);}void displayQueue(Queue* q) {if (q->front == NULL) {printf("Queue is empty.\n");return;}printf("Queue elements: ");Node* current = q->front;while (current != NULL) {printf("%s ", current->data);current = current->next;}printf("\n");}int main() {Queue myQueue;initializeQueue(&myQueue);enqueue(&myQueue, "Abudzar");enqueue(&myQueue, "Mohammad");enqueue(&myQueue, "Al-Farizi");displayQueue(&myQueue);dequeue(&myQueue);displayQueue(&myQueue);return 0;}
- Hasil:
Tidak ada komentar:
Posting Komentar