PERCOBAAN 1

 SCREENSHOT PROGRAM

 SCREENSHOT OUTPUT

 ANALISA
Pada program ini, terdapat definisi tipe data ItemType yang merupakan tipe data dari
elemenelemen yang akan disimpan di dalam stack. Kemudian, terdapat struktur Stack
yang berisi array Item dan Count yang digunakan untuk menyimpan data dan
menunjukkan indeks data paling atas dari stack.

Selanjutnya, terdapat beberapa fungsi operasi stack seperti InitializeStack, Empty, Full,
Push, dan Pop. Fungsi InitializeStack digunakan untuk menginisialisasi stack dengan
menetapkan Count menjadi 0. Fungsi Empty dan Full digunakan untuk mengecek apakah
stack kosong atau penuh. Fungsi Push digunakan untuk menambahkan elemen ke dalam
stack. Sedangkan, fungsi Pop digunakan untuk mengambil elemen paling atas dari stack.

Di dalam fungsi main, terdapat inisialisasi stack dengan menggunakan fungsi

InitializeStack dan penggunaan perulangan for untuk memasukkan elemen ke dalam
stack dengan menggunakan fungsi Push. Selanjutnya, terdapat perulangan for lainnya
untuk mengeluarkan elemen dari stack dengan menggunakan fungsi Pop.

Namun, terdapat kesalahan pada program ini yaitu pada saat input elemen ke dalam
stack, program tidak membaca input dari pengguna dengan benar. Pada baris kode
scanf("input");, seharusnya menggunakan %d untuk membaca integer dari pengguna.
Sehingga, seharusnya baris kode tersebut ditulis seperti berikut: scanf("%d", &input);.
Baris 1: Mengimpor library standard input/output pada bahasa pemrograman C.

Baris 2: Mendefinisikan konstanta MAXSTACK dengan nilai 5 menggunakan

praprosesor #define.

Baris 3: Mendefinisikan tipe data ItemType sebagai int.

Baris 5-9: Mendefinisikan struktur Stack yang berisi array Item dengan ukuran
MAXSTACK dan variabel Count untuk menunjukkan indeks data paling atas pada stack.

Baris 11-14: Mendefinisikan fungsi InitializeStack yang menerima parameter pointer ke

Stack dan menginisialisasi variabel Count menjadi 0.

Baris 16-18: Mendefinisikan fungsi Empty yang menerima parameter pointer ke Stack
dan mengembalikan nilai 1 jika Count sama dengan 0 atau 0 jika tidak sama dengan 0.

Baris 20-22: Mendefinisikan fungsi Full yang menerima parameter pointer ke Stack dan
mengembalikan nilai 1 jika Count sama dengan MAXSTACK atau 0 jika tidak sama
dengan MAXSTACK.
 Baris 24-31: Mendefinisikan fungsi Push yang menerima parameter ItemType x dan
pointer ke Stack S. Fungsi ini menambahkan elemen x ke dalam stack S jika Count tidak
sama dengan MAXSTACK. Jika
Count sama dengan MAXSTACK, maka fungsi akan menampilkan pesan bahwa stack
penuh dan data tidak dapat dimasukkan.

Baris 33-40: Mendefinisikan fungsi Pop yang menerima parameter pointer ke Stack S dan
mengembalikan elemen paling atas pada stack S jika Count tidak sama dengan 0. Jika
Count sama dengan 0, maka fungsi akan menampilkan pesan bahwa stack masih kosong.

Baris 42-52: Mendefinisikan fungsi main yang akan dijalankan saat program di-run. Di
sini, variabel i dan input di-deklarasikan sebagai integer. Kemudian, stack tumpukan di-
deklarasikan menggunakan tipe data Stack. Fungsi InitializeStack dipanggil untuk
menginisialisasi stack tumpukan.

Baris 44-48: Perulangan for digunakan untuk memasukkan elemen ke dalam stack
menggunakan fungsi Push. Pengguna diminta untuk memasukkan isi stack ke-i
menggunakan fungsi printf dan scanf.

