struktur data - 100 soal stack & queue ()

8/14/2019 Struktur Data - 100 Soal Stack & Queue (www.alonearea.com)

1/84

100 SOAL & JAWABAN STACK DAN QUEUE

Imam Ciptarjo 6307130TUGAS STRUKTUR DATA, MUNARWAN, S.T

1

alam istilah ilmu komputer, sebuah struktur data adalah cara

penyimpanan, pengorganisasian dan pengaturan data di

dalam media penyimpanan komputer sehingga data tersebut

dapat digunakan secara efisien. Dalam tehnik pemrograman,struktur data berarti tata letak data yang berisi kolom-kolom data, baik

itu kolom yang tampak oleh pengguna (user) ataupun kolom yang

hanya digunakan untuk keperluan pemrograman yang tiadak tampak

oleh pengguna. Setiap baris dari kumpulan kolom-kolom tersebut

dinamakan catatan (record).

DSrtuktur Data

Struktur data adalah cara menyimpan atau merepresentasikan data di

dalam komputer agar bisa dipakai secara efisien. Sedangkan data

adalah representasi dari fakta dunia nyata. Fakta atau keterangantentang kenyataan yang disimpan, direkam atau direpresentasikan

dalam bentuk tulisan, suara, gambar, sinyal atau simbol.

StackDalam ilmu komputer, stack atau tumpukan merupakan sebuah koleksi

objek yang menggunakan prinsip LIFO (Last In First Out), yaitu data

yang terakhr kali dimasukkan akan pertama kali keluar dari stack

tersebut. Stack dapat diimplementasikan sebagai representasi berkait

atau kontigu (dengan tabel fix).

Ciri Stack :* Elemen TOP (puncak) diketahui

* penisipan dan penghapusan elemen selalu dilakukan di TOP

* LIFO

Pemanfaatan Stack :

* Perhitungan ekspresi aritmatika (posfix)

* algoritma backtraking (runut balik)

* algoritma rekursif

Operasi Stack yang biasanya :

1. Push (input E : typeelmt, input/output data : stack):

menambahkan sebuah elemen ke stack

2. Pop (input/output data : stack, output E : typeelmt ) :

menghapus sebuah elemen stack

3. IsEmpty ()

4. IsFull ()

5. dan beberapas selektor yang lain

Contoh Soal Stack=========================== SOAL 1

=======================#include

#include


2/84



2

#include

struct list{int bil;struct list * next;

};typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE atas){PNODE pos;pos = atas;cout


3/84



3

PNODE atas=NULL;PNODE baru;int pil=1;clrscr();while(pil!=4){

cout


4/84



4

cout


5/84



5

coutpil;if (pil==1){

baru=x.masuk();x.PUSH(&atas, baru);

}if (pil==2)x.tampil(atas);if (pil==3){

x.POP(&atas);}

}}

=========================== SOAL 3

=======================#include

#include #include

class elemen{struct list{

int bil;struct list * next;

};public:typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE atas);void PUSH(PNODE *atas, PNODE baru);void POP(PNODE *atas);PNODE masuk(void);};

void elemen::tampil(PNODE atas){PNODE pos;pos = atas;cout


6/84



6

void elemen::POP(PNODE *atas){PNODE PH;PH = *atas;if(*atas==NULL){

coutnext;free(PH);}

}}

PNODE elemen::masuk(void){PNODE baru;baru=(NODE *)malloc(sizeof(NODE));coutbaru->bil;baru->next=NULL;return(baru);

}

