Struktur Data - 100 Soal Stack & Queue

1 100 SOAL & JAWABAN STACK DAN QUEUE
D
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).
Srtuktur 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 keterangan
tentang kenyataan yang disimpan, direkam atau direpresentasikan
dalam bentuk tulisan, suara, gambar, sinyal atau simbol.
Stack
Dalam 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 <iostream.h>
#include <stdlib.h>
Imam Ciptarjo – 6307130

TUGAS STRUKTUR DATA, MUNARWAN, S.T
#include <conio.h>
struct list{
int bil;
struct list * next;
};
typedef struct list NODE;
typedef NODE * PNODE;
void tampil(PNODE atas){

PNODE pos;
pos = atas;
cout<<"\n\nbilangan : ";
while(pos!=NULL){
cout<<pos->bil<<", ";
pos=pos->next;
}
}
void PUSH(PNODE *atas, PNODE baru){

if(*atas==NULL){
*atas = baru;
}else{
baru->next = *atas;
*atas = baru;
}
}
void POP(PNODE *atas){

PNODE PH;
PH = *atas;
if(*atas==NULL){
cout<<"\n\nSTACK KOSONG !!!\n\n";
}else{
if (PH->next==NULL){
*atas = NULL;
free(PH);
}else{
*atas = (*atas)->next;
free(PH);
}
}
}
PNODE masuk(void){
PNODE baru;
baru=(NODE *)malloc(sizeof(NODE));
cout<<"\nbil : ";cin>>baru->bil;
baru->next=NULL;
return(baru);
}
void main(){

PNODE atas=NULL;
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n\n1. PUSH STACK";
cout<<"\n2. LIHAT DATA STACK";
cout<<"\n3. POP STACK";
cout<<"\n4. EXIT";
cout<<"\nPilihan : ";cin>>pil;
if (pil==1){
baru=masuk();
PUSH(&atas, baru);
}
if (pil==2)
tampil(atas);
if (pil==3){
POP(&atas);
}
}
}
=========================== SOAL 2
=======================
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
class brg{
struct list{
char kode[10];
char nama[30];
char satu[20];
long harga;
struct list * next;
};
public:

void tampil(PNODE atas);
void PUSH(PNODE *atas, PNODE baru);
void POP(PNODE *atas);
PNODE masuk(void);
}x;
void brg::tampil(PNODE atas){
PNODE pos;
pos = atas;
while(pos!=NULL){
cout <<pos->kode<<"\t";
cout <<pos->nama<<"\t";

cout <<pos->satu<<"\t";
cout <<pos->harga<<"\n";
pos=pos->next;
}
}
void brg::PUSH(PNODE *atas, PNODE baru){

if(*atas==NULL){
*atas = baru;
}else{
baru->next = *atas;
*atas = baru;
}
}
void brg::POP(PNODE *atas){

PNODE PH;
PH = *atas;
if(*atas==NULL){
}else{
*atas = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE brg::masuk(void){
PNODE baru;
cout<<"\nKode : ";gets(baru->kode);
cout<<"\nNama : ";gets(baru->nama);
cout<<"\nSatuan : ";gets(baru->satu);
cout<<"\nharga : ";cin>>baru->kode;
baru->next=NULL;
return(baru);
}
void main(){
PNODE atas=NULL;
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n\n1. INPUT BARANG";
cout<<"\n2. LIHAT DAFTAR";
cout<<"\n3. HAPUS DAFTAR";
cout<<"\n4. EXIT";

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 <stdlib.h>
#include <conio.h>
class elemen{
struct list{
int bil;
struct list * next;
};
public:

PNODE masuk(void);
};
void elemen::tampil(PNODE atas){

PNODE pos;
pos = atas;
while(pos!=NULL){
pos=pos->next;
}
}
void elemen::PUSH(PNODE *atas, PNODE baru){

if(*atas==NULL){
*atas = baru;
}else{
baru->next = *atas;
*atas = baru;
}
}

void elemen::POP(PNODE *atas){

PNODE PH;
PH = *atas;
if(*atas==NULL){
}else{
*atas = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE elemen::masuk(void){
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE atas=NULL;
PNODE baru;
int pil=1;
elemen data;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=data.masuk();
data.PUSH(&atas, baru);
}
if (pil==2)
data.tampil(atas);
if (pil==3){
data.POP(&atas);
}
}
}
=========================== SOAL 4
=======================
#include <string.h>
#include <dos.h>

#include <stdlib.h>
#include <conio.h>
class elemen
{
struct list
{
int bil;
struct list *next;
};
public:
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;
while(pos != NULL)
{
cout<<pos -> bil<<", ";
pos = pos -> next;
}
cout<<"\n\n\n [TEKAN ENTER UNTUK MELANJUTKAN]";
getch();
}
void elemen :: PUSH (PNODE *atas, PNODE baru)

{
if (*atas == NULL)
{
*atas = baru;
}
else
{
baru -> next = *atas;
*atas = baru;
}

void elemen :: POP (PNODE *atas)

{
PNODE PH;
PH = *atas;
if(*atas == NULL)
{
}
else
{
if (PH -> next == NULL)
{
*atas = NULL;
free(PH);
}
else
{
*atas = (*atas) -> next;
free(PH);
}
}
getch();
}
PNODE elemen :: masuk_stack (void)

{
PNODE baru;
baru = (NODE *) malloc (sizeof(NODE));
baru -> next = NULL;
return (baru);
getch();
}
void elemen :: tampil_queue (PNODE head)

{
PNODE pos;
pos = head;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}
void elemen :: INSERT_QUEUE (PNODE *tail,PNODE *head, PNODE baru)

{
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<<"\n\nQUEUE KOSONG !!!\n\n";
}
else
{
{
*head = NULL;
*tail = NULL;
free(PH);
}
else
{
*head = (*head) -> next;
free(PH);
}
}
getch();
}
PNODE elemen :: masuk_queue (void)

{
PNODE baru;
baru = (NODE *)malloc(sizeof(NODE));
cout<<"\nbil : ";cin>>baru -> bil;
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();
m=strlen(a);
gotoxy (20,20);
for (x=0; x<m; x++)
{
cout<<*(a+x);
delay(200);
}
gotoxy (3,24);
for (x=0; x<75; x++)
{
cout<<*b;
delay(40);
}
while (pil != 3)
{
clrscr();
cout<<"\n-> Menu Utama <-"<<endl;
cout<<"\n1> Stack";
cout<<"\n2> Queue";
cout<<"\n3> Exit";
if (pil == 1)
{
while(pil != 4)
{
clrscr();
cout<<"\n>> Menu STACK <<"<<endl;
cout<<"\n1. PUSH STACK";
cout<<"\n4. Menu Utama";
if (pil == 1)
{
baru = data.masuk_stack();
}
if (pil == 2)
data.tampil_stack(atas);
if (pil == 3)

{
data.POP(&atas);
}
}
}
if (pil == 2)
{
while(pil != 4)
{
clrscr();
cout<<"\n>> Menu QUEUE <<"<<endl;
cout<<"\n1. INSERT_QUEUE LIST";
cout<<"\n2. LIHAT DATA LIST";
cout<<"\n3. DELETE_QUEUE LIST";
if (pil == 1)
{
baru=data.masuk_queue();
data.INSERT_QUEUE(&tail,&head,baru);
}
if (pil == 2)
data.tampil_queue(head);
if (pil == 3)
{
data.DELETE_QUEUE(&head,&tail);
}
}
}
}
}
=========================== SOAL 5
=======================
#include "iostream.h"
#include "stdlib.h"
#include "stdio.h"
#include "conio.h"
struct list
{
char nama[35];
char kode[10];
struct list * next;
};
typedef struct list node;
typedef node * pnode;

void TAMPIL(PNODE ATAS)

{
int x;
PNODE POS;
POS = ATAS;
cout<<"\nKode : ";
while(POS!=NULL)
{
cout<<POS->kode<<" - ";
POS=POS->next;
}
}
void PUSH(PNODE *ATAS,PNODE BARU)

{
if(*ATAS==NULL)
{
*ATAS = BARU;
}
else
{
BARU->next = *ATAS;
*ATAS = BARU;
}
}
void POP(PNODE *ATAS)

{
PNODE PH;
PH = *ATAS;
if(*ATAS==NULL)
{
}
else
{
if (PH->next==NULL)
{
*ATAS = NULL;
free(PH);
}
else
{
*ATAS = (*ATAS)->next;
free(PH);
}
}
}
PNODE MASUK(void)
{

PNODE BARU;
BARU=new(NODE);
cout<<"KODE : "; gets(BARU->kode);
BARU->next=NULL;
return(BARU);
}
void tampil(pnode atas)

{
int x;
pnode pos;
pos = atas;
cout<<"NEGARA : ";
while(pos!=NULL)
{
cout<<pos->nama<<" - ";
pos=pos->next;
}
}
void push(pnode *atas, pnode baru)

{
if(*atas==NULL)
{
*atas = baru;
}
else
{
baru->next = *atas;
*atas = baru;
}
}
void pop(pnode *atas)

{
pnode ph;
ph = *atas;
if(*atas==NULL)
{
}
else
{
if (ph->next==NULL)
{
*atas = NULL;
free(ph);
}
else
{

free(ph);
}
}
}
pnode masuk(void)
{
pnode baru;
baru=new(node);
cout<<"\nNEGARA : "; gets(baru->nama);
baru->next=NULL;
return(baru);
}
void main()
{
pnode atas=NULL;
pnode baru;
PNODE BARU;
PNODE ATAS=NULL;
int pil=1;
clrscr();
while(pil!=4)
{
cout<<"\n\n=======STACK=======";
cout<<"\n2. VIEW DATA STACK";
cout<<"\n4. EXIT";
cout<<"\nPilihan [1/2/3/4] : "; cin>>pil;
if (pil==1)
{
clrscr();
baru=masuk();
BARU=MASUK();
push(&atas,baru);
PUSH(&ATAS,BARU);
}
if (pil==2)
{
clrscr();
tampil(atas);
TAMPIL(ATAS);
}
if (pil==3)
{
clrscr();
pop(&atas);
POP(&ATAS);
}
}

}
=========================== SOAL 6
=======================
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
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<<"\nMenu:";
cout<<"\n1. Push";
cout<<"\n2. Pop";
cout<<"\n3. View";
cout<<"\n4. Exit";
cout<<"\nPilihan[1/2/3/4]:";
int pil;
cin>>pil;

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;
cout<<"\nMasukkan kode negara: ";
gets(baru->kode);
cout<<"\nMasukkan nama negara: ";
gets(baru->nama);
if(head==NULL){
head=baru;
head->next=NULL;
}
else{
baru->next=head;
head=baru;
}
}
void negara::pop(){
}
void negara::view(){
simpul *lihat;
lihat=head;
while(lihat!=NULL){
cout<<"\nKode Negara:"<<lihat->kode;
cout<<"\nNama Negara:"<<lihat->nama;
lihat=lihat->next;
}
getch();
}
void main(){
clrscr();
negara stack;
getch();
}
=========================== SOAL 7
=======================
#include <stdio.h>
#include <malloc.h>
#include <string.h>
//----------------------

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;

//----------------------
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;
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");
}
}

