Tek Informatika UNUD

1. Resume Struct & Stack 1
Daftar Isi
Daftar Isi .................................................................................................................................................1
Bab I Struct .............................................................................................................................................2
1.1. Definisi Struct...............................................................................................................................2
1.2. Deklarasi Struct ............................................................................................................................2
1.3. Pengaksesan Elemen Struct ..........................................................................................................3
1.4. Structure dan Fungsi.....................................................................................................................3
1.5. Kasus Struct..................................................................................................................................4
Bab II Stack.............................................................................................................................................5
2.1. Definisi Stack................................................................................................................................5
2.2. Deklarasi Stack dalam Program....................................................................................................5
2.3. Operasi – operasi dasar dalam stack.............................................................................................6
Bab III Infix, Prefix, Postfix ...................................................................................................................8
3.1. Pendahuluan..................................................................................................................................8
3.2. Konversi Notasi ............................................................................................................................9
3.3. Evaluasi Ekspresi........................................................................................................................12
3.4. Kasus Stack.................................................................................................................................13

2. Resume Struct & Stack 2
Bab I Struct
1.1. Definisi Struct
Struct adalah tipe data bentukan yang berisi kumpulan variabel-variabel yang bernaung
dalam satu nama yang sama dan memiliki kaitan satu sama lain.
Berbeda dengan array hanya berupa kumpulan variabel yang bertipe data sama, struct bisa
memiliki variabel-variabel yang bertipe data sama atau berbeda, bahkan bisa
menyimpan variabel yang bertipe data array atau struct itu sendiri.
Variabel-variabel yang menjadi anggota struct disebut dengan elemen struct.
1.2. Deklarasi Struct
Structure merupakan kumpulan dari satu atau beberapa variabel yang mempunyai tipe
sama atau berbeda (Heterogenous). Variabel dalam structure sering disebut dengan nama
komponen, field, elemen atau members. Suatu struktur dinyatakan dengan kata kunci
struct, daftar pernyataan variable yang disebut anggota, yang terlampir dalam tanda
kurung { }. Tiap pernyataan anggota dan struktur harus berakhir dengan semicolon ( ; ).
Bentuk umum deklarasi structure pada C:
struct <struct_name>{
<type> <elemen_name1>;
<type> <elemen_name2>;
} <structure_variable>;
Contoh:
struct Mahasiswa{
char nama[20];
float ip;
int semester;
};
Untuk mendefinisikan variabel X dengan tipe struct Mahasiswa adalah sbb:
struct Mahasiswa X;
Satu atau beberapa variabel dapat juga didefinisikan pada saat structure tersebut
dideklarasikan. Contoh: X dan Y adalah variabel bertipe struct Mahasiswa
struct Mahasiswa{
char nama[20];

3. Resume Struct & Stack 3
float ip;
int semester;
} X,Y;
1.3. Pengaksesan Elemen Struct
Bentuk umum:
<structure_variable>.<field_name>
<structure_pointer>→<field_name>
Contoh:
X.semester = 4;
X.ip = 3.75;
Mahasiswa *ptr = &X;
ptr→semester = 4;
1.4. Structure dan Fungsi
1. Passing parameter
Passing structure ke dalam fungsi sama seperti tipe data yang lain. Contoh mem-
passing struct Mahasiswa ke fungsi
void cetak(struct Mahasiswa X)
{
printf(“Nama=%sn”,X.nama);
printf(“IP = %fn”,X.ip);
}
void main()
{
Mahasiswa X;
cetak(X);
}
2. Structure sebagai return value
struct Mahasiswa Mhs;
..
struct Mahasiswa Entry(char *nama, int sem,
float ip)
{
strcpy(Mhs.nama,nama);
Mhs.semester = sem;
Mhs.ip = ip;
return(Mhs);
}