void main(){PNODE atas=NULL;PNODE baru;int pil=1;

elemen data;clrscr();while(pil!=4){

cout


7/84



7

#include #include

class elemen{

struct list{

int bil;struct list *next;

};

public:typedef struct list NODE;typedef NODE *PNODE;

void tampil_stack (PNODE atas);void PUSH (PNODE *atas, PNODE baru);void POP (PNODE *atas);PNODE masuk_stack (void);

void tampil_queue (PNODE head);void insert (PNODE *tail,PNODE *head, PNODE baru);void INSERT_QUEUE (PNODE *tail,PNODE *head, PNODE baru);void DELETE_QUEUE (PNODE *head, PNODE *tail);PNODE masuk_queue (void);

};

void elemen :: tampil_stack (PNODE atas){

PNODE pos;pos = atas;cout


8/84



8

}

void elemen :: POP (PNODE *atas){

PNODE PH;PH = *atas;

if(*atas == NULL){

cout next;free(PH);

}}getch();

}

PNODE elemen :: masuk_stack (void){

PNODE baru;baru = (NODE *) malloc (sizeof(NODE));coutbaru->bil;baru -> next = NULL;return (baru);getch();

}

void elemen :: tampil_queue (PNODE head){

PNODE pos;pos = head;cout


9/84



9

{if(*tail == NULL){

*head = baru;*tail = baru;

}else{

(*tail) -> next = baru;*tail = baru;

}}

void elemen :: DELETE_QUEUE (PNODE *head, PNODE *tail){

PNODE PH;PH = *head;if(*head == NULL){

cout next;free(PH);

}}getch();

}

PNODE elemen :: masuk_queue (void)

{ PNODE baru;baru = (NODE *)malloc(sizeof(NODE));coutbaru -> bil;baru -> next = NULL;return(baru);getch();

}

void main(){

PNODE atas = NULL;

PNODE baru;PNODE head = NULL,tail = NULL;


10/84



10

int pil=1, x, m;char *a = "Created bY Tendi Setiadi (6306211) ";char *b = "";elemen data;textbackground (RED);clrscr();

m=strlen(a);gotoxy (20,20);for (x=0; x


11/84



11

{data.POP(&atas);

}}

}

if (pil == 2){

while(pil != 4){clrscr();

cout


12/84



12

void TAMPIL(PNODE ATAS){

int x;PNODE POS;POS = ATAS;cout


13/84



13

PNODE BARU;BARU=new(NODE);coutnext=NULL;return(BARU);

}

void tampil(pnode atas){

int x;pnode pos;pos = atas;cout


14/84



14

free(ph);}

}}

pnode masuk(void){

pnode baru;baru=new(node);coutnext=NULL;return(baru);

}

void main(){

pnode atas=NULL;pnode baru;PNODE BARU;PNODE ATAS=NULL;int pil=1;clrscr();

while(pil!=4){

cout


15/84



15

}

=========================== SOAL 6

=======================

#include#include#include

struct simpul{char kode[7];char nama[20];simpul *next;

};

class negara{simpul *head;

public:negara();~negara();void push();void pop();void view();void menu();

};

negara::negara(){

head=NULL;menu();}

negara::~negara(){simpul *tampung;//tampung=head;while(head!=NULL){tampung=head;head=head->next;delete(tampung);}

delete head;}

void negara::menu(){clrscr();cout


16/84



16

switch(pil){case 1:push();menu();break;case 2:pop();menu();break;case 3:view();menu();break;case 4:break;default:break;}

}

void negara::push(){simpul *baru;baru = new simpul;coutnext=head;head=baru;}

}

void negara::pop(){}

void negara::view(){simpul *lihat;lihat=head;while(lihat!=NULL){cout


17/84



17

struct nilaiMatKul{char nim[10];char nama[50];float nilai;

};

struct elemen{nilaiMatKul elmt;struct elemen *next;

};

struct stack{struct elemen *top;

};

//----------------------

void createEmpty(stack *S){(*S).top = NULL;

}

//----------------------

bool isEmpty(stack S){bool hasil = false;if(S.top == NULL){hasil = true;

}return hasil;}

//----------------------

int countElement(stack S){

int hasil = 0;if(S.top != NULL){/* stack tidak kosong */

elemen *elmt;

/* inisialisasi */elmt = S.top;

while(elmt != NULL){/* proses */hasil= hasil + 1;

/* iterasi */elmt = elmt->next;

}

}return hasil;


18/84



18

}

//----------------------

void push(char nim[], char nama[], float nilai, stack *S ){elemen *elmt;elmt = (elemen *) malloc (sizeof (elemen));strcpy(elmt->elmt.nim, nim);strcpy(elmt->elmt.nama, nama);elmt->elmt.nilai = nilai;elmt->next = (*S).top;(*S).top = elmt;elmt = NULL;

}

//----------------------

void pop(stack *S){if((*S).top != NULL){/* jika stack bukan stack kosong */elemen *elmt = (*S).top;(*S).top = (*S).top->next;elmt->next = NULL;free(elmt);

}}

//----------------------

void printStack(stack S){if(S.top != NULL){printf("------isi stack------\n");elemen *elmt = S.top;int i = 1;

while(elmt != NULL){printf("====================\n");printf("elemen ke : %d\n", i);printf("nim : %s\n", elmt->elmt.nim);

printf("nama : %s\n", elmt->elmt.nama);printf("nilai : %f\n", elmt->elmt.nilai);

/* iterasi */elmt = elmt->next;i = i + 1;

}printf("---------------------\n");}else{/* proses jika stack kosong */printf("stack kosong\n");

}}


19/84



19

//----------------------

int main(){struct stack S;

createEmpty(&S);printStack(S);printf("=================\n");

push("13507701", "Imam", 64.75, &S);push("13507702", "Cinta", 75.11, &S);push("13507703", "Jasmine", 84.63, &S);printStack(S);printf("=================\n");

pop(&S);pop(&S);printStack(S);

printf("=================\n");return 0;

}

=========================== SOAL 8

=======================#include #include

//----------------------


};

struct stack{int top;nilaiMatKul data[10];

};

//----------------------

void createEmpty(stack *S){(*S).top = -1;

}

//----------------------

bool isEmpty(stack S){

bool hasil = false;


20/84



20

if(S.top == -1){hasil = true;

}return hasil;}

//----------------------

bool isFull(stack S){bool hasil = false;if(S.top == 9){hasil = true;

}return hasil;

}

//----------------------

void push(char nim[], char nama[], float nilai, stack *S ){if(isFull(*S) == true){/*jika stack penuh*/printf("stack penuh\n");

}else{if(isEmpty(*S) == true){/* jika stack kosong */(*S).top = 0;strcpy((*S).data[0].nim, nim);strcpy((*S).data[0].nama, nama);(*S).data[0].nilai = nilai;

}else{/* jika stack tidak kosong */(*S).top = (*S).top + 1;strcpy((*S).data[(*S).top].nim, nim);

strcpy((*S).data[(*S).top].nama, nama);(*S).data[(*S).top].nilai = nilai;

}

}}

//----------------------

void pop(stack *S){if((*S).top == 0){/*jika stack berisi satu elemen*/(*S).top = -1;

}else{if((*S).top != -1){

/*jika stack tidak kosong*/(*S).top = (*S).top - 1;


21/84



21

}}

}

//----------------------

void printStack(stack S){if(S.top != -1){printf("------isi stack------\n");int i;for(i=S.top;i>=0;i--){printf("====================\n");printf("elemen ke : %d\n", i);printf("nim : %s\n", S.data[i].nim);printf("nama : %s\n", S.data[i].nama);printf("nilai : %f\n", S.data[i].nilai);

}printf("---------------------\n");}else{/* proses jika stack kosong */printf("stack kosong\n");

}}

//----------------------

int main(){struct stack S;

createEmpty(&S);printStack(S);

printf("=================\n");push("13507701", "Nana", 64.75, &S);push("13507702", "Rudi", 75.11, &S);push("13507703", "Dea", 84.63, &S);printStack(S);

printf("=================\n");pop(&S);pop(&S);printStack(S);

printf("=================\n");return 0;

}

=========================== SOAL 9

=======================#include #include

#include


22/84



22

#include #define MAX_CITY 30#define MAX_STATE 30#define MAX_ZIP 5void main (void);int is_empty (struct node *);int push (struct node **);int pop (struct node **);void search (struct node **);void free_nodes (struct node **pstack);

struct node {char zip_code[MAX_ZIP+1];char city[MAX_CITY];char state[MAX_STATE];struct node *link;

};

void main (void){

struct node *pstack = NULL;int ok_so_far = 1, no_of_nodes = 0;while (ok_so_far == 1) {

ok_so_far = push(&pstack);if (ok_so_far == 1)

no_of_nodes ++;else if(ok_so_far == 0) {

puts("\nAn unexpected error has occurred -terminating program");

exit(1);}

}search (&pstack);

free_nodes(&pstack);}

int push(struct node **pstack){struct node *new_ptr;

new_ptr = (struct node *) malloc(sizeof(struct node));if(new_ptr == (struct node *) NULL){printf("ERROR! Unable to allocate memory - Abort\n");free(new_ptr);return (0);}else{

printf("\n\nEnter %d digit zip code or 'q' toquit>>", MAX_ZIP);gets(new_ptr->zip_code);

new_ptr->zip_code[MAX_ZIP] = '\0';if (strcmp(new_ptr->zip_code, "q") != 0) {


23/84



23

printf("\nEnter a less than %d character state name>>\n",MAX_STATE);gets(new_ptr->state);printf("\nEnter a less than %d character city name>>\n",MAX_CITY);gets(new_ptr->city);new_ptr->link = *pstack;*pstack = new_ptr;return (1);}else return (2);}}

void search (struct node **pstack){struct node *ptemp;int test = 0;char ch, find[6];ptemp = *pstack;printf("\n\nEnter %d digit zip code to search for \nor 'e' toprint entire list>>", MAX_ZIP);gets(find);find[MAX_ZIP] = '\0';if (find[0] =='E' || find[0] =='e'){test = 1;while (test != 0)test = pop (pstack);}else{while (test == 0 || ptemp != NULL){if (strcmp(ptemp->zip_code, find) == 0){test = 1;printf("Zip Code: %s\n", ptemp->zip_code);printf("State: %s\n", ptemp->state);

printf("City: %s\n\n", ptemp->city);}else if (ptemp == NULL){printf("The zip code %s was not found.\n", find);test = 1;}ptemp = ptemp->link;}puts ("\nType 'y' if you would you like to see the entire list");puts ("or any other key to continue>>");if (ch == 'y' || ch == 'Y')

{test = 1;


24/84



24

while (test != 0)test = pop (pstack);}}}

int pop (struct node **pstack){struct node *temp;if (is_empty(*pstack)== 1){printf("\nStack is now empty");return(0);}else{temp = *pstack;printf("Zip Code: %s\n", temp->zip_code);printf("State: %s\n", temp->state);printf("City: %s\n\n", temp->city);*pstack = (*pstack)->link;free(temp);return(1);}}

int is_empty (struct node *stack){if (stack == NULL)return(1);return(0);}

void free_nodes (struct node **pstack){struct node *temp;while (*pstack != NULL){temp = *pstack;

*pstack = (*pstack)->link;free(temp);}}

=========================== SOAL 10

=======================# include # include struct node{

int data;struct node *link;

};


25/84



25

struct node *push(struct node *p, int value){

struct node *temp;temp=(struct node *)malloc(sizeof(struct node));

/* creates new nodeusing data valuepassed as parameter */

if(temp==NULL){

printf("No Memory available Error\n");exit(0);

}temp->data = value;temp->link = p;p = temp;return(p);

}

struct node *pop(struct node *p, int *value){

struct node *temp;if(p==NULL){

printf(" The stack is empty can not pop Error\n");exit(0);

}*value = p->data;temp = p;p = p->link;free(temp);return(p);

}

void main(){

struct node *top = NULL;int n,value;do{

do{printf("Enter the element to be pushed\n");scanf("%d",&value);top = push(top,value);printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);

printf("Enter 1 to pop an element\n");scanf("%d",&n);while( n == 1)

{ top = pop(top,&value);


26/84



26

printf("The value poped is %d\n",value);printf("Enter 1 to pop an element\n");scanf("%d",&n);

}printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);}

=========================== SOAL 11

=======================#include #include

//deklarasi 'STACK' dengan struct dan arraytypedef struct STACK

{ int data[5];int atas;

};

//deklarasi variabel 'tumpuk' dari structSTACK tumpuk;

void main(){

clrscr();int pilihan,baru,i;

//inisialisasi awaltumpuk.atas=-1;do{

clrscr();printf("1.Push Data\n");printf("2.Pop Data\n");printf("3.Print Data\n");printf("\nPilihan = ");scanf("%i",&pilihan);switch(pilihan){

case 1:{if(tumpuk.atas==5-1){

printf("Tumpukan penuh");getch();

}else{

printf("Data yang akan di-push = ");scanf("%d",&baru);tumpuk.atas++;

tumpuk.data[tumpuk.atas]=baru;


27/84



27

}break;

}case 2:{

if(tumpuk.atas==-1){

printf("Tumpukan kosong");getch();

}else{

printf("Data yang akan di-pop = %d",tumpuk.data[tumpuk.atas]);

tumpuk.atas--;getch();

}break;

}case 3:{

if(tumpuk.atas==-1){

printf("Tumpukan kosong");getch();

}else{

printf("Data = ");for(i=0; i=1 && pilihan


28/84



28

int data[MAX];} Stack;Stack stack;int top[2];void Create(){//kosongkan stacktop[0] = -1;top[1] = MAX; //top[1] = 8 karena elemen array 0-7}void Tampil(){int i;printf("Stack 1\n");for(i=0;i=top[1];i--){printf("%d ",stack.data[i]);}}void Clear(int noStack){if(noStack==1) top[0]=-1; elseif(noStack==2) top[1]=MAX;}int IsFull(){int full = 0;if(top[0]+1 >= top[1]) full=1;return full;}void Push(int d, int noStack){if(IsFull()==0){if(noStack == 1) top[0]++; elseif(noStack == 2) top[1]--;stack.data[top[noStack-1]] = d;printf("masuk %d !",stack.data[top[noStack-1]]);}}int IsEmpty(int noStack){int empty=0;

if(noStack==1){if(top[0] == 0) empty=1;} elseif(noStack==2){if(top[1] == MAX) empty=1;}return empty;}int Pop(int noStack){int e;if(IsEmpty(noStack)==0){e=stack.data[top[noStack-1]];

if(noStack==1) top[0]--; elseif(noStack==2) top[1]++;


29/84



29

}return e;}void Clear(int noStack){if(noStack==1) top[0]=-1; elseif(noStack==2) top[1]=MAX;}void Tampil(){int i;printf("Stack 1\n");for(i=0;i=top[1];i--){printf("%d ",stack.data[i]);}}void main(){int pil;int no;int data;Create();do{clrscr();printf("1. Push\n");printf("2. Pop\n");printf("3. Tampil\n");printf("4. Clear\n");printf("5. Exit\n");printf("Pilihan = ");scanf("%d",&pil);switch(pil){case 1: printf("stack ke (1/2) : ");scanf("%d",&no);printf("Data = ");scanf("%d",&data);Push(data,no);break;case 2: printf("stack ke (1/2) : ");scanf("%d",&no);printf("Elemen yang keluar : %d",Pop(no));break;

case 3: Tampil();break;case 4: printf("stack ke (1/2) : ");scanf("%d",&no);Clear(no);break;}getch();} while(pil!=5);}

=========================== SOAL 13

=======================#include

#include


30/84



30

#include



void tampil(PNODE atas){PNODE pos;pos = atas;cout


31/84



31

PNODE atas=NULL;PNODE baru;int pil=1;clrscr();while(pil!=4){

cout


32/84



32




33/84


34/84



34

*tail = NULL;free(PH);

}else{

*head = (*head) -> next;free(PH);

}}getch();

}

PNODE elemen :: masuk_queue (void){

PNODE baru;baru = (NODE *)malloc(sizeof(NODE));coutbaru -> bil;baru -> next = NULL;return(baru);getch();

}

void main(){

PNODE atas = NULL;PNODE baru;PNODE head = NULL,tail = NULL;int pil=1, x, m;char *a = "Created bY Tendi Setiadi (6306211) ";char *b = "";elemen data;textbackground (RED);clrscr();



35/84



35

cout


36/84



36

data.tampil_queue(head);

if (pil == 3){

data.DELETE_QUEUE(&head,&tail);}

}}

}}

=========================== SOAL 15

=======================#include #include #include


int bil;struct list * next;

};public:typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE atas);void PUSH(PNODE *atas, PNODE baru);

