Struktur Data Queue

 Dalam pengembangan perangkat lunak, sering kali kita perlu mengelola kumpulan data dengan
urutan tertentu. Salah satu struktur data yang digunakan untuk tujuan ini adalah queue. Queue
adalah struktur data linier yang bekerja berdasarkan prinsip FIFO (First-In-First-Out), artinya
elemen yang pertama kali masuk ke dalam queue akan menjadi elemen pertama yang keluar dari
queue.

berikut contoh program struktur data queue

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

#define MAX_SIZE 100

// Struktur untuk merepresentasikan queue
struct Queue {
    int array[MAX_SIZE];
    int front, rear;
};

// Fungsi untuk menginisialisasi queue
void initialize(struct Queue *queue) {
    queue->front = -1;
    queue->rear = -1;
}

// Fungsi untuk mengecek apakah queue kosong (isEmpty)
int isEmpty(struct Queue *queue) {
    return (queue->front == -1 && queue->rear == -1);
}

// Fungsi untuk mengecek apakah queue penuh (isFull)
int isFull(struct Queue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// Fungsi untuk menambahkan angka ke dalam queue (enqueue)
void enqueue(struct Queue *queue, int value) {
    if (isFull(queue)) {
        printf("Queue penuh. Enqueue tidak bisa dilakukan.\n");
    } else {
        if (isEmpty(queue)) {
            queue->front = 0;
        }
        queue->rear = (queue->rear + 1) % MAX_SIZE;
        queue->array[queue->rear] = value;
        printf("%d ditambahkan ke dalam queue.\n", value);
    }
}

// Fungsi untuk menghapus angka teratas dari queue (dequeue)
void dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong. Dequeue tidak bisa dilakukan.\n");
    } else {
        int removedValue = queue->array[queue->front];
        printf("%d dihapus dari queue.\n", removedValue);

        if (queue->front == queue->rear) {
            // Hanya satu elemen dalam queue
            initialize(queue);
        } else {
            queue->front = (queue->front + 1) % MAX_SIZE;
        }
    }
}

// Fungsi untuk menampilkan seluruh angka dalam queue (display)
void display(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong.\n");
    } else {
        printf("Isi queue: ");
        int i = queue->front;
        do {
            printf("%d ", queue->array[i]);
            i = (i + 1) % MAX_SIZE;
        } while (i != (queue->rear + 1) % MAX_SIZE);
        printf("\n");
    }
}

int main() {
    struct Queue queue;
    initialize(&queue);

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    display(&queue);

    dequeue(&queue);
    dequeue(&queue);

    display(&queue);

    enqueue(&queue, 4);
    enqueue(&queue, 5);

    display(&queue);

    return 0;
}
output :



Program ini menggunakan array untuk merepresentasikan queue dan menyediakan fungsi-fungsi enqueue, dequeue, dan display. Anda dapat menambahkan operasi atau memodifikasi program sesuai dengan kebutuhan.
 
 
2.
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 100

// Struktur untuk merepresentasikan pelanggan
struct Customer {
    char name[50];
    int queueNumber;
};

// Struktur untuk merepresentasikan queue pelanggan
struct Queue {
    struct Customer array[MAX_SIZE];
    int front, rear;
};

// Fungsi untuk menginisialisasi queue
void initialize(struct Queue *queue) {
    queue->front = -1;
    queue->rear = -1;
}

// Fungsi untuk mengecek apakah queue kosong (isEmpty)
int isEmpty(struct Queue *queue) {
    return (queue->front == -1 && queue->rear == -1);
}