4. Resume Struct & Stack 4
1.5. Kasus Struct
1. Buatlah sebuah program data siswa dengan menggunakan struct dengan syarat berikut :
1. program mempersiapkan sebuah struct yang dapat menyimpan Nama Siswa, ID Siswa,
Nilai Siswa.
2. Kemudian program dapat menampilkan data Nama, ID, dan Nilai Siswa yang telah
dimasukkan.
3. Program dapat menampilkan rata-rata nilai dari nilai siswa-siswa yang telah dimasukkan
Jawab :
#include <stdio.h>
struct Siswa
{
int id;
char nama[20];
float nilai;
};
void main()
{
struct Siswa siswa[3];
float jumlah;
jumlah = 0;
for(index = 0; index < 3; index++)
{
printf(“Masukkan ID siswa ke-%d: ”,index + 1);
scanf(“%d”, &siswa[index].id);
printf(“Masukkan nama siswa ke-%d: ”, index + 1);
gets(siswa[index].nama);
printf(“Masukkan nilai siswa ke-%d: ”, index + 1);
scanf(“%d”, &siswa[index].nilai);
jumlah = jumlah + siswa[index].nilai;
}
for(index = 0; index < 3; index++)
{
Printf(“Data siswa ke-%d: ”, index + 1);
Printf(“ID: %d: ”, siswa[index].id);
Printf(“Nama : %s”, siswa[index].nama);
Printf(“Nilai : %.2f”, siswa[index].nilai);
}
Printf(“Rata-rata : %2.f” jumlah / 3);
}

5. Resume Struct & Stack 5
Bab II Stack
2.1. Definisi Stack
Stack (tumpukan) sebenarnya adalah sebuah cara dalam mengorganisasikan data-data
yang dimiliki. Ibarat seseorang yang menyimpan buku-bukunya, ada yang disusun dengan
cara ditumpuk, ada juga yang dijejerkan di dalam lemari.
Kaidah utama dalam konsep stack adalah LIFO yang merupakan singkatan dari Last In
First Out, artinya adalah data yang terakhir kali dimasukkan atau disimpan, maka data
tersebut adalah yang pertama kali akan diakses atau dikeluarkan. Gambar di bawah ini
mengilustrasikan kerja sebuah stack.
2.2. Deklarasi Stack dalam Program
Sebuah stack di dalam program komputer dideklarasikan sebagai sebuah tipe bentukan
baru, di dalam Bahasa C, biasa disebut struct. Sebuah struktur data dari sebuah stack
setidaknya harus mengandung dua buah variabel, yakni variabel TOP yang akan berguna
sebagai penanda bagian atas tumpukan dan ARRAY DATA dari yang akan menyimpan
data-data yang dimasukkan ke dalam stack tersebut. Berikut adalah syntax untuk
mendeklarasikan struktur data dari sebuah stack menggunakan Bahasa C
typedef struct
{
int TOP;
int data[max+1];
}Stack;
dimana, nilai MAX didefinisikan sebagai jumlah tumpukan maksimum yang dapat
disimpan dalam stack. Setelah strukutr data dari stack didefinisikan dengan syntax di atas,
maka setelah itu dapat dibuat variabel-variabel baru yang mengacu pada tipe data Stack di
atas, misalkan membuat sebuah variabel bernama tumpukan yang bertipe Stack:
Stack tumpukan;

6. Resume Struct & Stack 6
Dalam tulisan ini, sebuah stack didefinisikan dengan array berukuran MAX + 1,
maksudnya adalah agar elemen array ke-0 tidak digunakan untuk menyimpan data,
melainkan hanya sebagai tempat „singgah‟ sementara untuk variabel TOP. Sehingga, jika
TOP berada pada elemen array ke-0, berarti stack tersebut dalam kondisi kosong (tidak
ada data yang disimpan). Berikut adalah ilustrasi dari sebuah stack kosong dengan ukuran
nilai MAX = 6:
2.3. Operasi – operasi dasar dalam stack
Sebuah stack setidaknya memiliki lima buah operasi-operasi dasar, yakni:
a. Prosedur createEmpty
Prosedur ini berfungsi untuk mengosongkan stack dengan cara meletakkan TOP ke posisi
ke-0. Berikut adalah deklarasi prosedur createEmpty dalam Bahasa C:
void createEmpty()
{
tumpukan.TOP = 0;
}
b. Prosedur push
Prosedur ini berfungsi untuk memasukkan sebuah nilai/ data ke dalam stack. Sebelum
sebuah nilai/ data dimasukkan ke dalam stack, prosedur ini terlebih dahulu akan
menaikkan posisi TOP satu level ke atas. Misalkan kondisi stack masih kosong (TOP = 0),
lalu prosedur push akan menaikkan posisi TOP satu level ke atas, yakni ke posisi 1 (TOP =
1), baru setelah itu data dimasukkan ke dalam array pada indeks ke-1 (yakni indeks
dimana TOP berada). Berikut adalah deklarasi prosedur push dalam Bahasa C:
void push(int x)
{
tumpukan.TOP = tumpukan.TOP + 1;
tumpukan.data[tumpukan.TOP] = x;
}
Pada deklarasi prosedur push di atas, prosedur memiliki sebuah parameter formal yang
bernama „x‟ yang bertipe integer. Parameter formal „x‟ ini berguna untuk menerima
kiriman nilai dari program utama (void main()) yakni berupa sebuah bilangan integer yang
akan dimasukkan ke dalam stack. Sebelum nilai pada variabel „x‟ dimasukkan ke dalam
stack, terlebih dahulu posisi TOP dinaikkan satu level, baru setelah itu nilai pada variabel
„x‟ dimasukkan ke dalam array data pada indeks dimana TOP itu berada.
c. Prosedur pop