void POP(PNODE *atas);PNODE masuk(void);};

void elemen::tampil(PNODE atas){PNODE pos;pos = atas;cout


37/84



37

PH = *atas;if(*atas==NULL){

coutnext;free(PH);}

}}


}

void main(){PNODE atas=NULL;PNODE baru;int pil=1;

elemen data;clrscr();while(pil!=4){

cout


38/84



38

=========================== SOAL 18

=======================

=========================== SOAL 19=======================

=========================== SOAL 20

=======================

=========================== SOAL 21

=======================

=========================== SOAL 22

=======================

=========================== SOAL 23

=======================

=========================== SOAL 24

=======================

=========================== SOAL 25

=======================

=========================== SOAL 26=======================

=========================== SOAL 27

=======================

=========================== SOAL 28

=======================

=========================== SOAL 29

=======================

=========================== SOAL 30

=======================

=========================== SOAL 31

=======================

=========================== SOAL 32

=======================

=========================== SOAL 33

=======================


39/84



39

=========================== SOAL 34

=======================

=========================== SOAL 35

=======================

=========================== SOAL 36

=======================

=========================== SOAL 37

=======================

=========================== SOAL 38

=======================

=========================== SOAL 39

=======================

=========================== SOAL 40

=======================

=========================== SOAL 41

=======================

=========================== SOAL 42

=======================

=========================== SOAL 43

=======================

=========================== SOAL 44

=======================

=========================== SOAL 45

=======================

=========================== SOAL 46

=======================

=========================== SOAL 47

=======================

=========================== SOAL 48

=======================


40/84



40

=========================== SOAL 49

=======================

=========================== SOAL 50=======================

===========================================

================

QueueQueue (Antrian) adalah list linier yang :

1. Dikenali elemen pertama (Head) dan elemen terakhirnya (Tail)

2. Aturan penyisipan dan penghapusan elemennya disefinisikansebagai berikut :

- Penyisipan selalu dilakukan setelah elemen terakhir

- Penghapusan selalu dilakukan pada elemen pertama

3. Satu elemen dengan elemen lain dapat diakses melalui

informasi Next

Contoh Soal Queue=========================== SOAL 1

=======================

#include #include #include #define MAX 8

typedef struct{

char data[MAX];int head;int tail;

}Queue;

Queue antrian;

void Create(){

antrian.head=antrian.tail=-1;}

int IsEmpty(){

if(antrian.tail==-1)return 1;

else

return 0;


41/84



41

}

int IsFull(){

if(antrian.tail==MAX-1)return 1;

elsereturn 0;

}

void Enqueue(int data){

if(IsEmpty()==1){

antrian.head=antrian.tail=0;antrian.data[antrian.tail]=data;printf("%d masuk!",antrian.data[antrian.tail]);

}else if(IsFull()==0){

antrian.tail++;antrian.data[antrian.tail]=data;printf("%d masuk!",antrian.data[antrian.tail]);

}}

int Dequeue(){

int i;int e = antrian.data[antrian.head];for(i=antrian.head;i


42/84



42

}else printf("data kosong!\n");

}

void main(){

int pil;char kota[MAX];Create();do{

clrscr();printf("1. Enqueue\n");printf("2. Dequeue\n");printf("3. Tampil\n");printf("4. Clear\n");printf("5. Exit\n");printf("Pilihan = ");scanf("%d",&pil);switch(pil){

case 1:{

cout


43/84


44/84



44

{element *curr,*prev; //remove the first element inserted andcurr=head; //point the head to next elementhead=curr->next;curr=NULL;}size--;}

int Queue::isEmpty(){

if(getQueueSize()==0)return 1;

return 0;}

int Queue::getQueueSize(){return size;}//returns size of the Queue

void Queue::printQueueSize(){cout


45/84



45

void main(){

Queue qt;qt.printQueueMenu();char Option=0;int val;while(1)

{qt.printQueueMenu();cin>>Option;switch(Option){case '1':coutval;qt.Enqueue(val);break;case '2':qt.Dequeue();break;case '3':qt.printQueueElements();break;case '4':qt.printQueueSize();break;case '5':exit(0);break;}

}}

=========================== SOAL 3


struct list{

int bil;struct list * next;};typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE head){PNODE pos;pos = head;cout


46/84



46

}}

void INSERT_QUEUE(PNODE *tail,PNODE *head, PNODE baru){if(*tail==NULL){


}else{(*tail)->next = baru;*tail = baru;

}}

void DELETE_QUEUE(PNODE *head, PNODE *tail){PNODE PH;PH = *head;if(*head==NULL){

coutnext;free(PH);}

}}

PNODE masuk(void){PNODE baru;baru=(NODE *)malloc(sizeof(NODE));coutbaru->bil;baru->next=NULL;return(baru);

}

void main(){

PNODE head=NULL,tail=NULL;PNODE baru;int pil=1;clrscr();while(pil!=4){

cout


47/84



47

if (pil==2)tampil(head);

if (pil==3){DELETE_QUEUE(&head,&tail);

}}

}

=========================== SOAL 4


struct list{int bil;

struct list * next;};typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE head){PNODE pos;pos = head;cout


48/84


49/84


50/84



50

int pil=1;elemen data;clrscr();while(pil!=4){

cout


51/84



51




52/84



52



}




53/84



53

free(PH);}else{

*head = (*head) -> next;free(PH);

}}getch();

}



}

void main(){

PNODE atas = NULL;PNODE baru;PNODE head = NULL,tail = NULL;int pil=1, x, m;char *a = "Created bY Tendi Setiadi (6306211) ";char *b = "";elemen data;textbackground (RED);clrscr();



54/84


55/84



55

if (pil == 3){


}}

}}