//----------------------
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 <stdio.h>
#include <string.h>
//----------------------
struct nilaiMatKul{
char nim[10];
char nama[50];
float nilai;
};
struct stack{
int top;
nilaiMatKul data[10];
};
//----------------------
void createEmpty(stack *S){

(*S).top = -1;
}
//----------------------
bool isEmpty(stack S){
bool hasil = false;

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;

}
}
}
//----------------------
void printStack(stack S){

if(S.top != -1){
printf("------isi stack------\n");
int i;
for(i=S.top;i>=0;i--){
printf("====================\n");
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 <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <io.h>
#define MAX_CITY 30
#define MAX_STATE 30
#define MAX_ZIP 5
void 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' to
quit>>", MAX_ZIP);
gets(new_ptr->zip_code);
new_ptr->zip_code[MAX_ZIP] = '\0';
if (strcmp(new_ptr->zip_code, "q") != 0) {

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' to
print 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;

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 <stdio.h>
# include <stdlib.h>
struct node
{
int data;
struct node *link;
};

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

{
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
/* creates new node
using data value
passed 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);

printf("The value poped is %d\n",value);

printf("Enter 1 to pop an element\n");
scanf("%d",&n);
}
scanf("%d",&n);
} while(n == 1);
}
=========================== SOAL 11
=======================
#include <stdio.h>
#include <conio.h>
//deklarasi 'STACK' dengan struct dan array

typedef struct STACK
{
int data[5];
int atas;
};
//deklarasi variabel 'tumpuk' dari struct

STACK tumpuk;
void main()
{
clrscr();
int pilihan,baru,i;
//inisialisasi awal
tumpuk.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;

}
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<=tumpuk.atas; i++)
{
printf("%d
",tumpuk.data[i]);
}
getch();
}
break;
}
default:
{
printf("\nTidak ada dalam pilihan");
}
}
}while(pilihan>=1 && pilihan<=3);
getch();
}
=========================== SOAL 12
=======================
#include <stdio.h>
#include <conio.h>
#define MAX 8
typedef struct{

int data[MAX];
} Stack;
Stack stack;
int top[2];
void Create(){
//kosongkan stack
top[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[0];i++){
printf("%d ",stack.data[i]);
}
printf("\nStack 2\n");
for(i=MAX-1;i>=top[1];i--){
}
}
void Clear(int noStack){
if(noStack==1) top[0]=-1; else
if(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]++; else
if(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;
} else
if(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]--; else
if(noStack==2) top[1]++;

}
return e;
}
void Clear(int noStack){
if(noStack==1) top[0]=-1; else
if(noStack==2) top[1]=MAX;
}
void Tampil(){
int i;
printf("Stack 1\n");
for(i=0;i<=top[0];i++){
}
printf("\nStack 2\n");
for(i=MAX-1;i>=top[1];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;
printf("Elemen yang keluar : %d",Pop(no));
break;
case 3: Tampil();
break;
Clear(no);
break;
}
getch();
} while(pil!=5);
}
=========================== SOAL 13
=======================
#include <stdlib.h>

#include <conio.h>
struct list{
int bil;
struct list * next;
};
void tampil(PNODE atas){

PNODE pos;
pos = atas;
while(pos!=NULL){
pos=pos->next;
}
}
void PUSH(PNODE *atas, PNODE baru){

if(*atas==NULL){
*atas = baru;
}else{
baru->next = *atas;
*atas = baru;
}
}
void POP(PNODE *atas){

PNODE PH;
PH = *atas;
if(*atas==NULL){
}else{
*atas = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE masuk(void){
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){

PNODE atas=NULL;
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=masuk();
PUSH(&atas, baru);
}
if (pil==2)
tampil(atas);
if (pil==3){
POP(&atas);
}
}
}
=========================== SOAL 14
=======================
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
class elemen
{
struct list
{
int bil;
struct list *next;
};
public:


};


{
PNODE pos;
pos = atas;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if (*atas == NULL)
{
*atas = baru;
}
else
{
*atas = baru;
}
}

{
PNODE PH;
PH = *atas;
if(*atas == NULL)
{
}
else
{
{
*atas = NULL;
free(PH);
}
else
{
free(PH);
}
}
getch();
}


{
PNODE baru;
return (baru);
getch();
}

{
PNODE pos;
pos = head;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if(*tail == NULL)
{
*head = baru;
*tail = baru;
}
else
{
*tail = baru;
}
}

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

*tail = NULL;
free(PH);
}
else
{
free(PH);
}
}
getch();
}

{
PNODE baru;
return(baru);
getch();
}
void main()
{
PNODE atas = NULL;
PNODE baru;
int pil=1, x, m;
char *b = "Í";
elemen data;
clrscr();
m=strlen(a);
gotoxy (20,20);
for (x=0; x<m; x++)
{
cout<<*(a+x);
delay(200);
}
gotoxy (3,24);
for (x=0; x<75; x++)
{
cout<<*b;
delay(40);
}
while (pil != 3)
{
clrscr();


cout<<"\n1> Stack";
cout<<"\n2> Queue";
cout<<"\n3> Exit";
if (pil == 1)
{
while(pil != 4)
{
clrscr();
if (pil == 1)
{
}
if (pil == 2)
if (pil == 3)
{
data.POP(&atas);
}
}
}
if (pil == 2)
{
while(pil != 4)
{
clrscr();
if (pil == 1)
{
}
if (pil == 2)

if (pil == 3)
{
}
}
}
}
}
=========================== SOAL 15
=======================
#include <stdlib.h>
#include <conio.h>
class elemen{
struct list{
int bil;
struct list * next;
};
public:

PNODE masuk(void);
};
void elemen::tampil(PNODE atas){

PNODE pos;
pos = atas;
while(pos!=NULL){
pos=pos->next;
}
}
void elemen::PUSH(PNODE *atas, PNODE baru){

if(*atas==NULL){
*atas = baru;
}else{
baru->next = *atas;
*atas = baru;
}
}
void elemen::POP(PNODE *atas){

PNODE PH;

PH = *atas;
if(*atas==NULL){
}else{
*atas = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE atas=NULL;
PNODE baru;
int pil=1;
elemen data;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=data.masuk();
}
if (pil==2)
data.tampil(atas);
if (pil==3){
data.POP(&atas);
}
}
}
=========================== SOAL 16
=======================
=========================== SOAL 17
=======================

=========================== 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
=======================

=========================== 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
=======================

=========================== SOAL 49
=======================
=========================== SOAL 50
=======================
===========================================
================
Queue
Queue (Antrian) adalah list linier yang :
1. Dikenali elemen pertama (Head) dan elemen terakhirnya (Tail)
2. Aturan penyisipan dan penghapusan elemennya disefinisikan
sebagai 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 <stdio.h>
#include <conio.h>
#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;

int IsFull()
{
if(antrian.tail==MAX-1)
return 1;
else
return 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++;
}
}
int Dequeue()
{
int i;
int e = antrian.data[antrian.head];
for(i=antrian.head;i<=antrian.tail-1;i++)
{
antrian.data[i] = antrian.data[i+1];
}
antrian.tail--;
return e;
}
void Clear()
{
printf("data clear");
}
void Tampil()
{
if(IsEmpty()==0)
{
for(int i=antrian.head;i<=antrian.tail;i++)
{
printf("%d ",antrian.data[i]);
}

}
else printf("data kosong!\n");
}
void main()
{
int pil;
char kota[MAX];
Create();
do
{
clrscr();
printf("1. Enqueue\n");
printf("2. Dequeue\n");
switch(pil)
{
case 1:
{
cout<<"Kota = ";
gets(kota);
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 2
=======================
class element
{
public:
int value;
element* next;
};//class element
class Queue

{
public:
int size;
element* head;
element* tail;
Queue()
{
size=0;
head=NULL;
tail=NULL;
}//default constructor
void Enqueue(int);
void Dequeue();
int isEmpty();
int getQueueSize();
void printQueueSize();
void printQueueElements();
void printQueueMenu();
};
void Queue::Enqueue(int ele)

{
if(head==NULL) // first element
{
head=new element;
tail=head; //head==tail if one element
head->value=ele;
head->next=NULL;
}
else
{
tail->next=new element;
tail->next->value=ele;
tail->next->next=NULL;
cout<<tail->next->value<<endl;
tail=tail->next;
}
size++;
//printQueueElements();
}
void Queue::Dequeue()
{
if(getQueueSize()==0)
return;
else if(head==tail)
{
head=NULL;
}
else

{
element *curr,*prev; //remove the first element inserted and
curr=head; //point the head to next element
head=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<<"\nThe Size of the Queue:"<<size<<"\n";
}//print the Queue size
void Queue::printQueueElements()
{
element* curr2;
curr2= head;
cout<<"\n-----\n";
cout<<"Queue\n";
cout<<"-----\n";
cout<<"size:"<<getQueueSize()<<endl;
while(curr2!=NULL)
{
cout<<" |"<<curr2->value<<"|";
curr2=curr2->next;
}
cout<<endl;
}// print the Queue
void Queue::printQueueMenu()
{
cout<<"Welcome to Queue \n";
cout<<"1.Enqueue an element\n";
cout<<"2.Dequeue an element\n";
cout<<"3.Display Queue\n";
cout<<"4.Size Of Queue\n";
cout<<"5.Exit\n";
}

void main()
{
Queue qt;
qt.printQueueMenu();
char Option=0;
int val;
while(1)
{
qt.printQueueMenu();
cin>>Option;
switch(Option)
{
case '1':
cout<<"Enter a Number \n";
cin>>val;
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
=======================
#include <stdlib.h>
#include <conio.h>
struct list{
int bil;
struct list * next;
};
void tampil(PNODE head){

PNODE pos;
pos = head;
while(pos!=NULL){
pos=pos->next;

}
}
void INSERT_QUEUE(PNODE *tail,PNODE *head, PNODE baru){

if(*tail==NULL){
*head = baru;
*tail = baru;
}else{
(*tail)->next = baru;
*tail = baru;
}
}
void DELETE_QUEUE(PNODE *head, PNODE *tail){

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{
*head = (*head)->next;
free(PH);
}
}
}
PNODE masuk(void){
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE head=NULL,tail=NULL;
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n\n1. INSERT_QUEUE LIST";
cout<<"\n4. EXIT";
if (pil==1){
baru=masuk();
INSERT_QUEUE(&tail,&head,baru);
}

if (pil==2)
tampil(head);
if (pil==3){
DELETE_QUEUE(&head,&tail);
}
}
}
=========================== SOAL 4
=======================
#include <stdlib.h>
#include <conio.h>
struct list{
int bil;
struct list * next;
};

PNODE pos;
pos = head;
while(pos!=NULL){
pos=pos->next;
}
}

if(*tail==NULL){
*head = baru;
*tail = baru;
}else{
*tail = baru;
}
}

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{

free(PH);
}
}
}
PNODE masuk(void){
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=masuk();
}
if (pil==2)
tampil(head);
if (pil==3){
}
}
}
=========================== SOAL 5
=======================
#include <stdlib.h>
#include <conio.h>
class elemen{
struct list{
int bil;
struct list * next;
};
public:
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;
while(pos!=NULL){
pos=pos->next;
}
}
void elemen::INSERT_QUEUE(PNODE *tail,PNODE *head, PNODE baru){

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

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE baru;

int pil=1;
elemen data;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=data.masuk();
}
if (pil==2)
data.tampil(head);
if (pil==3){
}
}
}
=========================== SOAL 6
=======================
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
class elemen
{
struct list
{
int bil;
struct list *next;
};
public:


};


{
PNODE pos;
pos = atas;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if (*atas == NULL)
{
*atas = baru;
}
else
{
*atas = baru;
}
}

{
PNODE PH;
PH = *atas;
if(*atas == NULL)
{
}
else
{
{
*atas = NULL;
free(PH);
}
else
{
free(PH);
}
}
getch();
}


{
PNODE baru;
return (baru);
getch();
}

{
PNODE pos;
pos = head;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if(*tail == NULL)
{
*head = baru;
*tail = baru;
}
else
{
*tail = baru;
}
}

{
PNODE PH;
PH = *head;
if(*head == NULL)
{
}
else
{
{
*head = NULL;
*tail = NULL;

free(PH);
}
else
{
free(PH);
}
}
getch();
}

{
PNODE baru;
return(baru);
getch();
}
void main()
{
PNODE atas = NULL;
PNODE baru;
int pil=1, x, m;
char *b = "Í";
elemen data;
clrscr();
m=strlen(a);
gotoxy (20,20);
for (x=0; x<m; x++)
{
cout<<*(a+x);
delay(200);
}
gotoxy (3,24);
for (x=0; x<75; x++)
{
cout<<*b;
delay(40);
}
while (pil != 3)
{
clrscr();

cout<<"\n1> Stack";
cout<<"\n2> Queue";
cout<<"\n3> Exit";
if (pil == 1)
{
while(pil != 4)
{
clrscr();
if (pil == 1)
{
}
if (pil == 2)
if (pil == 3)
{
data.POP(&atas);
}
}
}
if (pil == 2)
{
while(pil != 4)
{
clrscr();
if (pil == 1)
{
}
if (pil == 2)

if (pil == 3)
{
}
}
}
}
}
=========================== SOAL 7
=======================
#include <stdio.h>
#include <malloc.h>
#include <string.h>
//----------------------
struct nilaiMatKul{
char nim[10];
char nama[50];
float nilai;
};
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;
}
//----------------------

int countElement(queue Q){

int hasil = 0;
if(Q.first != NULL){
/* queue tidak kosong */
elemen *elmt;
/* inisialisasi */
elmt = Q.first;
/* 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);
}

//----------------------
void printQueue(queue Q){

if(Q.first != NULL){
printf("------isi queue------\n");
elemen *elmt = Q.first;
int i = 1;
printf("====================\n");
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 queue kosong */
printf("queue kosong\n");
}
}
//----------------------
int main(){
struct queue Q;
createEmpty(&Q);
printQueue(Q);
printf("=================\n");
add("13507701", "Imam", 64.75, &Q);
add("13507702", "Cinta", 75.11, &Q);
add("13507703", "Jasmine", 84.63, &Q);
printQueue(Q);
printf("=================\n");
del(&Q);
del(&Q);
printQueue(Q);
printf("=================\n");
return 0;

=========================== SOAL 8
=======================
#include <stdio.h>
#include <string.h>
//----------------------
struct nilaiMatKul{
char nim[10];
char nama[50];
float nilai;
};
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 ){

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).last;i++){
strcpy((*Q).data[i-1].nim, (*Q).data[i].nim);
strcpy((*Q).data[i-1].nama, (*Q).data[i].nama);
(*Q).data[i-1].nilai = (*Q).data[i].nilai;
}
(*Q).last = (*Q).last - 1;
}
}
//----------------------
void printQueue(queue Q){

if(Q.first != -1){
printf("------isi queue------\n");
int i;
for(i=Q.last;i>=Q.first;i--){
printf("====================\n");
printf("nim : %s\n", Q.data[i].nim);
printf("nama : %s\n", Q.data[i].nama);

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 <stdio.h>
#define MAX 10 /* The maximum size of the queue */
#include <stdlib.h>
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);
}

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);
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);
scanf("%d",&n);
}
scanf("%d",&n);
} while(n == 1);
}
===================== SOAL 10 Circular Queue
==================
#include <stdio.h>
#define MAX 10 /* The maximum size of the queue */
#include <stdlib.h>
void insert(int queue[], int *rear, int front, int value)

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

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
{
scanf("%d",&value);
insert(queue,&rear,front,value);
scanf("%d",&n);
} while(n == 1);