Baris 50-56: Perulangan for digunakan untuk mengambil elemen dari stack menggunakan
fungsi Pop dan menampilkan isi stack ke-i menggunakan fungsi printf. Perulangan ini
dimulai dari nilai MAXSTACK dan berakhir saat i sama dengan 0.

PERCOBAAN 2

 SCREENSHOT PROGRAM
 SCREENSHOT OUTPUT

 ANALISA
#include <stdio.h>
#include <conio.h>
#define max 5
typedef struct {
int top;
int data[max+1];
}stack;
stack tumpukan;
void createEmpty();
int IsEmpty();
int IsFull();
void push(int x);
void pop();
main(){
int lagi;
int input;
int pilih;
createEmpty();
pilih = 0;
while (pilih != 5){
puts(":::::::::::::::::::::::::::::::::::");
printf(" MENU UTAMA\n");
puts(":::::::::::::::::::::::::::::::::::\n");
puts("1: Cek kondisi Stack");
puts("2: Tambah data (Push)");
puts("3: Keluarkan isi stack (Pop)");
puts("4: Kosongkan stack");
puts("5: Keluar\n");
printf("Pilihan Anda: ");
scanf("%d",&pilih);
switch(pilih){
case 1:
if (IsEmpty() == 1)
puts("Stack masih kosong\n");
else if ((IsEmpty() == 0) && (IsFull() == 0))
puts("Stack sudah terisi (belumpenuh)\n");
else
puts("Stack sudah penuh");
break;
case 2:
if (IsFull() == 1)
puts("Stack Penuh.");
else
{
printf("Masukkan data: ");
scanf("%d",&input);
push(input);
printf("Top baru:%d\n",tumpukan.data[tumpukan.top]);
printf("IsFull: %d\n",IsFull());
printf("IsEmpty: %d\n",IsEmpty());
}
break;
case 3:
printf("Top yang dikeluarkan bernilai: %d\n",tumpukan.data[tumpukan.top]);
pop();
break;
case 4:
while (IsEmpty() == 0)
{
printf("Top yang dikeluarkan bernilai:%d \n",tumpukan.data[tumpukan.top]);
pop();
}
puts("Stack sudah kosong");
break;
case 5:
puts("---Good Bye---");
break;
}
}
}
void createEmpty(){
tumpukan.top = 0;
}
void push(int x){
tumpukan.top = tumpukan.top + 1;
tumpukan.data[tumpukan.top] = x;
}
void pop(){
tumpukan.top = tumpukan.top - 1;
}
int IsEmpty(){
if (tumpukan.top == 0)
return 1;
else
return 0;
}
int IsFull(){
if (tumpukan.top == max)
return 1;
else
return 0;
}

Program ini merupakan implementasi dari struktur data stack menggunakan bahasa
pemrograman C.

Pada program ini, terdapat beberapa fungsi dan prosedur yang digunakan dalam
implementasi stack, yaitu:

Fungsi createEmpty() untuk membuat stack kosong.

Fungsi IsEmpty() untuk mengecek apakah stack kosong atau tidak.
Fungsi IsFull() untuk mengecek apakah stack sudah penuh atau belum.
Prosedur push() untuk menambahkan data ke dalam stack.
Prosedur pop() untuk mengeluarkan data dari stack.
Selain itu, pada program ini terdapat sebuah menu utama yang menampilkan beberapa
pilihan aksi yang dapat dilakukan pada stack, yaitu:

Pilihan 1 untuk mengecek kondisi stack, apakah kosong, terisi (belum penuh), atau sudah
penuh.
Pilihan 2 untuk menambahkan data ke dalam stack.
Pilihan 3 untuk mengeluarkan data dari stack.
Pilihan 4 untuk mengosongkan seluruh isi stack.
Pilihan 5 untuk keluar dari program.
Dalam implementasi program ini, stack direpresentasikan dengan menggunakan struktur
data stack yang memiliki dua variabel, yaitu top dan data. Variabel top menyimpan
indeks data teratas pada stack, sedangkan variabel data menyimpan nilai dari setiap
elemen pada stack.