=========================== SOAL 7


//----------------------


};

struct elemen{nilaiMatKul elmt;struct elemen *next;

};

struct queue{struct elemen *first;struct elemen *last;

};

//----------------------

void createEmpty(queue *Q){(*Q).first = NULL;(*Q).last = NULL;

}

//----------------------

bool isEmpty(queue Q){bool hasil = false;if(Q.first == NULL){hasil = true;

}

return hasil;}

//----------------------


56/84



56

int countElement(queue Q){int hasil = 0;

if(Q.first != NULL){/* queue tidak kosong */

elemen *elmt;

/* inisialisasi */elmt = Q.first;

while(elmt != NULL){/* proses */hasil= hasil + 1;

/* iterasi */elmt = elmt->next;

}

}return hasil;

}

//----------------------

void add(char nim[], char nama[], float nilai, queue *Q ){elemen *elmt;elmt = (elemen *) malloc (sizeof (elemen));strcpy(elmt->elmt.nim, nim);strcpy(elmt->elmt.nama, nama);elmt->elmt.nilai = nilai;elmt->next = NULL;if((*Q).first == NULL){

(*Q).first = elmt;}else{

(*Q).last->next = elmt;}

(*Q).last = elmt;elmt = NULL;}

//----------------------

void del(queue *Q){if((*Q).first != NULL){/* jika queue bukan queue kosong */elemen *elmt = (*Q).first;(*Q).first = (*Q).first->next;elmt->next = NULL;

free(elmt);}


57/84


58/84



58

=========================== SOAL 8

=======================#include

#include

//----------------------


};