// Fungsi untuk mengecek apakah queue penuh (isFull)
int isFull(struct Queue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// Fungsi untuk menambahkan data pelanggan ke dalam queue (enqueue)
void enqueue(struct Queue *queue, const char *name, int queueNumber) {
    if (isFull(queue)) {
        printf("Queue penuh. Enqueue tidak bisa dilakukan.\n");
    } else {
        if (isEmpty(queue)) {
            queue->front = 0;
        }

        queue->rear = (queue->rear + 1) % MAX_SIZE;
        strcpy(queue->array[queue->rear].name, name);
        queue->array[queue->rear].queueNumber = queueNumber;

        printf("%s dengan nomor antrian %d ditambahkan ke dalam queue.\n", name, queueNumber);
    }
}

// Fungsi untuk menghapus data pelanggan teratas dari queue (dequeue)
void dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong. Dequeue tidak bisa dilakukan.\n");
    } else {
        struct Customer removedCustomer = queue->array[queue->front];
        printf("%s dengan nomor antrian %d telah dilayani dan dihapus dari queue.\n",
               removedCustomer.name, removedCustomer.queueNumber);

        if (queue->front == queue->rear) {
            // Hanya satu pelanggan dalam queue
            initialize(queue);
        } else {
            queue->front = (queue->front + 1) % MAX_SIZE;
        }
    }
}

// Fungsi untuk menampilkan seluruh data pelanggan dalam queue (display)
void display(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong.\n");
    } else {
        printf("Antrian pelanggan:\n");
        int i = queue->front;
        do {
            printf("Nomor Antrian: %d, Nama: %s\n", queue->array[i].queueNumber, queue->array[i].name);
            i = (i + 1) % MAX_SIZE;
        } while (i != (queue->rear + 1) % MAX_SIZE);
    }
}

int main() {
    struct Queue customerQueue;
    initialize(&customerQueue);

    enqueue(&customerQueue, "John", 1);
    enqueue(&customerQueue, "Alice", 2);
    enqueue(&customerQueue, "Bob", 3);

    display(&customerQueue);

    dequeue(&customerQueue);
    dequeue(&customerQueue);

    display(&customerQueue);

    enqueue(&customerQueue, "Charlie", 4);
    enqueue(&customerQueue, "David", 5);

    display(&customerQueue);

    return 0;
}
output :

Program ini menggunakan array untuk merepresentasikan queue pelanggan dengan data berupa nama dan nomor antrian. Anda dapat menambahkan operasi atau memodifikasi program sesuai dengan kebutuhan.



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

#define MAX_SIZE 100

// Struktur untuk merepresentasikan proses
struct Process {
    char name[50];
};

// Struktur untuk merepresentasikan queue proses
struct Queue {
    struct Process array[MAX_SIZE];
    int front, rear;
};

// Fungsi untuk menginisialisasi queue
void initialize(struct Queue *queue) {
    queue->front = -1;
    queue->rear = -1;
}

// Fungsi untuk mengecek apakah queue kosong (isEmpty)
int isEmpty(struct Queue *queue) {
    return (queue->front == -1 && queue->rear == -1);
}

// Fungsi untuk mengecek apakah queue penuh (isFull)
int isFull(struct Queue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// Fungsi untuk menambahkan proses ke dalam queue (enqueue)
void enqueue(struct Queue *queue, const char *name) {
    if (isFull(queue)) {
        printf("Queue penuh. Enqueue tidak bisa dilakukan.\n");
    } else {
        if (isEmpty(queue)) {
            queue->front = 0;
        }

        queue->rear = (queue->rear + 1) % MAX_SIZE;
        strcpy(queue->array[queue->rear].name, name);

        printf("Proses %s ditambahkan ke dalam queue.\n", name);
    }
}

// Fungsi untuk menghapus proses teratas dari queue (dequeue)
void dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong. Dequeue tidak bisa dilakukan.\n");
    } else {
        struct Process removedProcess = queue->array[queue->front];
        printf("Proses %s telah dieksekusi dan dihapus dari queue.\n", removedProcess.name);

        if (queue->front == queue->rear) {
            // Hanya satu proses dalam queue
            initialize(queue);
        } else {
            queue->front = (queue->front + 1) % MAX_SIZE;
        }
    }
}

// Fungsi untuk menampilkan seluruh proses dalam queue (display)
void display(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong.\n");
    } else {
        printf("Antrian proses:\n");
        int i = queue->front;
        do {
            printf("Proses: %s\n", queue->array[i].name);
            i = (i + 1) % MAX_SIZE;
        } while (i != (queue->rear + 1) % MAX_SIZE);
    }
}