7. Resume Struct & Stack 7
Prosedur ini berfungsi untuk mengeluarkan/ menghapus nilai terakhir (yang berada pada
posisi paling atas) dari stack, dengan cara menurunkan nilai TOP satu level ke bawah.
Misalkan TOP berada pada indeks ke-5, maka ketika akan mengeluarkan/ menghapus data
pada posisi paling atas (pada posisi TOP), prosedur ini akan menurunkan posisi TOP ke
indeks array ke-4. Berikut deklarasi prosedur pop dalam Bahasa C:
void pop()
{
tumpukan.TOP = tumpukan.TOP - 1;
}
d. Fungsi IsEmpty
Fungsi ini berfungsi untuk melakukan pengecekan terhadap stack, apakah stack tersebut
kosong atau tidak. Jika stack tersebut kosong (artinya, TOP berada pada posisi 0), maka
fungsi akan mengembalikan nilai 1 (true), tetapi jika stack tersebut tidak kosong/ berisi
(artinya, TOP tidak berada pada posisi 0), maka fungsi akan mengembalikan nilai 0
(false). Berikut deklarasi fungsi IsEmpty dalam Bahasa C:
int IsEmpty()
{
if (tumpukan.TOP == 0)
return 1;
else
return 0;
}
e. Fungsi IsFull
Fungsi ini berfungsi untuk melakukan pengecekan terhadap stack, apakah stack tersebut
penuh atau tidak. Jika stack tersebut penuh (artinya, TOP berada pada posisi MAX),
maka fungsi akan mengembalikan nilai 1 (true), tetapi jika stack tersebut tidak penuh
(artinya, TOP tidak berada pada posisi MAX), maka fungsi akan mengembalikan nilai 0
(false). Berikut deklarasi fungsi IsFull dalam Bahasa C:
int IsFull()
{
if (tumpukan.TOP == MAX)
return 1;
else
return 0;
}

8. Resume Struct & Stack 8
Bab III Infix, Prefix, Postfix
3.1. Pendahuluan
Salah satu kegunaan stack adalah untuk mengubah notasi infix menjadi prefix ataupun
postfix, ada baiknya mengenal istilah operand dan operator dahulu.
Apa yang dimaksud dengan Operand dan Operator ?
Apa yang dimaksud dengn Infix, Prefix dan Postfix?
Infix, Prefix ataupun Postfix adalah bentuk penulisan operasi matematika, bedanya :
Infix - Operator diletakkan di antara Operand
Prefix - Operator diletakkan di depan Operand
Postfix / Sufix - Operator diletakkan di belakang Operand
Mengapa harus menggunakan Prefix dan Postfix?
Karena infix memiliki beberapa kekurangan, yaitu :
1. Urutan pengerjaan tidak berdasarkan letak kiri atau kanannya,
tetapi berdasarkan precedence-nya
Contoh : 3 + 4 x 2
3 + 4 x 2 , maka urutan pengerjaan adalah 4 x 2 dahulu.
3 + 8 , baru hasilnya ditambah 3
11
Urutan precedence (dari prioritas tertinggi) adalah sebagai berikut :
1. - Pemangkatan
2. - Perkalian dan Pembagian
3. - Penjumlahan dan Pengurangan.
- Kecuali kalau ada tanda kurung.
2. Menggunakan tanda kurung. Infix bisa menggunakan tanda kurung. Tetapi tanda
kurung dapat mengacak urutan precedence.
Contoh : Tanpa penggunaan tanda kurung :
9 – 5 – 3
9 – 5 – 3 , maka urutan pengerjaan adalah 9 - 5 dahulu.
4 – 3
1
Bandingkan dengan penggunaan tanda kurung berikut :
9 – ( 5 – 3 )
9 – ( 5 – 3 ) , maka urutan pengerjaan adalah 5 – 3 dahulu.
9 – 2
7
3. Jika suatu program akan mengevaluasi (mencari hasil) suatu infix, maka komputer perlu
men-scan berulang-ulang mencari urutan pengerjaannya dahulu.
Contoh : 7 + 4 x 2 – 6 / 3