scanf("%d",&n);
while( n == 1)
{
delete(queue,&front,rear,&value);
scanf("%d",&n);
}
scanf("%d",&n);
} while(n == 1);
}
=============== SOAL 11 Queue Dengan Link List
================
# include <stdio.h>

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

{
struct node *temp;
/* creates new node
using data value
if(temp==NULL)
{
exit(0);
}
temp->data = value;
temp->link=NULL;
if(*rear == NULL)
{
*rear = temp;
*front = *rear;
}
else
{
(*rear)->link = temp;
*rear = temp;
}
}
void delete(struct node **front, struct node **rear, int *value)

{
struct node *temp;
if((*front == *rear) && (*rear == NULL))
{
printf(" The queue is empty cannot delete Error\n");
exit(0);
}
*value = (*front)->data;
temp = *front;
*front = (*front)->link;
if(*rear == temp)
*rear = (*rear)->link;
free(temp);
}
void main()
{
struct node *front=NULL,*rear = NULL;
int n,value;

do
{
do
{
scanf("%d",&value);
insert(&front,&rear,value);
scanf("%d",&n);
} while(n == 1);

scanf("%d",&n);
while( n == 1)
{
delete(&front,&rear,&value);
scanf("%d",&n);
}
scanf("%d",&n);
} while(n == 1);
}
==================== SOAL 12 Priority Queue
===================
# include <stdio.h>
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;
/* creates new node using data value
if(temp==NULL)
{
exit(0);
}
temp->data = value;
temp->priority = priority;
temp->link=NULL;
if(*rear == NULL) /* This is the first node */
{
*rear = temp;

*front = *rear;
}
else
{
if((*front)->priority < priority)
/* the element to be inserted has
highest priority hence should
be the first element*/
{
temp->link = *front;
*front = temp;
}
else
if( (*rear)->priority > priority)
/* the element to be inserted has
lowest priority hence should
be 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;

int n,value, priority;

do
{
do
{
printf("Enter the element to be inserted and its
priority\n");
scanf("%d %d",&value,&priority);
insert(&front,&rear,value,priority);
scanf("%d",&n);
} while(n == 1);

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);
scanf("%d",&n);
}
scanf("%d",&n);
} while( n == 1)
}
=========================== SOAL 13
=======================
#include <stdio.h>
#include <conio.h>
#define MAX 8
typedef struct{
int data[MAX];
int head;
int tail;
} Queue;
Queue antrian;
void Create(){
}
int IsEmpty(){
return 1;
else
return 0;
}
int IsFull(){
if(antrian.tail==MAX-1) return 1;
else return 0;
}

void Enqueue(int data){

if(IsEmpty()==1){
void Tampil(){
if(IsEmpty()==0){
for(int i=antrian.head;i<=antrian.tail;i++){
}
}else printf("data kosong!\n");
}
} else
if(IsFull()==0){
antrian.tail++;
}
}
int Dequeue(){
int i;
for(i=antrian.head;i<=antrian.tail-1;i++){
}
antrian.tail--;
return e;
}
void Clear(){
}
void Tampil(){
if(IsEmpty()==0){
for(int i=antrian.head;i<=antrian.tail;i++){
}
}else printf("data kosong!\n");
}
void main(){
int pil;
int data;
Create();
do{
clrscr();
switch(pil){
case 1: printf("Data = ");scanf("%d",&data);

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 <LTime.h>
#include <Queue.h>
#include <dos.h>
#include <stdlib.h>
int main()
{
int k;
Queue timeLine;
cout << "\nSampling";
for( int i = 0; i < 7; i++ )
{
struct time snapShot;
gettime( &snapShot );
Time sample( snapShot.ti_hour,
snapShot.ti_min,
snapShot.ti_sec,
snapShot.ti_hund );
timeLine.put ( *(new Time( sample )) );
cout << ".";
randomize();
k = rand();
for(int j = 0; j < k; ++j ) // Delay loop
{
cout << "";
}
}
cout << "\nThe timing samples are:\n\n";
while( !timeLine.isEmpty() )
{
Time& sampleTime = (Time&)timeLine.get();
cout << sampleTime << "\n";
delete &sampleTime;
}
return 0;
}

=========================== SOAL 15
=======================
#include <stdio.h>
#include <conio.h>
#define MAX 8
typedef struct
{
char data[MAX];
int head;
int tail;
}Queue;
Queue antrian;
void Create()
{
}
int IsEmpty()
{
return 1;
else
return 0;
}
int IsFull()
{
if(antrian.tail==MAX-1)
return 1;
else
return 0;
}
void Enqueue(int data)

{
if(IsEmpty()==1)
{
}
else if(IsFull()==0)
{
antrian.tail++;
}
}

int Dequeue()
{
int i;
for(i=antrian.head;i<=antrian.tail-1;i++)
{
}
antrian.tail--;
return e;
}
void Clear()
{
}
void Tampil()
{
if(IsEmpty()==0)
{
for(int i=antrian.head;i<=antrian.tail;i++)
{
}
}
else printf("data kosong!\n");
}
void main()
{
int pil;
char kota[MAX];
Create();
do
{
clrscr();
switch(pil)
{
case 1:
{
cout<<"Kota = ";
gets(kota);

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
=======================
#include <stdlib.h>
#include <conio.h>
class elemen{
struct list{
char kota[30];
struct list * next;
};
public:
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){


}else{
*head = NULL;
free(PH);
}else{
free(PH);
}
}
}

PNODE pos;
pos = head;
if(pos==NULL){
cout<<"\n\nLIST KOSONG.";
}else{
cout<<"\n\nDaftar Kota : ";
while(pos!=NULL){
cout<<pos->kota<<", ";
pos=pos->next;
} cout<<"\b\b.";
}
}

if(*tail==NULL){
*head = baru;
*tail = baru;
}else{
*tail = baru;
}
}

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{
free(PH);
}
}

PNODE baru;
cout<<"\nKota : ";cin>>baru->kota;
baru->next=NULL;
return(baru);
}
void main(){
PNODE baru;
int pil=1,cari=1;
clrscr();
while(pil!=4){
clrscr();
cout<<"\n4. EXIT";
if (pil==1){
cout<<"\n\n1. Insert Queue";
cout<<"\n2. Insert Stack";
cout<<"\nPilih ? ";
cin>>cari;
baru=data.masuk();
if(cari==1)
{
}
if(cari==2){
data.PUSH(&head, baru);
}
}
if (pil==2)
data.tampil(head);
getch();
if (pil==3){
cout<<"\n\n1. Delete Queue";
cout<<"\n2. Delete stack";
cout<<"\nPilih ? ";
cin>>cari;
if(cari==1){
}
if(cari==2){
data.POP(&head);
}
}

}
=========================== SOAL 17
=======================
#include <stdlib.h>
#include <conio.h>
struct list{
int bil;
struct list * next;
};

PNODE pos;
pos = head;
while(pos!=NULL){
pos=pos->next;
}
}

if(*tail==NULL){
*head = baru;
*tail = baru;
}else{
*tail = baru;
}
}

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE masuk(void){

PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE baru;
int pil=1;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=masuk();
}
if (pil==2)
tampil(head);
if (pil==3){
}
}
}
=========================== SOAL 18
=======================
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
class elemen
{
struct list
{
int bil;
struct list *next;
};
public:



};

{
PNODE pos;
pos = atas;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if (*atas == NULL)
{
*atas = baru;
}
else
{
*atas = baru;
}
}

{
PNODE PH;
PH = *atas;
if(*atas == NULL)
{
}
else
{
{
*atas = NULL;
free(PH);
}

else
{
free(PH);
}
}
getch();
}

{
PNODE baru;
return (baru);
getch();
}

{
PNODE pos;
pos = head;
while(pos != NULL)
{
pos = pos -> next;
}
getch();
}

{
if(*tail == NULL)
{
*head = baru;
*tail = baru;
}
else
{
*tail = baru;
}
}

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

{
}
else
{
{
*head = NULL;
*tail = NULL;
free(PH);
}
else
{
free(PH);
}
}
getch();
}

{
PNODE baru;
return(baru);
getch();
}
void main()
{
PNODE atas = NULL;
PNODE baru;
int pil=1, x, m;
char *b = "Í";
elemen data;
clrscr();
m=strlen(a);
gotoxy (20,20);
for (x=0; x<m; x++)
{
cout<<*(a+x);
delay(200);
}
gotoxy (3,24);
for (x=0; x<75; x++)

{
cout<<*b;
delay(40);
}
while (pil != 3)
{
clrscr();
cout<<"\n1> Stack";
cout<<"\n2> Queue";
cout<<"\n3> Exit";
if (pil == 1)
{
while(pil != 4)
{
clrscr();
if (pil == 1)
{
}
if (pil == 2)
if (pil == 3)
{
data.POP(&atas);
}
}
}
if (pil == 2)
{
while(pil != 4)
{
clrscr();

if (pil == 1)
{
}
if (pil == 2)
if (pil == 3)
{
}
}
}
}
}
=========================== SOAL 19
=======================
#include <stdlib.h>
#include <conio.h>
class elemen{
struct list{
int bil;
struct list * next;
};
public:

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

PNODE pos;
pos = head;
while(pos!=NULL){
pos=pos->next;
}
}

if(*tail==NULL){

*head = baru;
*tail = baru;
}else{
*tail = baru;
}
}

PNODE PH;
PH = *head;
if(*head==NULL){
}else{
*head = NULL;
*tail = NULL;
free(PH);
}else{
free(PH);
}
}
}
PNODE baru;
baru->next=NULL;
return(baru);
}
void main(){
PNODE baru;
int pil=1;
elemen data;
clrscr();
while(pil!=4){
cout<<"\n4. EXIT";
if (pil==1){
baru=data.masuk();
}
if (pil==2)
data.tampil(head);
if (pil==3){

}
}
}
=========================== 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
=======================

=========================== 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
=======================

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


Struktur Data - 100 Soal Stack & Queue

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Struktur Data - 100 Soal Stack & Queue

Enviado por

Direitos autorais:

Formatos disponíveis

1 100 SOAL & JAWABAN STACK DAN QUEUE

Contoh Soal Stack

Imam Ciptarjo – 6307130

void tampil(PNODE atas){

void PUSH(PNODE *atas, PNODE baru){

void POP(PNODE *atas){

Imam Ciptarjo – 6307130

typedef struct list NODE;

typedef NODE * PNODE;

Imam Ciptarjo – 6307130

void brg::PUSH(PNODE *atas, PNODE baru){

void brg::POP(PNODE *atas){

Imam Ciptarjo – 6307130

void tampil(PNODE atas);

void elemen::tampil(PNODE atas){

void elemen::PUSH(PNODE *atas, PNODE baru){

Imam Ciptarjo – 6307130

void elemen::POP(PNODE *atas){

Imam Ciptarjo – 6307130

void tampil_stack (PNODE atas);

void tampil_queue (PNODE head);

void elemen :: tampil_stack (PNODE atas)

void elemen :: PUSH (PNODE *atas, PNODE baru)

Imam Ciptarjo – 6307130

void elemen :: POP (PNODE *atas)

PNODE elemen :: masuk_stack (void)

void elemen :: tampil_queue (PNODE head)

void elemen :: INSERT_QUEUE (PNODE *tail,PNODE *head, PNODE baru)

Imam Ciptarjo – 6307130

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

PNODE elemen :: masuk_queue (void)

Imam Ciptarjo – 6307130

Imam Ciptarjo – 6307130

Imam Ciptarjo – 6307130

void TAMPIL(PNODE ATAS)

void PUSH(PNODE *ATAS,PNODE BARU)

void POP(PNODE *ATAS)

Imam Ciptarjo – 6307130

void tampil(pnode atas)

void push(pnode *atas, pnode baru)

void pop(pnode *atas)

Imam Ciptarjo – 6307130

Imam Ciptarjo – 6307130

Imam Ciptarjo – 6307130

Imam Ciptarjo – 6307130

void createEmpty(stack *S){

bool isEmpty(stack S){

int countElement(stack S){

Imam Ciptarjo – 6307130

void push(char nim[], char nama[], float nilai, stack *S ){

void pop(stack *S){

void printStack(stack S){

Imam Ciptarjo – 6307130

push("13507701", "Imam", 64.75, &S);

void createEmpty(stack *S){

bool isEmpty(stack S){

bool hasil = false;

Imam Ciptarjo – 6307130

bool isFull(stack S){

void push(char nim[], char nama[], float nilai, stack *S ){

void pop(stack *S){

Imam Ciptarjo – 6307130

void printStack(stack S){

void elemen :: INSERT_QUEUE (PNODE tail,PNODE head, PNODE baru)

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

struct node push(struct node p, int value)

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

void elemen :: INSERT_QUEUE (PNODE tail,PNODE head, PNODE baru)

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

void INSERT_QUEUE(PNODE tail,PNODE head, PNODE baru){

void DELETE_QUEUE(PNODE head, PNODE tail){

void INSERT_QUEUE(PNODE tail,PNODE head, PNODE baru){

void DELETE_QUEUE(PNODE head, PNODE tail){

void INSERT_QUEUE(PNODE tail,PNODE head, PNODE baru);