struct queue{int first;

int last;nilaiMatKul data[10];};

//----------------------

void createEmpty(queue *Q){

(*Q).first = -1;(*Q).last = -1;

}

//----------------------

bool isEmpty(queue Q){bool hasil = false;

if(Q.first == -1){hasil = true;

}return hasil;}

//----------------------

bool isFull(queue Q){bool hasil = false;if(Q.last == 9){hasil = true;

}return hasil;

}

//----------------------

void add(char nim[], char nama[], float nilai, queue *Q ){


59/84



59

if(isEmpty(*Q) == true){/* jika queue kosong */(*Q).first = 0;(*Q).last = 0;strcpy((*Q).data[0].nim, nim);strcpy((*Q).data[0].nama, nama);(*Q).data[0].nilai = nilai;

}else{/* jika queue tidak kosong */if(isFull(*Q) != true){(*Q).last = (*Q).last + 1;

strcpy((*Q).data[(*Q).last].nim, nim);strcpy((*Q).data[(*Q).last].nama, nama);(*Q).data[(*Q).last].nilai = nilai;}else{

printf("queue penuh\n");}

}

}//----------------------

void del(queue *Q){if((*Q).last == 0){(*Q).first = -1;(*Q).last = -1;

}else{/*menggeser elemen ke depan*/int i;for(i=((*Q).first + 1);i=Q.first;i--){printf("====================\n");printf("elemen ke : %d\n", i);

printf("nim : %s\n", Q.data[i].nim);printf("nama : %s\n", Q.data[i].nama);


60/84



60

printf("nilai : %f\n", Q.data[i].nilai);}printf("---------------------\n");}else{/* proses jika queue kosong */printf("queue kosong\n");

}}