9. Resume Struct & Stack 9
Jika kita diminta untuk menghitung soal seperti itu, maka kita tahu bahwa yang pertama
kali harus kita kerjakan adalah 4 x 2. Lalu 6 / 3 dsb, seperti langkah-langkah berikut :
7 + 4 x 2 – 6 / 3
7 + 8 – 6 / 3
7 + 8 – 2
15 – 2
13
Komputer tidak bisa membaca keseluruhan soal sekaligus. Komputer hanya bisa men-scan
soal satu per satu operand atau operator. Sehingga untuk mengetahui mana yang harus
dikerjakan duluan, komputer harus men-scan keseluruhan soalnya dulu. Jadi langkah-
langkah si komputer dalam mengerjakan soal infix seperti berikut:
1. - Cari precedence tertinggi dengan men-scan kiri ke kanan keseluruhan soal.
2. - Hitung nilai operator dengan precedence tertinggi tersebut.
3. - Ulangi lagi dari langkah 1, sampai semua operator selesai dikerjakan.
Jika komputer tidak men-scan keseluruhan soal terlebih dahulu, maka akan terjadi
kesalahan pada hasilnya.
3.2. Konversi Notasi
Konversi Infix ke Prefix Manual (tanpa stack)
Langkah-langkahnya:
1. Cari operator yang memiliki precedence tertinggi.
2. Letakkan operator tsb di depan operand-operandnya.
3. Ulangi lagi.
Contoh:
A + B – C x D ^ E / F , ”D ^ E” maksudnya D pangkat E.
A + B – C x D ^ E / F , pangkat memiliki precedence tertinggi
A + B – C x ^ D E / F , taruh ^ di depan D dan E
A + B – C x ^ D E / F , x (kali) dan / (bagi) memiliki precedence sama tapi x di kiri
A + B – x C ^ D E / F , taruh x di belakang
A + B – x C ^ D E / F , dan sebagainya
A + B – / x C ^ D E F
A + B – / x C ^ D E F
+ A B – / x C ^ D E F
+ A B – / x C ^ D E F
– + A B / x C ^ D E F , inilah bentuk Prefix-nya.
Konversi Infix ke Postfix Manual (tanpa stack)
Langkah-langkahnya :
1.Cari operator yang memiliki precedence tertinggi.
2.Letakkan operator tsb di belakang operand-operandnya.
3. Ulangi terus sampai bosan, eh salah, sampai selesai.
Contoh :
A + B – C x D ^ E / F , ”D ^ E” maksudnya D pangkat E.
A + B – C x D ^ E / F , pangkat memiliki precedence tertinggi
A + B – C x D E ^ / F , taruh ^ di belakang D dan E
A + B – C x D E ^ / F , x (kali) dan / (bagi) memiliki precedence sama tapi x di kiri
A + B – C D E ^ x / F , taruh x di belakang
A + B – C D E ^ x / F ,dan sebagainya

10. Resume Struct & Stack 10
A + B – C D E ^ x F /
A + B – C D E ^ x F /
A B + – C D E ^ x F /
A B + – C D E ^ x F /
A B + C D E ^ x F / – , inilah bentuk Postfix-nya.
Konversi Infix ke Prefix Menggunakan Stack
Kali ini kita menggunakan 2 Stack, yang satu untuk menampung operand
(sebut saja dengan Stack “Pre”) dan yang satunya lagi untuk menampung operator
(sebut saja dengan Stack “Opr”).
Langkah – langkah :
1. Scan Infix dari kanan ke kiri.
2. Jika berupa operand, maka Push ke Stack “Pre”.
3. Jika berupa operator, maka bandingkan operator NEW tersebut dengan TOP pada Stack
“Opr”:
a. a. WHILE precedence TOP > NEW, maka POP Stack “Opr” pindahkan ke Stack
“Pre”.
b. b. Lalu Push NEW ke dalam Stack “Opr”.
4. Jika berupa “)“, maka Push “)“ ke Stack “Opr”.
5. Jika berupa “(”, maka Pop Stack “Opr” pindahkan ke stack “Pre” sampai ketemu
“)“.
6. Ulangi terus dari langkah 1 sampai seluruh Infix sudah di-scan.
7. POP semua isi Stack “Opr”, pindahkan ke Stack “Pre”.
8. POP semua isi Stack “Pre”, pindahkan ke Prefix.
Contoh : A ^ B / ( C – D )