Program ini diawali dengan membuat stack kosong menggunakan fungsi createEmpty().
Selanjutnya, program akan menampilkan menu utama dan meminta pengguna untuk
memilih aksi yang ingin dilakukan pada stack.

Pilihan 1 akan mengecek kondisi stack dengan memanggil fungsi IsEmpty() dan IsFull(),
kemudian menampilkan pesan sesuai kondisi stack yang ditemukan.
 Pilihan 2 akan mengecek apakah stack sudah penuh atau belum dengan memanggil fungsi
IsFull(). Jika stack belum penuh, program akan meminta pengguna untuk memasukkan
nilai data yang ingin ditambahkan ke dalam stack dengan menggunakan fungsi push().
Setelah itu, program akan menampilkan nilai dari elemen teratas pada stack (Top baru),
status stack (IsFull dan IsEmpty), dan kembali ke menu utama.

Pilihan 3 akan mengeluarkan data dari stack dengan memanggil prosedur pop(). Setelah
itu, program akan menampilkan nilai dari elemen teratas pada stack yang telah dihapus
(Top yang dikeluarkan bernilai), dan kembali ke menu utama.

Pilihan 4 akan mengosongkan seluruh isi stack dengan menggunakan prosedur pop()
secara berulang hingga stack kosong. Setelah itu, program akan menampilkan pesan
bahwa stack sudah kosong, dan kembali ke menu utama.

Pilihan 5 akan keluar dari program dengan menampilkan pesan Good Bye.

LATIHAN 1

 SCREENSHOT PROGRAM

 SCREENSHOT OUTPUT
 ANALISA
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STACK_SIZE 100

char stack[MAX_STACK_SIZE];
int top = -1;

void push(char c) {
if (top >= MAX_STACK_SIZE - 1) {
printf("Stack Overflow\n");
exit(1);
} else {
top++;
stack[top] = c;
}
}

char pop() {
char c;
if (top == -1) {
printf("Stack Underflow\n");
 exit(1);
} else {
c = stack[top];
top--;
return c;
}
}

int main() {
char input[] = "EAS*Y*QUE***ST***IO*N***";
int i;
for (i = 0; i < strlen(input); i++) {
if (input[i] != '*') {
push(input[i]);
} else {
char first = pop();
char second = pop();
printf("%c%c", second, first);
}
}
while (top != -1) {
printf("%c", pop());
}
printf("\n");
return 0;
}

Program di atas adalah sebuah program C yang mengimplementasikan konsep stack

dengan menggunakan array sebagai struktur datanya. Program ini akan melakukan
reverse (membalikkan) setiap pasangan karakter yang terdapat di dalam string input, yang
dipisahkan oleh karakter '*'. Berikut adalah analisis lebih detail mengenai program
tersebut:

Program dimulai dengan mengimpor tiga header file yaitu stdio.h, stdlib.h, dan string.h.
Kemudian, program mendefinisikan sebuah konstanta bernama MAX_STACK_SIZE
dengan nilai 100. Konstanta ini akan digunakan untuk menentukan ukuran maksimum
stack yang digunakan oleh program.
Program selanjutnya mendeklarasikan sebuah array bernama stack dengan ukuran
MAX_STACK_SIZE dan variabel top yang akan digunakan untuk menunjukkan indeks
dari elemen teratas stack. Variabel top diinisialisasi dengan nilai -1, menunjukkan bahwa
stack kosong.

Setelah itu, program mendefinisikan dua fungsi yaitu push() dan pop(). Fungsi push()
akan menambahkan karakter ke dalam stack, sedangkan fungsi pop() akan mengambil
karakter teratas dari stack dan mengembalikannya.

Fungsi push() akan melakukan pengecekan apakah stack sudah penuh atau belum. Jika
stack sudah penuh, maka program akan mencetak pesan "Stack Overflow" dan keluar dari
program dengan kode error 1. Jika stack belum penuh, maka variabel top akan dinaikkan
satu dan karakter akan dimasukkan ke dalam stack.