int main() {
    struct Queue processQueue;
    initialize(&processQueue);

    enqueue(&processQueue, "Process1");
    enqueue(&processQueue, "Process2");
    enqueue(&processQueue, "Process3");

    display(&processQueue);

    dequeue(&processQueue);
    dequeue(&processQueue);

    display(&processQueue);

    enqueue(&processQueue, "Process4");
    enqueue(&processQueue, "Process5");

    display(&processQueue);

    return 0;
}
output :


Program ini menggunakan array untuk merepresentasikan queue proses dengan data berupa nama proses. Anda dapat menambahkan operasi atau memodifikasi program sesuai dengan kebutuhan.



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

#define MAX_SIZE 100

// Struktur untuk merepresentasikan simpul dalam graf
struct Node {
    int data;
    struct Node* next;
};

// Struktur untuk merepresentasikan graf
struct Graph {
    int numVertices;
    struct Node** adjacencyList;
};

// Struktur untuk merepresentasikan queue
struct Queue {
    int array[MAX_SIZE];
    int front, rear;
};

// Fungsi untuk menginisialisasi queue
void initialize(struct Queue *queue) {
    queue->front = -1;
    queue->rear = -1;
}

// Fungsi untuk mengecek apakah queue kosong (isEmpty)
int isEmpty(struct Queue *queue) {
    return (queue->front == -1 && queue->rear == -1);
}

// Fungsi untuk mengecek apakah queue penuh (isFull)
int isFull(struct Queue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// Fungsi untuk menambahkan simpul ke dalam queue (enqueue)
void enqueue(struct Queue *queue, int value) {
    if (isFull(queue)) {
        printf("Queue penuh. Enqueue tidak bisa dilakukan.\n");
    } else {
        if (isEmpty(queue)) {
            queue->front = 0;
        }

        queue->rear = (queue->rear + 1) % MAX_SIZE;
        queue->array[queue->rear] = value;

        printf("Simpul %d ditambahkan ke dalam queue.\n", value);
    }
}

// Fungsi untuk menghapus simpul teratas dari queue (dequeue)
void dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong. Dequeue tidak bisa dilakukan.\n");
    } else {
        int removedValue = queue->array[queue->front];
        printf("Simpul %d dikunjungi dan dihapus dari queue.\n", removedValue);

        if (queue->front == queue->rear) {
            // Hanya satu simpul dalam queue
            initialize(queue);
        } else {
            queue->front = (queue->front + 1) % MAX_SIZE;
        }
    }
}

// Fungsi untuk menampilkan seluruh simpul dalam queue (display)
void display(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong.\n");
    } else {
        printf("Simpul dalam queue: ");
        int i = queue->front;
        do {
            printf("%d ", queue->array[i]);
            i = (i + 1) % MAX_SIZE;
        } while (i != (queue->rear + 1) % MAX_SIZE);
        printf("\n");
    }
}

// Fungsi untuk membuat graf dengan sejumlah simpul
struct Graph* createGraph(int numVertices) {
    struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
    graph->numVertices = numVertices;
    graph->adjacencyList = (struct Node**)malloc(numVertices * sizeof(struct Node*));

    for (int i = 0; i < numVertices; i++) {
        graph->adjacencyList[i] = NULL;
    }

    return graph;
}

// Fungsi untuk menambahkan edge (sambungan) antara dua simpul dalam graf
void addEdge(struct Graph* graph, int src, int dest) {
    // Menambahkan edge dari src ke dest
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = dest;
    newNode->next = graph->adjacencyList[src];
    graph->adjacencyList[src] = newNode;

    // Menambahkan edge dari dest ke src (graf tidak berarah)
    newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = src;
    newNode->next = graph->adjacencyList[dest];
    graph->adjacencyList[dest] = newNode;
}