11. Resume Struct & Stack 11
Konversi Infix ke Postfix Menggunakan Stack
Contoh : A ^ B / ( C – D )
Keterangan :
o Tanda kurung “(“ dan “)”, dapat dianggap tidak memiliki precedence, sehingga pada
langkah ke-7, operator “–“ tidak perlu dibandingkan lagi dengan “(“ dan langsung di Push
ke Stack.
o Pada langkah ke-8, tanda “)” dibaca dari Infix, maka Stack di Pop terus sampai ketemu
tanda “(“. Sehingga pada contoh di atas operator “–“ di Pop dan dipindahkan ke Postfix.

12. Resume Struct & Stack 12
3.3. Evaluasi Ekspresi
EVALUASI
Yang dimaksud dengan “Evaluasi” disini adalah mencari nilai akhir dari suatu notasi.
Dengan kata lain, disuruh ngitung hasilnya.
Contoh : Berapa hasil 3 + 4 ?
Jawab : 7
Evaluasi Postfix Manual
Langkah-langkahnya :
1. Scan Postfix dari kiri ke kanan.
2. Jika berupa operand, cuekin dulu aja.
3. Jika berupa operator, ambil 2 operand sebelumnya (yang tadi sempet kita cuekin di
sebelah kiri), lakukan perhitungan, lalu simpan lagi berupa operand.
4. Begitu seterusnya sampai ujung kanan Postfix.
Contoh :
Postfix : 7 6 5 x 3 2 ^ – +
7 6 5 x 3 2 ^ – + , scan terus sampai ketemu operator pertama.
7 6 5 x 3 2 ^ – + , hitung 6 x 5.
7 30 3 2 ^ – + , scan lagi cari operator berikutnya.
7 30 3 2 ^ – + , hitung 3 pangkat 2.
7 30 9 – + , scan lagi cari operator berikutnya.
7 30 9 – + , hitung 30 – 9.
7 21 + , scan lagi.
7 21 + , hitung 7 + 24.
28 , selesai.
Evaluasi Postfix Menggunakan Stack
Langkah-langkahnya :
1. Scan Postfix dari kiri ke kanan.
2. Jika berupa Operand, masukkan ke Stack.
3. Jika berupa Operator, Pop Stack 2 kali (ambil 2 operand), hitung hasilnya, lalu Push lagi
ke dalam Stack.
4. Ulangi lagi sampai ujung kanan Postfix.
Evaluasi Prefix Manual
Langkah-langkahnya idem, sama kaya Postfix, tapi arah scannya dari kanan ke kiri.
Contoh :
Prefix : + 7 – x 6 5 ^ 3 2 (soalnya sama nih sama soal Postfix tadi)
+ 7 – x 6 5 ^ 3 2 , scan kanan ke kiri sampai ketemu operator.
+ 7 – x 6 5 ^ 3 2 , hitung 3 pangkat 2.
+ 7 – x 6 5 9 , selanjutnya silahkan pelajari sendiri dulu.
+ 7 – x 6 5 9
+ 7 – 30 9
+ 7 – 30 9
+ 7 21
+ 7 21
28

13. Resume Struct & Stack 13
Evaluasi Prefix Menggunakan Stack
Langkah-langkahnya :
1. Scan Postfix dari kanan ke kiri.
2. Jika berupa Operand, masukkan ke Stack.
3. Jika berupa Operator, Pop Stack 2 kali (ambil 2 operand), hitung hasilnya, lalu Push lagi
ke dalam Stack.
4. Ulangi lagi sampai ujung kanan Postfix.
3.4. Kasus Stack
Dari Notasi Infiks berikut ini tentukan prefix dan postfix dengan menggunakan stack !
Infix : 7*3+6^5/4-2
Prefix : ?
Postfix : ?
Jawab :
Prefix
Character yang di Uji Stack Prefix
2 2
- - 2
4 - 42
/ -/ 42
5 -/ 542
^ -/^ 542
6 -/^ 6542
+ + -/^6542
3 + 3-/^6542
* +* 3-/^6542
7 +* 73-/^6542
+*73-/^6542
Jadi prefix dari 7*3+6^5/4-2 adalah +*73-/^6542
Postfix
Character yang di Uji Stack Postfix
7 7
* * 7
3 * 73
+ + 73*
6 + 73*6
^ +^ 73*6
5 +^ 73*65
/ +/ 73*65^
4 +/ 73*65^4
- - 73*65^4/+
2 - 73*65^4/+2-
73*65^4/+2-
Jadi postfix dari 7*3+6^5/4-2 adalah 73*65^4/+2-