Fungsi pop() akan melakukan pengecekan apakah stack kosong atau tidak. Jika stack
kosong, maka program akan mencetak pesan "Stack Underflow" dan keluar dari program
dengan kode error 1. Jika stack tidak kosong, maka karakter teratas dari stack akan
diambil dan variabel top akan dikurangi satu. Karakter tersebut akan dijadikan nilai
kembalian dari fungsi pop().

Fungsi main() adalah bagian utama dari program. Di dalam fungsi main(), program
mendeklarasikan sebuah string bernama input yang berisi "EASYQUESTION**". String
ini merupakan input yang akan diproses oleh program.

Program kemudian melakukan loop sebanyak strlen(input) kali (panjang string input). Di
dalam loop ini, program memeriksa apakah karakter pada posisi i dari string input sama
dengan karakter '*'. Jika iya, maka program akan memanggil fungsi pop() dua kali untuk
mengambil dua karakter teratas dari stack. Setelah itu, karakter tersebut akan dicetak
dengan urutan yang terbalik menggunakan perintah printf().

Jika karakter pada posisi i tidak sama dengan karakter '*', maka program akan memanggil
fungsi push() untuk menambahkan karakter tersebut ke dalam stack.
Setelah loop selesai, program akan mencetak sisa karakter di dalam stack dengan
memanggil fungsi pop() hingga stack kosong.

Akhirnya, program mencetak karakter newline (\n) dan mengembalikan nilai 0 dari
fungsi main().

Secara keseluruhan, program ini berfungsi untuk membalikkan setiap pasangan karakter
yang terdapat di dalam string input, yang dipisahkan oleh karakter ''. Program ini
 mengimplementasikan konsep stack menggunakan array sebagai struktur datanya.
Namun, program ini tidak mengecek apakah input yang diberikan valid atau tidak,
misalnya apakah jumlah karakter '' pada input sel

LATIHAN 2

 SCREENSHOT PROGRAM

 SCREENSHOT OUTPUT
 ANALISA
LATIHAN 2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LENGTH 100

typedef struct Stack {

int top;
int items[MAX_LENGTH];
} Stack;

void initialize(Stack* stack) {

stack->top = -1;
}

int is_empty(Stack* stack) {

return stack->top == -1;
}

int is_full(Stack* stack) {

return stack->top == MAX_LENGTH - 1;
}

void push(Stack* stack, int item) {

if (is_full(stack)) {
printf("Error: stack is full\n");
exit(EXIT_FAILURE);
}
stack->items[++stack->top] = item;
}

int pop(Stack* stack) {

if (is_empty(stack)) {
printf("Error: stack is empty\n");
exit(EXIT_FAILURE);
}
return stack->items[stack->top--];
}
int peek(Stack* stack) {
if (is_empty(stack)) {
printf("Error: stack is empty\n");
exit(EXIT_FAILURE);
}
return stack->items[stack->top];
}

void decimal_to_binary(int decimal_num, char* binary_num) {

Stack stack;
initialize(&stack);

while (decimal_num > 0) {

int remainder = decimal_num % 2;
push(&stack, remainder);
decimal_num /= 2;
}

int i = 0;
while (!is_empty(&stack)) {
binary_num[i++] = pop(&stack) + '0';
}
binary_num[i] = '\0';
}

void decimal_to_octal(int decimal_num, char* octal_num) {

Stack stack;
initialize(&stack);

while (decimal_num > 0) {

int remainder = decimal_num % 8;
push(&stack, remainder);
decimal_num /= 8;
}

int i = 0;
while (!is_empty(&stack)) {
octal_num[i++] = pop(&stack) + '0';
}
 octal_num[i] = '\0';
}

void decimal_to_hexadecimal(int decimal_num, char* hex_num) {

Stack stack;
initialize(&stack);

while (decimal_num > 0) {

int remainder = decimal_num % 16;
if (remainder < 10) {
push(&stack, remainder);
} else {
push(&stack, remainder - 10 + 'A');
}
decimal_num /= 16;
}

int i = 0;
while (!is_empty(&stack)) {
hex_num[i++] = pop(&stack);
}
hex_num[i] = '\0';
}