//----------------------

int main(){queue Q;

createEmpty(&Q);printQueue(Q);

printf("=================\n");

add("13507701", "Nana", 64.75, &Q);add("13507702", "Rudi", 75.11, &Q);add("13507703", "Dea", 84.63, &Q);printQueue(Q);

printf("=================\n");del(&Q);del(&Q);printQueue(Q);

printf("=================\n");return 0;

}

=========================== SOAL 9

=======================#include #define MAX 10 /* The maximum size of the queue */#include

void insert(int queue[], int *rear, int value){

if(*rear < MAX-1){

*rear= *rear +1;queue[*rear] = value;

}else{

printf("The queue is full can not insert a value\n");exit(0);

}


61/84



61

}

void delete(int queue[], int *front, int rear, int * value){

if(*front == rear){

printf("The queue is empty can not delete a value\n");exit(0);

}*front = *front + 1;*value = queue[*front];

}

void main(){

int queue[MAX];int front,rear;int n,value;front=rear=(-1);do{

do{

printf("Enter the element to be inserted\n");scanf("%d",&value);insert(queue,&rear,value);printf("Enter 1 to continue\n");

scanf("%d",&n);} while(n == 1);

printf("Enter 1 to delete an element\n");scanf("%d",&n);while( n == 1){

delete(queue,&front,rear,&value);printf("The value deleted is %d\n",value);

printf("Enter 1 to delete an element\n");scanf("%d",&n);

}

printf("Enter 1 to continue\n");scanf("%d",&n);} while(n == 1);

}

===================== SOAL 10 Circular Queue