// Fungsi untuk melakukan Breadth-First Search (BFS) pada graf
void BFS(struct Graph* graph, int startVertex) {
    struct Queue queue;
    initialize(&queue);

    int* visited = (int*)malloc(graph->numVertices * sizeof(int));
    for (int i = 0; i < graph->numVertices; i++) {
        visited[i] = 0;
    }

    visited[startVertex] = 1;
    enqueue(&queue, startVertex);

    while (!isEmpty(&queue)) {
        int currentVertex = queue.array[queue.front];
        dequeue(&queue);

        printf("Simpul %d dikunjungi.\n", currentVertex);

        struct Node* temp = graph->adjacencyList[currentVertex];
        while (temp != NULL) {
            int adjacentVertex = temp->data;
            if (!visited[adjacentVertex]) {
                visited[adjacentVertex] = 1;
                enqueue(&queue, adjacentVertex);
            }
            temp = temp->next;
        }
    }

    free(visited);
}

int main() {
    int numVertices, startVertex;

    printf("Masukkan jumlah simpul dalam graf: ");
    scanf("%d", &numVertices);

    struct Graph* graph = createGraph(numVertices);

    printf("Masukkan sambungan antar simpul (misal: 0 1, 1 2, dst.)\n");
    printf("Ketik -1 -1 untuk selesai.\n");

    int src, dest;
    while (1) {
        scanf("%d %d", &src, &dest);
        if (src == -1 || dest == -1) {
            break;
        }
        addEdge(graph, src, dest);
    }

    printf("Masukkan simpul awal untuk BFS: ");
    scanf("%d", &startVertex);

    printf("Melakukan Breadth-First Search (BFS) dari simpul %d:\n", startVertex);
    BFS(graph, startVertex);

    return 0;
}

output :


Program ini menyediakan implementasi Breadth-First Search (BFS) pada graf dengan menggunakan queue. Anda dapat menyesuaikan jumlah simpul dan sambungan antar simpul pada graf untuk menguji program.


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

#define MAX_SIZE 100

// Struktur untuk merepresentasikan node kata dalam queue
struct Node {
    char word[50];
    struct Node* next;
};

// Struktur untuk merepresentasikan queue
struct Queue {
    struct Node* front;
    struct Node* rear;
};

// Fungsi untuk menginisialisasi queue
void initialize(struct Queue *queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

// Fungsi untuk mengecek apakah queue kosong (isEmpty)
int isEmpty(struct Queue *queue) {
    return (queue->front == NULL && queue->rear == NULL);
}

// Fungsi untuk menambahkan kata ke dalam queue (enqueue)
void enqueue(struct Queue *queue, const char *word) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    strcpy(newNode->word, word);
    newNode->next = NULL;

    if (isEmpty(queue)) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }

    printf("Kata '%s' ditambahkan ke dalam queue.\n", word);
}

// Fungsi untuk menghapus kata teratas dari queue (dequeue)
void dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong. Dequeue tidak bisa dilakukan.\n");
    } else {
        struct Node* temp = queue->front;
        queue->front = temp->next;

        printf("Kata '%s' dihapus dari queue.\n", temp->word);

        free(temp);

        if (queue->front == NULL) {
            queue->rear = NULL;
        }
    }
}

// Fungsi untuk menampilkan seluruh kata dalam queue (display)
void display(struct Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue kosong.\n");
    } else {
        printf("Kata dalam queue: ");
        struct Node* temp = queue->front;
        while (temp != NULL) {
            printf("%s ", temp->word);
            temp = temp->next;
        }
        printf("\n");
    }
}

// Fungsi untuk membersihkan seluruh queue dan membebaskan memori
void clearQueue(struct Queue *queue) {
    while (!isEmpty(queue)) {
        dequeue(queue);
    }
}

int main() {
    struct Queue wordQueue;
    initialize(&wordQueue);

    enqueue(&wordQueue, "Program");
    enqueue(&wordQueue, "menggunakan");
    enqueue(&wordQueue, "queue");
    enqueue(&wordQueue, "untuk");
    enqueue(&wordQueue, "menyimpan");
    enqueue(&wordQueue, "kata-kata");

    display(&wordQueue);

    dequeue(&wordQueue);
    dequeue(&wordQueue);

    display(&wordQueue);

    clearQueue(&wordQueue);

    return 0;
}
output :


Program ini menggunakan linked list untuk merepresentasikan queue kata-kata dalam sebuah kalimat. Anda dapat menambahkan operasi atau memodifikasi program sesuai dengan kebutuhan.

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