int main() {
int decimal_num = 137;
char binary_num[MAX_LENGTH];
char octal_num[MAX_LENGTH];
char hex_num[MAX_LENGTH];

decimal_to_binary(decimal_num, binary_num);
decimal_to_octal(decimal_num, octal_num);
decimal_to_hexadecimal(decimal_num, hex_num);

printf("Decimal: %d\n", decimal_num);

printf("Binary: %s\n", binary_num);
printf("Octal: %s\n", octal_num);
printf("Hexadecimal: %s\n", hex_num);

return 0;
 }

Program ini merupakan program konversi bilangan desimal ke bilangan biner, oktal, dan
heksadesimal menggunakan struktur data stack.

Pada program ini, terdapat struktur data stack yang dibuat menggunakan tipe data struct.
Stack ini berisi bilangan bulat dengan ukuran maksimal MAX_LENGTH. Stack ini
memiliki tiga operasi utama, yaitu push, pop, dan peek.

Selanjutnya, terdapat tiga fungsi konversi bilangan desimal ke biner, oktal, dan
heksadesimal. Setiap fungsi menggunakan stack untuk menyimpan sisa hasil bagi saat
melakukan konversi bilangan desimal ke basis yang diinginkan. Kemudian, sisa hasil
bagi tersebut diambil dari stack dan diubah menjadi karakter untuk bilangan
heksadesimal, atau langsung ditambahkan '0' untuk bilangan biner dan oktal.

Fungsi main menggunakan tiga variabel karakter untuk menyimpan hasil konversi dari
bilangan desimal ke biner, oktal, dan heksadesimal. Kemudian, fungsi konversi dipanggil
dengan memasukkan bilangan desimal dan variabel karakter yang telah disediakan.

Hasil konversi kemudian ditampilkan menggunakan printf.

Program ini dapat dijadikan sebagai referensi untuk membuat program konversi bilangan
dengan menggunakan struktur data stack.

LATIHAN 3

 SCREENSHOT PROGRAM
 SCREENSHOT OUTPUT

 ANALISA
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LENGTH 100

typedef struct Stack {
int top;
char items[MAX_LENGTH];
} Stack;

void initialize(Stack* stack) {

stack->top = -1;
}

int is_empty(Stack* stack) {

return stack->top == -1;
}

int is_full(Stack* stack) {

return stack->top == MAX_LENGTH - 1;
}

void push(Stack* stack, char item) {

if (is_full(stack)) {
printf("Error: stack is full\n");
exit(EXIT_FAILURE);
}
stack->items[++stack->top] = item;
}

char pop(Stack* stack) {

if (is_empty(stack)) {
printf("Error: stack is empty\n");
exit(EXIT_FAILURE);
}
return stack->items[stack->top--];
}

char peek(Stack* stack) {

if (is_empty(stack)) {
printf("Error: stack is empty\n");
exit(EXIT_FAILURE);
}
return stack->items[stack->top];
}

void reverse_string(char* str) {

Stack stack;
initialize(&stack);

int i;
for (i = 0; i < strlen(str); i++) {
push(&stack, str[i]);
}

for (i = 0; i < strlen(str); i++) {

str[i] = pop(&stack);
}
}

int main() {
char str[MAX_LENGTH] = "YOONGI MARRY ME";

printf("Original string: %s\n", str);

reverse_string(str);

printf("Reversed string: %s\n", str);

return 0;
}

Program di atas adalah program yang mengimplementasikan fungsi reverse_string yang

menerima sebuah string sebagai input, dan mengembalikan string tersebut dengan urutan
karakter terbalik. Fungsi ini menggunakan struktur data stack untuk membalikkan urutan
karakter dalam string.

Berikut adalah analisis lebih detail dari program tersebut:

Program dimulai dengan mengimpor header file standar seperti stdio.h, stdlib.h, dan
string.h.

Konstanta MAX_LENGTH didefinisikan untuk menentukan panjang maksimum string

yang dapat ditangani oleh program.
 Kemudian, struktur data Stack didefinisikan dengan dua anggota: top (yang menunjukkan
indeks elemen teratas dalam stack) dan items (yang merupakan array karakter yang
menyimpan elemen dalam stack).