==================#include #define MAX 10 /* The maximum size of the queue */#include

void insert(int queue[], int *rear, int front, int value){

*rear= (*rear +1) % MAX;


62/84



62

if(*rear == front){

printf("The queue is full can not insert a value\n");exit(0);

}queue[*rear] = value;

}

void delete(int queue[], int *front, int rear, int * value){

if(*front == rear){

printf("The queue is empty can not delete a value\n");exit(0);

}*front = (*front + 1) % MAX;*value = queue[*front];

}

void main(){

int queue[MAX];int front,rear;int n,value;front=0; rear=0;do{

do{

printf("Enter the element to be inserted\n");scanf("%d",&value);insert(queue,&rear,front,value);printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);

printf("Enter 1 to delete an element\n");scanf("%d",&n);while( n == 1)

{ delete(queue,&front,rear,&value);printf("The value deleted is %d\n",value);printf("Enter 1 to delete an element\n");scanf("%d",&n);

}printf("Enter 1 to continue\n");scanf("%d",&n);} while(n == 1);

}

=============== SOAL 11 Queue Dengan Link List

================

# include


63/84


64/84



64

do{

do{

printf("Enter the element to be inserted\n");scanf("%d",&value);insert(&front,&rear,value);printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);


delete(&front,&rear,&value);printf("The value deleted is %d\n",value);printf("Enter 1 to delete an element\n");scanf("%d",&n);

}printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);}

==================== SOAL 12 Priority Queue

===================# include

# include struct node{

int data;int priority;struct node *link;

};void insert(struct node **front, struct node **rear, int value,int priority){

struct node *temp,*temp1;temp=(struct node *)malloc(sizeof(struct node));

/* creates new node using data valuepassed as parameter */if(temp==NULL){

printf("No Memory available Error\n");exit(0);

}temp->data = value;temp->priority = priority;temp->link=NULL;if(*rear == NULL) /* This is the first node */{

*rear = temp;


65/84



65

*front = *rear;}else{

if((*front)->priority < priority)/* the element to be inserted has

highest priority hence shouldbe the first element*/

{temp->link = *front;*front = temp;

}else

if( (*rear)->priority > priority)/* the element to be inserted haslowest priority hence shouldbe the last element*/

{(*rear)->link = temp;*rear = temp;

}

else{

temp1 = *front;while((temp1->link)->priority >= priority)

/* find the position and insert the new element */temp1=temp1->link;

temp->link = temp1->link;temp1->link = temp;}

}void delete(struct node **front, struct node **rear, int *value,int *priority){

struct node *temp;if((*front == *rear) && (*rear == NULL)){

printf(" The queue is empty cannot delete Error\n");

exit(0);}*value = (*front)->data;*priority = (*front)->priority;temp = *front;*front = (*front)->link;if(*rear == temp)

*rear = (*rear)->link;free(temp);

}

void main()

{ struct node *front=NULL,*rear = NULL;


66/84



66

int n,value, priority;do{do{

printf("Enter the element to be inserted and itspriority\n");

scanf("%d %d",&value,&priority);insert(&front,&rear,value,priority);printf("Enter 1 to continue\n");scanf("%d",&n);

} while(n == 1);


delete(&front,&rear,&value,&priority);printf("The value deleted is %d\ and its priority is %d

\n",value,priority);

printf("Enter 1 to delete an element\n");scanf("%d",&n);

}printf("Enter 1 to delete an element\n");scanf("%d",&n);

} while( n == 1)}

=========================== SOAL 13

=======================#include #include #define MAX 8typedef struct{int data[MAX];int head;int tail;} Queue;Queue antrian;

void Create(){antrian.head=antrian.tail=-1;}int IsEmpty(){if(antrian.tail==-1)return 1;elsereturn 0;}int IsFull(){if(antrian.tail==MAX-1) return 1;else return 0;

}


67/84



67

void Enqueue(int data){if(IsEmpty()==1){antrian.head=antrian.tail=0;antrian.data[antrian.tail]=data;printf("%d masuk!",antrian.data[antrian.tail]);void Tampil(){if(IsEmpty()==0){for(int i=antrian.head;i


68/84



68

Enqueue(data);break;case 2: printf("Elemen yang keluar : %d",Dequeue());break;case 3: Tampil();break;case 4: Clear();break;}getch();} while(pil!=5);}

=========================== SOAL 14

=======================#include

#include #include #include #include

int main(){

int k;Queue timeLine;cout


69/84



69

=========================== SOAL 15

=======================#include

#include #include #define MAX 8

typedef struct{

char data[MAX];int head;int tail;

}Queue;

Queue antrian;

void Create(){

antrian.head=antrian.tail=-1;}

int IsEmpty(){

if(antrian.tail==-1)return 1;

elsereturn 0;

}

int IsFull(){

if(antrian.tail==MAX-1)return 1;

elsereturn 0;

}

void Enqueue(int data){

if(IsEmpty()==1){antrian.head=antrian.tail=0;antrian.data[antrian.tail]=data;printf("%d masuk!",antrian.data[antrian.tail]);

}else if(IsFull()==0){

antrian.tail++;antrian.data[antrian.tail]=data;printf("%d masuk!",antrian.data[antrian.tail]);

}

}


70/84



70

int Dequeue(){

int i;int e = antrian.data[antrian.head];for(i=antrian.head;i


71/84



71

Enqueue(*kota);break;

}case 2:{

printf("Elemen yang keluar :%d",Dequeue());

break;}case 3: Tampil(); break;case 4: Clear(); break;

}getch();

}while(pil!=5);}

=========================== SOAL 16



char kota[30];struct list * next;

};

public:typedef struct list NODE;typedef NODE * PNODE;void tampil(PNODE head);void INSERT_QUEUE(PNODE *tail,PNODE *head, PNODE baru);void DELETE_QUEUE(PNODE *head, PNODE *tail);void PUSH(PNODE *head, PNODE baru);void POP(PNODE *head);PNODE masuk(void);

}data;

