Queue week 9

Queue

Queue adalah Suatu kumpulan data dimana penambahan data atau elemnnya dilakukan di belakang
sedangkan kalo mau hapusnya dilakukan dari sisi depan ( FIFO )

contoh :

front                               rear
Q1    ,    Q2    ,    Q3    ,    Q4

istilah istilah di Queue
1. Elemen depan = front
2. Elemen belakang = rear
3. Fifo = data yang pertama kali masuk , yang paling pertama juga keluar.
4. Enqueue = proses buat nambah data baru di belakang
5. Dequeue = proses buat hapus data/ ambil data di depan

Perbedaan Stack sama Queue adalah
Kalo stack itu sifatnya LIFO , kalo queue sifatnya FIFO .
Kalo stack pake istilah bottom sama top . kalo queue pake istilah front dan rear

implementasi source code :

– struct :

struct data{
char bil[10];
struct data *next,*prev;
};

– function tambah data di belakang

void tambahdata(data **front,char input[], data **rear){
data *baru;
data *curr;
printf(“New Data Insert\n”);
baru = (struct data*) malloc (sizeof(data));

strcpy(baru -> bil, input);
baru->next=NULL;
if(*front == NULL){
*front=baru;
*rear=baru;
}
else{
curr=*front;
while(curr->next!=NULL){
curr=curr->next;
}
curr->next=baru;
}
getch();
}

– function menampilkan data yang sudah di input

void tampildata(data **rear){
data *temp;
temp = *rear;
if(*rear == NULL){
printf(“Stack is Empty\n”);
}
else {
while(temp != NULL){
printf(“%s “, temp -> bil);
temp = temp -> next;
}
printf(“\n”);
}
}

– Function dequeue

void dequeue(data **front){
data *curr;
if(front==NULL){
printf(“Queue is Empty”);
}
else{
curr=*front;
printf(“Pooped : %s \n”,curr->bil);
*front=(*front)->next;
free(curr);
}
}

– Function top

void frontt(data **rear){
struct data *var=*rear;
if(var!=NULL){
printf(“%s”,var->bil);
printf(“\n”);
}
else{
printf(“\nQueue is Empty”);
}
}

– Function cek data apakah kosong atau tidak

void cek(data **rear){
struct data *temp, *var=*rear;
if(var != NULL){
printf(“Queue is Empty\n”);
}
else{
printf(“Queue is Not empty”);
}
}

Week 8-Stacking

 

Stack  adalah suatu struktur data yang terbentuk dari barisan hingga yang terurut dari satuan data. Pada Stack, penambahan dan penghapusan elemennya hanya dapat dilakukan pada satu posisi, yaitu posisi akhir stack. Posisi ini disebut Puncak atau Top dari stack. Stack mempunyai sifat LIFO (Last In First Out), Benda yang terakhir masuk ke dalam stack akan menjadi benda pertama yang dikeluarkan dari stack.

Stack karena aturan penyisipan dan penghapusan semacam itu, TOP adalah satu-satunya alamat tempat terjadi operasi. Elemen yang ditambahkan paling akhir akan menjadi elemen yang akan dihapus.Dikatakan bahwa elemen Stack akan tersusun secara LIFO (Last In First Out).

karena kita menumpuk Compo di posisi terakhir, maka Compo akan menjadi elemen teratas dalam tumpukan.

Sebaliknya, karena kita menumpuk Televisi pada saat pertama kali, maka elemen Televisi menjadi elemen terbawah dari tumpukan. Dan jika kita mengambil elemen dari tumpukan, maka secara otomatis akan terambil elemen teratas, yaitu Compo juga.

OPERASI-OPERASI/FUNGSI STACK

Push       : digunakan untuk menambah item pada stack pada tumpukan paling atas

Pop         : digunakan untuk mengambil item pada stack pada tumpukan paling atas

Clear       : digunakan untuk mengosongkan stack

IsEmpty : fungsi yang digunakan untuk mengecek apakah stack sudah kosong

IsFull     : fungsi yang digunakan untuk mengecek apakah stack sudah penuh

 

MACAM-MACAM STACK

1. Stack dengan Array

Sesuai dengan sifat stack, pengambilan atau penghapusan elemen dalam stack harus dimulai dari elemen teratas.

2. Double Stack dengan Array

Metode ini adalah teknik khusus yang dikembangkan untuk menghemat pemakaian memori dalam pembuatan dua stack dengan array. Intinya adalah penggunaan hanya sebuah array untuk menampung dua stack.

3.Stack dengan linked list

Adalah stack yang dibuat menggunakan linked list.

CONTOH PROGRAM STACK MENGGUNAKAN LINKED LIST

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

typedef int ItemType;
typedef struct simpul node;
struct simpul
{
	ItemType item;
	node *next;
};

struct Stack{
	node *TOS;
};

node *baru;

void awal()
{
	printf("===================================================");
	printf("=         PROGRAM STACK DENGAN LINKED LIST        =");
	printf("===================================================\n");
}

void allocate_node(ItemType x)
{
	baru = (node *) malloc (sizeof(node));
	if(baru==NULL)
	{
		printf("Gagal\n");
		exit(1);
	}
	else
	{
		baru->item=x;
		baru->next=NULL;
	}
}

void inisialisasi(Stack *s)
{
	s->TOS = NULL;
}

int kosong(Stack *s)
{
	return s->TOS==NULL;
}

void push(Stack *s)
{
	baru->next = s->TOS;
	s->TOS = baru;
}

ItemType pop(Stack *s)
{
	node *temp;
	if(kosong(s))
	{
		printf("Data Kosong\n");
		return ' ';
	}
	else
	{
		temp = s->TOS;
		s->TOS = s->TOS->next;
		return temp->item;
		free(temp);
		temp=NULL;
	}
}

void tampil(Stack *s)
{
	Stack bantu;
	bantu = *s;
	printf("\nData Simpul ==>  ");
	while(bantu.TOS!=NULL)
	{
		printf("%d ", bantu.TOS->item);
		bantu.TOS = bantu.TOS->next;
	}
	printf("\n\n");
}

void main()
{
	int pilih, data;
	char lagi='y';
	Stack ujung;

	inisialisasi(&ujung);
	while(lagi=='y')
	{
		system("CLS");
		awal();
		//tampil(&ujung);
		printf("Menu Pilihan : \n");
		printf("1. Push\n");
		printf("2. Pop\n");
		printf("3. Tampilkan Stack\n");
		printf("\nPilih No          : ");
		scanf("%d", &pilih);
		switch(pilih)
		{
		case 1:
			printf("Masukkan data     : ");
			scanf("%d", &data);
			allocate_node(data);
			push(&ujung);
			break;
		case 2:
			pop(&ujung);
			break;
		case 3:
			tampil(&ujung);
			break;
		}
		fflush(stdin);
		printf("Lagi (ya(y)/tidak(t) ? ");
		scanf("%c", &lagi);
	}
}

Erwin Iswandi(14110110137)
Anthony Nugraha(14110110138)