Beberapa fungsi yang berkaitan dengan stack didefinisikan seperti initialize, is_empty,
is_full, push, pop, dan peek. Fungsi-fungsi ini digunakan untuk mengelola stack.

Fungsi reverse_string didefinisikan untuk membalikkan urutan karakter dalam string.

Fungsi ini menerima sebuah pointer ke string sebagai input.

Fungsi reverse_string menginisialisasi stack dan melakukan iterasi pada setiap karakter
dalam string, mendorong karakter ke stack.

Kemudian, fungsi melakukan iterasi pada setiap karakter dalam string, menarik karakter
dari stack dan menempatkannya pada posisi yang sesuai dalam string.

Fungsi main dimulai dengan mendeklarasikan sebuah string str dengan panjang
maksimum MAX_LENGTH.

Kemudian, string str diisi dengan teks "YOONGI MARRY ME".

String asli dicetak menggunakan printf.

Fungsi reverse_string dipanggil dengan string str sebagai argumen.

String yang dibalikkan dicetak kembali menggunakan printf.

Program selesai dengan mengembalikan nilai 0.

Program ini berhasil membalikkan urutan karakter dalam string "JUAN EKNATH "
menjadi "HTANKE NAUJ".

LATIHAN 4

 SCREENSHOT PROGRAM
 SCREENSHOT OUTPUT

 ANALISA
#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Fungsi untuk mengubah huruf kecil menjadi huruf besar

char toUpper(char c) {
if (islower(c)) {
return toupper(c);
}
return c;
}

int main() {
// Input string
char string[100];
printf("Masukkan sebuah string: ");
fgets(string, 100, stdin);
string[strcspn(string, "\n")] = '\0'; // Menghapus karakter newline

// Menggunakan stack dengan array

char stack[100];
int top = -1;

// Memasukkan setiap huruf ke dalam stack

for (int i = 0; i < strlen(string); i++) {
char c = toUpper(string[i]);
if (isalpha(c)) {
top++;
stack[top] = c;
}
}

// Membuat string terbalik dari stack

char reversed[100];
int i = 0;
while (top >= 0) {
reversed[i] = stack[top];
top--;
i++;
}
reversed[i] = '\0';

// Membandingkan string asli dengan string terbalik

if (strcmp(string, reversed) == 0) {
printf("String \"%s\" adalah palindrom.\n", string);
 } else {
printf("String \"%s\" bukan palindrom.\n", string);
}

return 0;
}

ANALISA:
Program di atas merupakan program untuk mengecek apakah sebuah string merupakan
palindrom atau bukan.

Pertama-tama, program mengambil input string dari pengguna dan menghapus karakter
newline. Kemudian, program membuat stack menggunakan array dan memasukkan setiap
huruf dari string yang telah diubah ke huruf besar ke dalam stack. Setelah itu, program
membuat string terbalik dari stack dengan mengambil setiap huruf dari stack dan
memasukkannya ke dalam string terbalik. Terakhir, program membandingkan string asli
dengan string terbalik untuk menentukan apakah string tersebut merupakan palindrom
atau bukan.

Untuk mengubah huruf kecil menjadi huruf besar, program menggunakan fungsi
toUpper() yang mengembalikan huruf yang telah diubah menjadi huruf besar. Fungsi ini
menggunakan fungsi islower() untuk mengecek apakah huruf tersebut merupakan huruf
kecil dan fungsi toupper() untuk mengubah huruf tersebut menjadi huruf besar.

Program ini menggunakan beberapa fungsi dari library C, yaitu stdio.h, string.h, dan
ctype.h. Fungsi fgets() digunakan untuk mengambil input string dari pengguna, strlen()
digunakan untuk mendapatkan panjang string, isalpha() digunakan untuk mengecek
apakah karakter tersebut merupakan huruf, dan strcmp() digunakan untuk
membandingkan string.

Secara keseluruhan, program ini dapat digunakan untuk mengecek apakah sebuah string
merupakan palindrom atau bukan dengan menggunakan stack untuk membalikkan string.