void elemen::PUSH(PNODE *head, PNODE baru){if(*head==NULL){*head = baru;

}else{baru->next = *head;*head = baru;

}}

void elemen::POP(PNODE *head){PNODE PH;PH = *head;

if(*head==NULL){


72/84



72

coutnext;free(PH);

}}

}

void elemen::tampil(PNODE head){PNODE pos;pos = head;if(pos==NULL){

cout


73/84



73

}

PNODE elemen::masuk(void){PNODE baru;baru=(NODE *)malloc(sizeof(NODE));coutbaru->kota;baru->next=NULL;return(baru);

}

void main(){PNODE head=NULL,tail=NULL;PNODE baru;int pil=1,cari=1;clrscr();while(pil!=4){

clrscr();cout


74/84



74

}

=========================== SOAL 17

=======================

#include #include #include



void tampil(PNODE head){



75/84



75

PNODE baru;baru=(NODE *)malloc(sizeof(NODE));coutbaru->bil;baru->next=NULL;return(baru);

}

void main(){PNODE head=NULL,tail=NULL;PNODE baru;int pil=1;clrscr();while(pil!=4){

cout


76/84



76

PNODE masuk_stack (void);

void tampil_queue (PNODE head);void insert (PNODE *tail,PNODE *head, PNODE baru);void INSERT_QUEUE (PNODE *tail,PNODE *head, PNODE baru);void DELETE_QUEUE (PNODE *head, PNODE *tail);PNODE masuk_queue (void);

};




77/84



77

else{

*atas = (*atas) -> next;free(PH);

}}getch();

}



}




78/84



78

{cout next;free(PH);

}}getch();

}



}

void main(){

PNODE atas = NULL;PNODE baru;PNODE head = NULL,tail = NULL;int pil=1, x, m;char *a = "Created bY Tendi Setiadi (6306211) ";char *b = "";

elemen data;textbackground (RED);clrscr();



79/84



79

{cout


80/84



80

if (pil == 1){

baru=data.masuk_queue();data.INSERT_QUEUE(&tail,&head,baru);

}

if (pil == 2)data.tampil_queue(head);

if (pil == 3){


}}

}}

=========================== SOAL 19



int bil;

struct list * next;};public:typedef struct list NODE;typedef NODE * PNODE;

void tampil(PNODE head);void insert(PNODE *tail,PNODE *head, PNODE baru);void INSERT_QUEUE(PNODE *tail,PNODE *head, PNODE baru);void DELETE_QUEUE(PNODE *head, PNODE *tail);PNODE masuk(void);};

void elemen::tampil(PNODE head){PNODE pos;pos = head;cout


81/84



81


}else{(*tail)->next = baru;*tail = baru;

}}

void elemen::DELETE_QUEUE(PNODE *head, PNODE *tail){PNODE PH;PH = *head;if(*head==NULL){

coutnext;free(PH);}

}}


}

void main(){PNODE head=NULL,tail=NULL;PNODE baru;int pil=1;elemen data;clrscr();

while(pil!=4){cout


82/84



82

}}

}

=========================== SOAL 20

=======================

=========================== SOAL 21

=======================

=========================== SOAL 22

=======================

=========================== SOAL 23

=======================

=========================== SOAL 24

=======================

=========================== SOAL 25

=======================

=========================== SOAL 26

=======================

=========================== SOAL 27

=======================

=========================== SOAL 28

=======================

=========================== SOAL 29

=======================

=========================== SOAL 30

=======================

=========================== SOAL 31

=======================

=========================== SOAL 32

=======================

=========================== SOAL 33

=======================

=========================== SOAL 34

=======================


83/84



83

=========================== SOAL 35

=======================

=========================== SOAL 36

=======================

=========================== SOAL 37

=======================

=========================== SOAL 38

=======================

=========================== SOAL 39

=======================

=========================== SOAL 40

=======================

=========================== SOAL 41

=======================

=========================== SOAL 42

=======================

=========================== SOAL 43

=======================

=========================== SOAL 44

=======================

=========================== SOAL 45

=======================

=========================== SOAL 46

=======================

=========================== SOAL 47

=======================

=========================== SOAL 48

=======================

=========================== SOAL 49

=======================


84/84

100 SOAL & JAWABAN STACK DAN QUEUE84

=========================== SOAL 50

=======================

===========================================================

struktur data - 100 soal stack & queue ()

Documents