Struktur Data

LEMBARAN IDENTITAS DAN PENGESAHAN
PENYUSUNAN MODUL PRAKTEK
1. Judul : Praktek Struktur Data

2. Ketua Pelaksana
Nama/NIP : Rasyidah, S.Si., MM / 19740601 200604 2 001
Jurusan/Prodi : Teknologi Informasi / Manajemen Informatika
Matakuliah yang diampu : Praktek Struktur Data
3. Anggota Pelaksana 1
Nama/NIP : Rita Afyenni, M.Kom / 19700718 200801 2 010
Jurusan/Prodi : Teknologi Informasi / Manajemen Informatika
Matakuliah yang diampu: Praktek Basis Data Dasar
4. Lokasi Kegiatan :Jurusan Teknologi Informasi Politeknik Negeri
Padang
5. Biaya Yang Dibutuhkan :
6. JangkaWaktu Pelaksana : 6 Bulan
7. Biaya :
Mengetahui, Padang, 30 November 2016

Ketua Jurusan Ketua Pelaksana
Ervan Asri, M. Kom Rasyidah, S.Si., MM .

NIP. 19780901 200812 1 001 NIP. 19740601 200604 2 001
Wakil Direktur 1
Drs. Albar, MKom

NIP. 19580917 198603 1 002
ii
KATA PENGANTAR
Puji syukur penulis haturkan kepada Allah SWT, hanya dengan rahmat
dan karuniaNya lah penulis dapat menyelesaikan Jobsheet untuk mata kuliah
Praktek Struktur Data.
Jobsheet ini dibuat sesuai dengan pembelajaran kurikulum berbasis
kompetensi, terutama untuk kebutuhan di Jurusan Teknologi Informasi Politeknik
Negeri Padang (jurusan TI PNP), sehingga mahasiswa dapat menggunakannya
sebagai pedoman dan agar lebih mudah dalam melaksanakan perkuliahan
padamata kuliah Praktek Struktur Data.
Pada jobsheet ini disediakan pembahasan teori untuk masing-masing bab
agar mahasiswa terbantu dalam pelaksanaan prakteknya, juga diuraikan
bahan/peralatan yang digunakan selama praktek. Diberikan juga langkah-langkah
kerja yang harus diikuti mahasiswa agar praktek menjadi lebih terstruktur dan
diberikan latihan-latihan yang harus dikerjakan oleh mahasiswa agar lebih
memahami materi praktek pada modul tesebut.
Penulis merasa masih banyak kekurangan dalam penyusunan jobsheet ini
sehingga masih membutuhkan penyempurnaan, karena itu segala kritik dan saran
dari pembaca sangat penulis harapkan.
Penulis mengucapkan terima kasih kepada :
1. Ir. Aidil Zamri, MT, selaku Direktur Politeknik Negeri Padang
2. Ervan Asri, M.Kom, selaku Ketua Jurusan Teknologi Informasi
3. Yance Sonatha, S.Kom., MT selaku Ketua Program Studi Manajemen
Informatika.
4. Semua pihak yang tidak bisa disebutkan satu persatu
Akhir kata penulis berharap agar Jobsheet ini dapat bermanfaat bagi
pembaca pada umumnya dan mahasiswa pada khususnya.
Padang, November 2016
Rasyidah
iii
DESKRIPSI MODUL PRAKTEK
a. Identitas Mata Kuliah

Nama Mata Kuliah : Praktek Struktur Data
Kode Mata Kuliah : IS 4304
Jumlah SKS :1
Jumlah Jam : 3 Jam / Minggu
Semester / Tingkat : III / II
Status : Wajib
Pra Syarat : Algoritma dan Pemrograman
Waktu Pertemuan : 16 Kali Pertemuan/Semester (270Menit/Pertemuan)
Deskripsi Ringkas
Mata kuliah Praktek Struktur Data ini merupakan mata kuliah lanjutan dari
Praktek Algoritma dan Pemrograman yang telah dipelajari oleh mahasiswa pada
semester sebelumnya.
Adapun materi yang diajarkan pada mata kuliah Praktek Struktur Data ini adalah
mengenal konsep dasar dari struktur data, mengenal perbedaan dasar dari konsep
struktur data dengan konsep algoritma, mengenal bahasa pemrograman C, tipe
data bentukan (abstract data type) yang terdiri dari typedeft dan struct, Array
struct, beberapa teknik sorting data (Insertion Sort, Bubble Sort, Merge Sort,
Selection Sort), beberapa teknik searching data (Sequential Search, Binary
Search, Interpolation Search), menggunakan pointer, menggunakan linked list,
teknik stack, teknik queue, konsep tree, konsep graph.
Kriteria Penilaian
Proses penilaian pada mata kuliah Praktek Struktur Data ini berasal dari empat
komponen penilaian, yaitu :
1. Kehadiran
Komponen ini memiliki poin sebesar 10% dari total pertemuan tatap muka
sebanyak 18 kali. Kehadiran merupakan salah satu komponen penunjang
iv
dalam melakukan proses penilaian dan keaktifan mahasiswa akan
dijadikan nilai tambah secara objektif untuk penilaian akhir.
2. Tugas dan Laporan
Selama satu semester, mahasiswa diwajibkan mengerjakan semua latihan
yang terdapat pada modul praktek yang dituliskan melalui Laporan.
Latihan ini harus dikerjakan disetiap pertemuan praktek. Komponen
keseluruhan tugas memiliki poin sebesar 30%.
3. UTS (Ujian Tengah semester)
UTS dilakukan pada pertemuan ke 9 dari keseluruhan total pertemuan
melalui ujian tertulis, praktek atau mini project yang akan dipresentasikan.
Materi yang diujikan adalah materi pertemuan 1 sampai dengan 8, dengan
bobot yang diberikan sebesar 30%.
4. UAS (Ujian Akhir Semester)
UAS dilakukan pada saat jadwal ujian akhir yang ditetapkan oleh jadwal
akademik di Jurusan Teknologi Informasi. UAS bisa dilaksanakan dalam
bentuk ujian tertulis, praktek atau mini project yang akan dipresentasikan.
Materi yang diujikan adalah materi setelah UTS yaitu materi pada
pertemuan 10 sampai dengan 18, dengan bobot yang diberikan sebesar
30%.
Penilaian dilakukan berdasarkan semua komponen nilai yang ada. Nilai akhir
yang diperoleh mahasiswa merupakan rata-rata dari perolehan tiap komponen
dengan melibatkan bobot masing-masing. Nilai akhir merupakan gambaran
kemampuan dan kualitas mahasiswa terhadap ilmu yang sudah diperoleh selama
satu semester. Nilai akhir akan dikonversi ke dalam bentuk angka dan huruf sesuai
dengan peraturan akademik yang ada di Jurusan Teknologi Informasi.
v
DAFTAR ISI
HALAMAN JUDUL ............................................................................................... i

LEMBARAN IDENTITAS DAN PENGESAHAN .............................................. ii
KATA PENGANTAR .......................................................................................... iii
DESKRIPSI MODUL PRAKTEK ....................................................................... iv
DAFTAR ISI ........................................................................................................ vi
DAFTAR GAMBAR ........................................................................................... vii
PETUNJUK PENGGUNAAN MODUL PRAKTEK ......................................... viii
MODUL 1 KONSEP DASAR STRUKTUR DATA DAN BAHASA
PEMROGRAMAN C ....................................................................... 1
MODUL 2 TIPE DATA BENTUKAN DALAM BAHASA
PEMROGRAMAN C ....................................................................... 8
MODUL 3 TEKNIK SORT DALAM BAHASA
PEMROGRAMAN C ..................................................................... 22
MODUL 4 TEKNIK SEARCH DALAM BAHASA
PEMROGRAMAN C ..................................................................... 33
MODUL 5 PENERAPAN POINTER DALAM
PEMROGRAMAN C ..................................................................... 44
MODUL 6 PENERAPAN LINKED LIST NON CIRCULAR
PEMROGRAMAN C ..................................................................... 52
MODUL 7 PENERAPAN LINKED LIST CIRCULAR DALAM
PEMROGRAMAN C ..................................................................... 67
MODUL 8 PENERAPAN TEKNIK STACK DALAM
PEMROGRAMAN C ..................................................................... 72
MODUL 9 PENERAPAN TEKNIK QUEUE DALAM
PEMROGRAMAN C ..................................................................... 83
MODUL 10 PENERAPAN TEKNIK TREE DALAM
PEMROGRAMAN C ..................................................................... 92
MODUL 11 PENERAPAN TEKNIK GRAPH DALAM
PEMROGRAMAN C ..................................................................... 98
DAFTAR ISTILAH ............................................................................................. xiv

LAMPIRAN
vi
DAFTAR GAMBAR
Gambar 1.1 Hasil pengujian program 1.1 .............................................................. 5

Gambar 1.2 Hasil Pengujian program 1.2............................................................. ..5
Gambar 1.3 Hasil pengujian program 1.3 ............................................................... 5
Gambar 1.4 Hasil pengujian program 1.4 ............................................................... 5
Gambar 2.1 Hasil pengujian program 2.1 ............................................................. 18
Gambar 5.1 Pointer P mengarah ke alamat ke-1 sampai ke-N ............................. 42
Gambar 5.2 Ilustrasi variabel statis (a) dan dinamis (b) ....................................... 43
Gambar 5.3 Ilustrasi pointer P yang akan menunjuk ke alamat dari variabel ‘a’
yang bertipe karakter ...................................................................... 43
Gambar 5.4 Ilustrasi Pointer P .............................................................................. 44
Gambar 6.1 Ilustrasi Struktur Linked List ............................................................ 51
Gambar 7.1 Single Linked List Circular ............................................................... 64
Gambar 7.2 Single Linked List Circular ............................................................... 65
Gambar 7.3 Double Linked List Circular ............................................................. 65
Gambar 8.1 Fungsi Utama Stack .......................................................................... 73
Gambar 9.1 Ilustrasi kerja queue .......................................................................... 88
Gambar 9.2 Hasil pengujian program 9.1 ........................................................... 101
Gambar 10.1 Hasil pengujian program 10.1 ....................................................... 118
vii
Gambar 11.1 Contoh Graf Berbobot................................................................... 122
Gambar 11.2 a .................................................................................................... 123
Gambar 11.2 b .................................................................................................... 123
Gambar 11.3 a .................................................................................................... 124
Gambar 11.3 b .................................................................................................... 124
Gambar 11.4 a .................................................................................................... 125
Gambar 11.4 b .................................................................................................... 125
Gambar 11.5 a .................................................................................................... 125
Gambar 11.5 b .................................................................................................... 125
Gambar 11.6 (a)(b)(c) ......................................................................................... 126
Gambar 11.10 Hasil pengujian program 11.4 ..................................................... 136
viii
PETUNJUK PENGGUNAAN MODUL PRAKTEK
Jobsheet ini dibuat sebagai bahan acuan materi dan pelaksanaan

perkuliahan Praktek Struktur Data untuk Program Studi Manajemen Informatika
Jurusan Teknologi Informasi. Pada buku ini terdapat garis-garis besar materi
praktek perkuliahan yang terdiri dari 18 bab yang dilengkapi dengan landasan
teori, langkah kerja dan latihan.
Sebagai upaya dalam meningkatkan efektivitas proses pembelajaran pada mata
kuliah Praktek Struktur Data, maka dibutuhkan modul praktek berupa buku
sebagai pelengkap dalam aktivitas pembelajaran. Penulisan modul praktek mata
kuliah Praktek Struktur Data ini mengacu pada sasaran belajar dan pembelajaran
untuk mencapai kompetensi sebagaimana yang tertuang dalam Rencana
Pembelajaran Semester (RPS). Adapun materi yang jelaskan pada jobsheet ini
mengenal konsep dasar dari struktur data, mengenal perbedaan dasar dari konsep
struktur data dengan konsep algoritma, mengenal bahasa pemrograman C, tipe
data bentukan (abstract data type) yang terdiri dari typedeft dan struct, Array
struct, beberapa teknik sorting data (Insertion Sort, Bubble Sort, Merge Sort,
Selection Sort), beberapa teknik searching data (Sequential Search, Binary
Search, Interpolation Search), menggunakan pointer, menggunakan linked list,
teknik stack, teknik queue, konsep tree, konsep graph.
a. Petunjuk bagi Mahasiswa

1. Baca dan pelajarilah modul praktek sebelum hari pelaksanaan praktek,
pelajari dan pahami langkah-langkah percobaannya.
2. Jika ada langkah-langkah yang belum jelas, tanyakan kepada pengajar
sebelum praktek dimulai.
3. Installah terlebih dahulu program/software yang akan digunakan pada
kegiatan praktek.
4. Bacalah informasi-informasi yang ada berkaitan dengan program/software
guna kelancaran kegiatan praktek.
ix
5. Ikutilah petunjuk-petunjuk yang ada berkaitan dengan penggunaan
program/software tersebut.
6. Setiap mempelajari satu sub kompetensi, Anda harus mulai dari menguasai
pengertian-pengertian dalam uraian materi dan kemudian kerjakan soal soal
yang ada di bagian lembar latihan.
b. Petunjuk bagi Dosen

1. Jumlah keseluruhan materi percobaan ini ada 18 modul praktek yang dapat
dipergunakan untuk satu semester (terdiri dari 18 x pertemuan kegiatan
praktek yang masing-masing memerlukan waktu 3 X 45 menit).
2. Laporan praktek Mahasiswa diserahkan pada awal kegiatan praktek
berikutnya, diserahkan kepada pengajar.
3. Materi untuk UTS dan UAS juga diserahkan kepada pengajar. Disesuaikan
dengan jadwal akademik dan progres pelaksanaan praktek dari kelas yang
bersangkutan.
x
POLITEKNIK NEGERI PADANG
PROGRAM STUDI : MANAJEMEN INFORMATIKA
JUDUL PRAKTEK:
PENGANTAR PRAKTEK STRUKTUR DATA
TOPIK KEGIATAN PRAKTEK:

Konsep Dasar Struktur Data dan 1
Bahasa Pemrograman C
1. Jumlah Jam : 1 Pertemuan

2. Tujuan Praktek :
Mampu memahami konsep dasar dari struktur data dan terbiasa dengan bahasa
pemrograman C
3. Teori Dasar :
Struktur data adalah sebuah bagian dari ilmu pemrograman dasar bertujuan
untuk membuat sebuah struktur penyimpanan data yang digunakan saat
program dijalankan. Struktur data berbeda dengan basis data. Struktur data
berada pada level pemrograman yang digunakan untuk tempat penyimpanan
data yang digunakan oleh program terkait dengan alokasinya di memori.
Struktur alokasi di memori untuk menyimpan data yang sedang digunakan oleh
program inilah fokus dari struktur data. Struktur data bertujuan agar cara
merepresentasikan data dalam membuat program dapat dilakukan secara efisien
dalam pengolahan di memori dan pengolahan penyimpanan dari program ke
storage juga lebih mudah dilakukan. Struktur Data merupakan kelompok item
data yang terorganisasi yang dianggap sebagai suatu unit. Struktur Data disebut
juga sebagai jenis data kompleks (complex data type) atau data aggregates.
Beberapa struktur data :
a. Array (larik) d. List (daftar)
b. String e. Dll
c. Record
1
4. Bahan/Peralatan :
Komputer (Acer S60, Memory (RAM) 1 GB, Processor Dual Core 3 GHz,
HardDisk 80 GB, DVD RW, Monitor 17 “)
Software Bahasa Pemrograman C (CodeBlocks)
5. Langkah Kerja dan Gambar Kerja :

a. Buka CodeBlocks
b. Tulis program-program berikut ini :
Program 1.1
/* -----------------------------------------------------*/
/* Program menentukan nama bulan berdasarkan input angka */
/* -----------------------------------------------------*/
2
Program 1.2
/* ------------------------------------------------------------*/
/* Program mengkonversi nilai detik ke x jam, y menit, z detik */
/* ------------------------------------------------------------*/
Program 1.3
/* --------------------------------------------*/
/* Program menghitung jumlah angka 1 sampai 10 */
/* --------------------------------------------*/
3
Program 1.4
/* ---------------------------------------------------*/
/* Program meminta user memasukkan input tertentu */
/* Jika tidak sesuai perintah input akan terus diulang */
/* ----------------------------------------------------*/
c. Jalankan program-program diatas
6. Latihan :
Buatlah program untuk menentukan bonus akhir tahun karyawan yang terdiri dari
dua golongan. Pertama Staf jika masakerja minimal 5 tahun dan berumur minimal
45 tahun, maka memperoleh bonus Rp 1.000.000,- , jika masakerja minimal 5
tahun dan berumur kecil dari 45 tahun maka memperoleh bonus Rp 700.000,-,
selain syarat tersebut Staf memperoleh bonus Rp 500.000,- . Kedua Non-Staf, jika
masakerja besar dari 5 tahun dan berumur diatas 45 tahun maka memperoleh bonus
Rp 400.000,- , selain syarat tersebut Non-Staf memperoleh bonus Rp 250.000,-.
Golongan, masakerja dan umur dimasukkan oleh user.
4
7. Keselamatan dan Kesehatan Kerja (K3) :
Gunakan alas kaki / sepatu ketika memasuki labor untuk praktek
8. Hasil Pengujian dan Pembahasan :

Hasil Pengujian :
Gambar 1.1 Hasil pengujian program 1.1
Gambar 1.2 Hasil Pengujian program 1.2

Pembahasan :
9. Kesimpulan :
10. Lembar Penilaian :
5
Item Penilaian Bobot Nilai Nilai X Bobot
Persiapan 5%
Datang tepat waktu, kesiapan alat
Proses, sistematika, langkah kerja, 25%
kemandirian, partisipasi, keaktifan
Sikap dan keselamatan kerja, 10%
Sikap menggunakan peralatan, kerapian
Hasil/Data/Produk; 50%
Ketepatan, kebenaran program
Waktu 10%
Total 100%
11. Daftar Pustaka :

1. Rosa A.S,2010, M.Shalahuddin, “Modul Pembelajaran Struktur Data”, Modula
: Bandung
2. Antonius Rachmat C, 2010, “ Algoritma dan Pemrograman dengan Bahasa C”,
Andi Yogyakarta
3. Moh. Sjukani, 2012,” Struktur Data (Algoritma & Struktur Data 1) dengan
C,C++”, Mitra Wacana Media : Jakarta
6
JUDUL PRAKTEK:
TIPE DATA DAN STRING

Tipe Data Bentukan dalam Bahasa 2
Pemrograman C

2. Tujuan Praktek :
Mampu memahami tipe data bentukan dan menerapkannya dalam bahasa
pemrograman C
3. Teori Dasar :
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.
Typedeft
Bahasa C memiliki tipe data numerik dan karakter (seperti int, float, char dll).
Disamping itu juga memiliki tipe data enumerasi dan structure. Bagaimana jika
kita ingin membuat tipe data baru? Untuk pembuatan tipe data baru digunakan
keyword typedef.
Bentuk umum:
typedef <tipe_data_lama> <tipe_data_baru>;
Contoh :
typedef int angka;
typedef float pecahan
7
Struct
Bentuk umum :
typedef struct nama_struct{
tipe_data <nama_var>;
tipe_data <nama_var>;
....
};
Ada 2 cara pendeklarasian struct, yaitu :

Deklarasi 1:
typedef struct Mahasiswa {
char NIM[8];
char nama[50];
float ipk; };
Deklarasi 2 tapa menggunakan typedeft.
struct {
char NIM[8];
char nama[50];
float ipk;
} mhs;
Pada contoh deklarasi 2 diatas berarti kita sudah mempunyai variabel mhs yang
bertipe data struct.
8
a. Buka CodeBlocks
Program 2.1
/* -------------------------------*/
/* Program menentukan lama durasi */
/* -------------------------------*/
#include "stdio.h"
#include "conio.h"
#include "math.h"
void main()
{
typedef struct
{ long int hh;
long int mm;
long int ss;
}jam;
jam j1,j2,j3;
long int konv1,konv2,durasi;
clrscr();
printf("Jam Awal\n");
printf("Jam = "); scanf("%ld",&j1.hh);
printf("Menit = "); scanf("%ld",&j1.mm);
printf("Detik = "); scanf("%ld",&j1.ss);
printf("\nJam Akhir\n");
printf("Jam = "); scanf("%ld",&j2.hh);
printf("Menit = "); scanf("%ld",&j2.mm);
printf("Detik = "); scanf("%ld",&j2.ss);
clrscr();
printf("Jam awal = %ld:%ld:%ld\n",j1.hh,j1.mm,j1.ss);
printf("\nJam akhir = %ld:%ld:%ld\n",j2.hh,j2.mm,j2.ss);
konv1=(j1.hh*3600)+(j1.mm*60)+j1.ss;
konv2=(j2.hh*3600)+(j2.mm*60)+j2.ss;
durasi=abs(konv2-konv1);
j3.hh=durasi/3600;
j3.mm=(durasi%3600)/60;
j3.ss=(durasi%3600)%60;
printf("\nDurasi = %ld:%ld:%ld\n",j3.hh,j3.mm,j3.ss);
getch();
}
9
Program 2.2
/* -----------------------------------*/
/* Program operasi aritmatika pecahan */
/* -----------------------------------*/
#include "stdio.h"
#include "conio.h"
void main()
{
typedef struct
{
int x;
int y;
}pecahan;
pecahan p1,p2,p3;
float hsl;
clrscr();
printf("P1\n");
printf("x = "); scanf("%d",&p1.x);
printf("y = "); scanf("%d",&p1.y);
printf("\nP2\n");
printf("x = "); scanf("%d",&p2.x);
printf("y = "); scanf("%d",&p2.y);
clrscr();
printf("P1 = %d/%d\n",p1.x,p1.y);
printf("P2 = %d/%d\n",p2.x,p2.y);
//penjumlahan
p3.x=(p1.x*p2.y)+(p1.y*p2.x);
p3.y=p1.y*p2.y;
hsl = (float) p3.x/p3.y;
printf("\nP1 + P2 = %d/%d = %0.2f\n",p3.x,p3.y,hsl);
//pengurangan
p3.x=(p1.x*p2.y)-(p1.y*p2.x);
p3.y=p1.y*p2.y;
printf("\nP1 - P2 = %d/%d = %0.2f\n",p3.x,p3.y,hsl);
//perkalian
p3.x=p1.x*p2.x;
p3.y=p1.y*p2.y;
printf("\nP1 * P2 = %d/%d = %0.2f\n",p3.x,p3.y,hsl);
//pembagian
p3.x=p1.x*p2.y;
p3.y=p1.y*p2.x;
printf("\nP1 : P2 = %d/%d = %0.2f\n",p3.x,p3.y,hsl);
return 0;
getch();
}
10
Program 2.3
/* -----------------------------------------------*/
/* Program operasi aritmatika pecahan dengan menu */
/* -----------------------------------------------*/
#include "stdio.h"
void main()
{
printf("\n\n");
typedef struct
{
int pemb,peny;
}pecahan;
int p,u;
pecahan A,B,kali,tambah,kurang,bagi;
do
{
printf("\t\t\t OPERASI PECAHAN \n\n");
printf("\t\t\t-----------------\n\n");
printf("\n\n");
printf("\t--------------------\n");
printf("\t-- Pilihan Menu : --\n");
printf("\t--------------------\n");
printf("\t 1.Penjumlahan \t2.Pengurangan \n\n");
printf("\t 3.Perkalian \t\t4.Pembagian \n\n");
printf("\n\n");
printf(" Masukkan Pilihan : ");
scanf("%i",&p);
printf("\t----------------\n\n");
system("cls");
if(p==1)
{
do
{
printf("\t\t------------------\n");
printf("\t\t- Penjumlahan -\n");
printf("\t\t------------------\n\n");
printf(" masukkan pembilang 1 : ");
scanf("%i",&A.pemb);
printf("\n\n");
printf(" masukkan penyebut 1 : ");
scanf("%i",&A.peny);
printf("\n\n");
scanf("%i",&B.pemb);
printf("\n\n");
scanf("%i",&B.peny);
printf("\n\n");
printf(" Tampilan Pecahan 1 : ");
printf("%i/%i",A.pemb,A.peny);
11
printf("\n\n");
printf("%i/%i",B.pemb,B.peny);
tambah.pemb=A.pemb*B.peny+B.pemb*A.peny;
tambah.peny=A.peny*B.peny;
printf("\n\n");
printf(" Operasi Pecahan : ");
printf("+");
printf("=");
printf("%i/%i",tambah.pemb,tambah.peny);
printf("\n\n");
printf(" Hasil Penjumlahan : ");
printf("%i/%i",tambah.pemb,tambah.peny);
printf("\n\n");
printf("\t----------------------------------\n");
printf("\t-- Ingin Mengulang ? YES/Back : --\n");
printf("\t-- 1.Yes 2.Back --\n");
printf("\t----------------------------------\n");
printf("\t Pilihan Anda: ");
scanf("%i",&u);
printf("\t---------------\n");
printf("\n\n");
if(u==1)
{
system("cls");
printf(" Silakan Ulangi lagi ..");
printf("\n\n");
}
else//
{
system("cls");
printf("\n\n");
printf(" Kembali ke Awal ...\n\n");
}
}
while (u==1);
}
else if(p==2)
{
do
{
printf("\t\t------------------\n");
printf("\t\t- Pengurangan -\n");
printf("\t\t------------------\n\n");
printf("\n\n");
printf("\n\n");
12
printf("\n\n");
printf("\n\n");
printf("\n\n");
kurang.pemb=A.pemb*B.peny-B.pemb*A.peny;
kurang.peny=A.peny*B.peny;
printf("\n\n");
printf("-");
printf("=");
printf("%i/%i",kurang.pemb,kurang.peny);
printf("\n\n");
printf(" Hasil Pengurangan : ");
printf("%i/%i",kurang.pemb,kurang.peny);
printf("\n\n");
printf("\t----------------------------------\n");
printf("\t----------------------------------\n");
scanf("%i",&u);
printf("\t---------------\n");
printf("\n\n");
if(u==1)
{
system("cls");
printf("\n\n");
}
else//
{
system("cls");
printf("\n\n");
}
}
while(u==1);
}
else if(p==3)
{
do
{
printf("\t\t------------------\n");
13
printf("\t\t- Perkalian -\n");
printf("\t\t------------------\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
kali.pemb=A.pemb*B.pemb;
kali.peny=A.peny*B.peny;
printf("\n\n");
printf("\n\n");
printf("*");
printf("=");
printf("%i/%i",kali.pemb,kali.peny);
printf("\n\n");
printf(" Hasil Perkalian : ");
printf("%i/%i",kali.pemb,kali.peny);
printf("\n\n");
printf("\t----------------------------------\n");
printf("\t----------------------------------\n");
scanf("%i",&u);
printf("\t---------------\n");
printf("\n\n");
if(u==1)
{
system("cls");
printf("\n\n");
}
else//
{
system("cls");
printf("\n\n");
14
}
}
while(u==1);
}
else if(p==4)
{
do
{
printf("\t\t------------------\n");
printf("\t\t- Pembagian -\n");
printf("\t\t------------------\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
printf("\n\n");
bagi.pemb=A.pemb*B.peny;
bagi.peny=A.peny*B.pemb;
printf("\n\n");
printf("%i/%i ",A.pemb,A.peny);
printf(" : ");
printf("=");
printf("%i/%i",bagi.pemb,bagi.peny);
printf("\n\n");
printf(" Hasil Penjumlahan : ");
printf("%i/%i",bagi.pemb,bagi.peny);
printf("\n\n");
printf("\t----------------------------------\n");
printf("\t----------------------------------\n");
scanf("%i",&u);
printf("\t---------------\n");
printf("\n\n");
if(u==1)
{
system("cls");
15
printf("\n\n");
}
else//
{
system("cls");
printf("\n\n");
}
}
while(u==1);
}
else//p>4
{
printf("\t\t\t------------------\n");
printf("\t\t\t-- EXIT....... --\n");
printf("\t\t\t------------------\n");
}
}
while(p<=4);
}
6. Latihan :
Buatlah program untuk menghitung nilai rata-rata mahasiswa dalam bentuk tabel
dengan tampilan output sebagai berikut :
16
Gunakan array struct untuk pembuatan program tersebut.

17
Hasil Pengujian :
18
Pembahasan :
9. Kesimpulan :
19
Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
3. Moh. Sjukani, 2012,” Struktur Data (Algoritma & Struktur Data1) dengan
20
JUDUL PRAKTEK:
TEKNIK SORT

Teknik Sort dalam Bahasa 3
Pemrograman C

2. Tujuan Praktek :
Mampu menerapkan teknik pengurutan (sorting) kedalam bahasa
pemrograman C
3. Teori Dasar :
Pengurutan (sorting) adalah proses menyusun elemen-elemen dengan tata urut
tertentu dan proses tersebut terimplementasi dalam bermacam aplikasi.
Insertion Sort
Salah satu algoritma sorting yang paling sederhana adalah insertion sort.
Teknik ini adalah membandingkan elemen ke-n (n mulai dari 2 hingga elemen
terakhir) dengan elemen-elemen sebelumnya. Bila elemen yang dibandingkan
bernilai kecil, maka tukar posisinya.
Insertion sort adalah sebuah algoritma pengurutan yang membandingkan dua
elemen data pertama, mengurutkannya, kemudian mengecek elemen data
berikutnya satu persatu dan membandingkannya dengan elemen data yang telah
diurutkan.
Bubble Sort
Bubble Sort adalah salah satu algoritma untuk sorting data, atau mengurutkan
data dari yang terbesar ke yang terkecil atau sebaliknya (Ascending atau
Descending).
21
Bubble sort (metode gelembung) adalah metode/algoritma pengurutan dengan dengan
cara melakukan penukaran data dengan tepat disebelahnya secara terus menerus
sampai bisa dipastikan dalam satu iterasi tertentu tidak ada lagi perubahan. Jika tidak
ada perubahan berarti data sudah terurut. Disebut pengurutan gelembung karena
masing-masing kunci akan dengan lambat menggelembung ke posisinya yang tepat.
Bubble sort adalah salah satu metoda sorting atau mengurutkan dari data terkecil ke
data terbesar.
Merge Sort
MergeSort merupakan pengurutan untuk data yang jumlahnya besar, dengan membagi-
bagi menjadi sub-subbgaian mulai dari sedikit elemen hingga keseluruhan elemen
tersebut menjadi data yang sudah urut, dimana data tidak semuanya dapat dimuat
dalam memori utama (main memory), sehingga harus disimpan dalam penyimpanan
sekunder (secondary storage) berupa berkas (file). Sortir ini digunakan bila kapasitas
memori tidak sanggup untuk menampung seluruh data yang akan disortir.
Selection Sort
Selection Sort merupakan memilih elemen maksimum/minimum array, lalu
menempatkan elemen maksimum/minimum itu pada awal atau akhir array (tergantung
pada urutannya ascending/descending). Selanjutnya elemen tersebut tidak disertakan
pada proses selanjutnya.

a. Buka CodeBlocks
22
Program 3.1
/* ----------------------------------------------------------*/
/* Program mengurutkan data array menggunakan insertion sort */
/* ----------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
void main()
{
int L[7];
int i,N;
void v_insertAsc(int A[7],int N);
//input data array
printf("Input Data Array\n");
printf("\nBanyak Data: "); scanf("%i",&N);
for(i=0;i<N;i++)
{
printf("Nilai ke-%i = ",i+1);
scanf("%i",&L[i]); } //end loop i
//panggil procedure v_inAsc
v_insAsc(L,N);
//output data array
printf("Data terurut:\n");
for(i=0;i<N;i++)
{
printf("%5i",L[i]); } //end loop i
printf("\nTekan Enter...\n");
getche();
}
void v_insAsc(int A[7],int N)
{
int k,X,i;
//insertion sort ascending
k=1;
while(k<=N-1)
{
i=k;
X=A[i];
while(i>=1 && A[i-1]>X)
{
A[i]=A[i-1];
i--;
} //endwhile
A[i]=X;
k++;
} //endwhile
}
23
Program 3.2
/* -------------------------------------------------------*/
/* Program mengurutkan data array menggunakan bubble sort */
/* -------------------------------------------------------*/
#include<stdio.h>
#include<stdlib.h>
int main()
{ int a,k,c,d,g;
k=4;
int b[4];
printf(" Mangurutkan data dengan Bubble Sort(Descanding)\n ");

printf("------------------------------------------------\n");
for(a=0;a<k;a++)
{
printf("Masukkan nilai ke-%d : ",a+1);
scanf("%d",&b[a]);
}
for(a=0;a<k-1;a++)
{
for(d=a+1;d<k;d++)
{
c=a;
if(b[c]<b[d])
{
c=d;
}
g=b[c];
b[c]=b[a];
b[a]=g;
}
}
printf("\n setelah diurutkan akan menjadi : \n");
for(a=0;a<k;a++)
{
printf(" %d \n",b[a]);
}
}
Program 3.3
/* -------------------------------------------------------*/
/* Program mengurutkan data array menggunakan merge sort */
/* -------------------------------------------------------*/
24
#include <stdio.h>
#define MAX 10
int Data[MAX];
int temp[MAX];
// Prosedur merge sort

void merge(int Data[], int temp[], int kiri, int tengah, int kanan)
{
int i, left_end, num_elements, tmp_pos;
left_end = tengah - 1;
tmp_pos = kiri;
num_elements = kanan - kiri + 1;
while ((kiri <= left_end) && (tengah <= kanan))

{
if (Data[kiri] <= Data[tengah])
{
temp[tmp_pos] = Data[kiri];
tmp_pos = tmp_pos + 1;
kiri = kiri +1;
}
else
{
temp[tmp_pos] = Data[tengah];
tengah = tengah + 1;
}
}
while (kiri <= left_end)
{
temp[tmp_pos] = Data[kiri];
kiri = kiri + 1;
}
while (tengah <= kanan)
{
temp[tmp_pos] = Data[tengah];
tengah = tengah + 1;
}
for (i=0; i <= num_elements; i++)

{
Data[kanan] = temp[kanan];
kanan = kanan - 1;
}
}
// Prosedur membuat kumpulan data
void m_sort(int Data[], int temp[], int kiri, int kanan)
{
int tengah;
if (kanan > kiri)
25
{
tengah = (kanan + kiri) / 2;
m_sort(Data, temp, kiri, tengah);
m_sort(Data, temp, tengah+1, kanan);
merge(Data, temp, kiri, tengah+1, kanan);
}
}
void mergeSort(int Data[], int temp[], int array_size)

{
m_sort(Data, temp, 0, array_size - 1);
}
int main()
{
int i;
printf(" Merge Sort \n");
printf("------------\n");
printf("Masukkan DATA SEBELUM TERURUT : \n");
for (i = 0; i < MAX; i++)
{
printf ("Data ke %i : ", i+1);
scanf ("%d", &Data[i]);
}
mergeSort(Data, temp, MAX);

printf("\nDATA SETELAH TERURUT : ");
for (i = 0; i < MAX; i++)
printf("%d ", Data[i]);
printf("\n");
//scanf("%d");
return(0);
}
Program 3.4
/* ----------------------------------------------------------*/
/* Program mengurutkan data array menggunakan selection sort */
/* ----------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
void v_SelAsc(int A[],int N);
void v_Tukar(int *P,int *M);
void main()
{
int L[5];
int i,N;
//input data array
26
printf("Banyak Data: ");scanf("%i",&N);
for(i=0;i<N;i++)
{
printf("Data ke-%i: ",i+1);
scanf("%i",&L[i]);
} //end loop i
//memanggil procedure v_SelAsc

v_SelAsc(L,N);
//menampilkan kembali data array

printf("\nData Terurut:\n");
for(i=0;i<N;i++)
{
printf("%3i",L[i]);
} //end loop i
getche();
}
void v_SelAsc(int A[5],int N)

{
int maks,k,j,temp;
for(k=(N-1);k>=0;k--)
{
maks=0;
for(j=0;j<=k;j++)
{
if (A[j] > A[maks])
{ maks=j; } //endif
} //end loop j
v_Tukar(&A[k],&A[maks]);
} //end loop k
} //end procedure v_SelAsc
void v_Tukar(int *P,int *M)

{
int temp;
temp = *P;
*P = *M;
*M = temp;
} //end procedure v_Tukar
27
6. Latihan :
Buatlah program untuk mengurutkan data array dinamis dengan menggunakan metode
insertion sort, bubble sort, merge sort dan selection sort dalam bentuk menu.


Hasil Pengujian :
28
Pembahasan :
9. Kesimpulan :

Persiapan 5%
29
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
30
JUDUL PRAKTEK:
TEKNIK SEARCHING

Teknik Search dalam Bahasa 4
Pemrograman C

2. Tujuan Praktek :
Mampu menerapkan teknik pencarian (searching) kedalam bahasa
pemrograman C
3. Teori Dasar :
Pencarian (searching) adalah sebuah metode pencarian guna menemukan
data/informasi yang sedang dicari didalam sebuah kumpulan data yang
memiliki tipe data sama. Pencarian diperlukan untuk mendapatkan
informasi/data dari kumpulan data yang belum diketahui.
Beberapa metode pencarian data :
a. Sequential Search
Sequential Search adalah metode pencarian sebuah data dari suatu kumpulan
data dimana data dicari dari depan ke belakang atau dari awal sampai akhir data
tanpa harus mengurutkan data atau data tidak harus terurut. Konsepnya yaitu
dengan melakukan perbandingan data satu persatu secara berurutan sampai data
tersebut ditemukan ataupun tidak ditemukan.
31
Proses dalam sequential search :
i. Pertama data melakukan perbandingan satu persatu secara berurutan dalam
kumpulan data dengan data yang dicari sampai data tersebut ditemukan atau
tidak ditemukan.
ii. Pada dasarnya, pencarian ini hanya melakukan pengulangan data dari 1
sampai dengan jumlah data (n).
iii. Setiap pengulangan dibandingkan data ke-I dengan data yang sedang dicari.
iv. Apabila data sama dengan yang dicari, berarti data telah berhasil ditemukan.
Sebaliknya apabila sampai akhir melakukan pengulangan tidak ada data
yang sama dengan data yang dicari, berarti data tidak ada yang ditemukan.
b. Binary Search
Binary Search adalah metode pencarian sebuah data dari suatu kumpulan data,
dimana kumpulan data tersebut harus berurutan dengan benar agar proses
pencarian data bisa dilakukan. Dalam proses pencarian data pada metode ini
data akan dibagi menjadi dua bagian untuk setiap tahap pencariannya.
32
Proses dalam Binary Search :
i. Pertama pengambilan data dimulai dari posisi 1 sampai dengan posisi akhir
(n)
ii. Selanjutnya mencari posisi data yang tengah dengan menggunakan rumus :
(posisi awal + posisi akhir)/2
iii. Setelah itu data yang akan dicari dibandingkan dengan data yang berada di
tengah, apakah data tersebut sama atau lebih kecil atau lebih besar ?
iv. Seandainya data tersebut lebih besar, maka proses pencarian yang dicari
dengan posisi awal adalah posisi tengan + 1.
v. Apabila data lebih kecil, maka proses pencarian yang dicari dengan posisi
akhir adalah posisi tengah – 1.
vi. Jika data sama dengan data yang dicari, berarti data tersebut telah ketemu.
c. Interpolation Search
Proses pencarian data ini hampir sama dengan proses pencarian binary search,
pencarian ini juga dilakukan pada kumpulan data yang sudah urut. Akan tetapi
jika pada binary search kita membagi data menjadi 2 bagian tiap prosesnya,
pada interpolation search kita akan membagi data menurut rumus sebagai
berikut:
Posisi = ( kunci – data[low] / data[high] – data[low] ) * ( high – low ) + low
Singkatnya proses pencarian interpolation search hampir mirip dengan proses
pencarian kata dikamus, yaitu kita mencari data yang dimaksud dengan cara
memperkirakan letak data.
33
a. Buka CodeBlocks
Program 4.1
/* ----------------------------------------------------------*/
/* Program mencari data dalam array secara sequential search */
/* ----------------------------------------------------------*/
#include "stdio.h"
#include "conio.h"
void main()
{
int nilai[10]={10,2,3,10,20,17,5,25,8,26};
int i,x,jum,flag;
printf(" Program Pencarian Data (Sequential Search)\n");

printf("-------------------------------------------\n\n");
printf("Masukkan nilai yang dicari = ");scanf("%d",&x);
printf("\n---Isi Array---\n");
printf(" Indeks ");
for (i=0;i<=9;i++)
{
printf("%4d",i);
}
printf("\n");
printf(" Nilai ");
for (i=0;i<=9;i++)
{
printf("%4d",nilai[i]);
}
printf("\n\n");
i=0;
jum=0;
flag=0;
while (i<=9)
{
if(nilai[i]==x)
{
flag=1;
printf("Nilai %d ada pada indeks ke %d\n",x,i);
jum=jum+1;
}
i++;
}
if(flag!=1)
printf("Data yang dicari tidak ditemukan\n");
printf("Ditemukan sebanyak %d kali\n",jum);

getch();
34
}
Program 4.2
/* -------------------------------------------------------*/
/* Program mencari data dalam array secara binary search */
/* -------------------------------------------------------*/
#include<stdio.h>
#include<conio.h>
int data[10]={15,8,10,9,24,8,17,3,21,2};
int search;
void selection_sort()
{
//Proses pengurutan data dengan metode selection sort
int temp, min, a, b;
for(a=0;a<10;a++)
{
min=a;
for(b=a+1;b<10;b++)
{
if(data[b]<data[min])
{
min=b;
}
}
temp=data[a];
data[a]=data[min];
data[min]=temp;
}
}
void binarysearch()
{
//Proses pencarian data
int awal,akhir,tengah,b_flag=0;
awal=0;
akhir=10;
while(b_flag==0 && awal<=akhir)
{
tengah=(awal+akhir)/2;
if (data[tengah]==search)
{
b_flag=1;
break;
}
else if(data[tengah]<search)
awal=tengah+1;
else
35
akhir=tengah-1;
}
if (b_flag==1)
printf("\nData yang anda cari ditemukan pada index ke-
%d",tengah);
else
printf("\nMaaf, data yang anda cari tidak ditemukan\n");
}
int main()
{
int m;
printf(" Program pencarian data (Binary Search) \n");
printf("----------------------------------------\n");
printf("Daftar Data : \n");
for (m=0;m<10;m++)
{
printf(" %2d ",data[m]);
}
printf("\n\n");
printf("Silahkan inputkan data yang ingin dicari : ");
scanf("%d",&search);
printf("Data telah diurutkan : ");
selection_sort();
for (m=0;m<10;m++)
{
printf(" %2d ",data[m]);
}
binarysearch();
getch();
}
Program 4.3
/* ------------------------------------------------------------*/
/* Program mencari data dalam array secara interpolation search */
/* ------------------------------------------------------------*/
#include<stdio.h>
#include <conio.h>
int main()
{
//deklarasi variable
int A[10], i,j,k,tkr,low,high,pos,tm;
printf(" Program pencarian data (Binary Search) \n");

printf("----------------------------------------\n");
//proses penginputan data
for(i=0;i<10;i++)
{
printf("data ke-%d : ",i+1);
36
scanf("%d",&A[i]);
}
//proses pengurutan data

for(i=0;i<10;i++)
{
for(j=i+1;j<10;j++)
{
if (A[i]>A[j])
{
tkr=A[i];
A[i]=A[j];
A[j]=tkr;
}
}
}
// Menampilkan hasil pengurutan

printf("Data yang telah diurutkan : \n");
for (i=0;i<10;i++)
{
printf("%5d",A[i]);
}
//Input data yang akan dicari clrscr();

printf("\n Masukkan data yang akan anda cari : ");
scanf("%d",&k);
//proses pencarian data

tm=0;
high=9; low=0;
do
{
pos = ((k - A[low]) / (A[high] - A[low]))*(high-low) +
low;
if (A[pos] == k)
{
tm++;
break;
}
if (A[pos] > k)
high = pos-1;
else if (A[pos] < k)
low = pos + 1;
}
while(k >= A[low] && k <= A[high]);
if (tm>0)
{
printf(" data %d yang dicari ada dalam
array\n",k);
printf(" ===================================");
37
}
else
{
printf("data tidak ditemukan dalam array\n");}
//scanf("%d");
return(0);
}
6. Latihan :
a. Buatlah program untuk mencari sebuah data dalam array dinamis dengan
menggunakan metode sequential search, dimana data yang dicari dimasukkan
oleh user.
b. Buatlah program untuk mencari sebuah data dalam array dimana data elemen
array dan data yang dicari dimasukkan manual oleh user dengan menggunakan
metode sequential search.
c. Gabungkan program pada soal latihan (a) dan (b) menjadi sebuah program
menu.
d. Buatlah program untuk mencari sebuah data dalam array dinamis dengan
menggunakan metode binary search, dimana data yang dicari dimasukkan oleh
user.
e. Buatlah program untuk mencari sebuah data dalam array dimana data elemen
metode binary search.
f. Gabungkan program pada soal latihan (d) dan (e) menjadi sebuah program
menu.
g. Buatlah program untuk mencari sebuah data dalam array dinamis dengan
menggunakan metode interpolation search, dimana data yang dicari
dimasukkan oleh user.
38
h. Buatlah program untuk mencari sebuah data dalam array dimana data elemen
metode interpolation search.
i. Gabungkan program pada soal latihan (g) dan (h) menjadi sebuah program
menu.


Hasil Pengujian :
39
40
Pembahasan :
9. Kesimpulan :

Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
41
JUDUL PRAKTEK:
Pointer

Penerapan pointer dalam 5
pemrograman C

2. Tujuan Praktek :
Mampu menerapkan pointer kedalam bahasa pemrograman C
3. Teori Dasar :
Pointer adalah sebuah variabel yang berisikan alamat memori (bukan nilai),
dengan kata lain dapat dikatakan bahwa pointer merupakan suatu variabel
penunjuk ke alamat memori tertentu. Pointer juga disebut sebagai struktur data
yang dinamis karena variable yang di deklarasikan pointer menunjuk pada
lokasi alamat memori tertentu dalam RAM. Jadi variable pointer tidak berisi
suatu nilai tetapi berisi suatu alamat memori tertentu. berikut ilustrasi dari
sebuah pointer.
Gambar 5.1 Pointer P mengarah ke Alamat ke-1 sampai ke-N
42
Dari gambar diatas dapat dilihat bahwa pointer P mengarah ke Alamat ke-1, ini berarti
bahwa nilai dari pointer P adalah alamat ke-1. hal ini tentunya berbeda dengan variabel
biasa yang hanya dapat menyimpan nilai dengan tipe data tertentu. oleh karena itu
pointer juga sering disebut dengan alamat memori, walaupun sebenarnya lebih tepat
disebut sebagai pencatat atau penunjuk alamat memori.
Gambar 5.2 Ilustrasi variabel statis (a) dan dinamis (b)
Seandainya kita memiliki pointer 'P' yang akan menunjuk ke alamat dari variabel 'a'
yang bertipe char, maka situasinya dapat kita ilustrasikan sebagai berikut:
Gambar 5.3 Ilustrasi pointer P yang akan menunjuk ke alamat dari variabel 'a' yang
bertipe char
Bentuk umum deklarasi Pointer dalam Bahasa C:

tipe_data *NamaPointer;
contoh:
int *IMP;
Tipe_data disini menunjukkan bahwa pointer tersebut akan menunjuk ke sebuah alamat
dimana alamat tersebut ditempati oleh nilai yang memiliki tipe data sesuai tipe_data
43
(tipe data deklarasi). Pada contoh diatas pointer IMP akan menunjuk ke alamat yang
ditempati nilai dengan tipe data int saja.
Contoh:
Seandainya kita memiliki variabel x yang bernilai 16 (x = 16), alamat dari nilai variabel
x dapat diketahui dengan queri &x. Untuk mengetahui alamat penyimpanan (alamat
memori) variabel x, kita akan menggunakan variabel bantuan, yaitu alamat_x
(dituliskan sebagai alamat_x = &x). Alamat_x inilah yang disebut variabel pointer, atau
disebut dengan pointer ke x, karena variabel ini menunjuk ke lokasi dimana nilai x (16)
disimpan.
Gambar 5.4 Ilustrasi pointer P
& : Operator deference, mengambil alamat suatu variabel

* : Operator reference, mengambil dari alamat suatu variabel
44
a. Buka CodeBlocks
Program 5.1
/* ------------------------------------------*/
/* Program sederhana pertama tentang pointer */
/* ------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
int I=21,F;
int*IF;
F=I;//nilai variabel F di isi nilai variabel I
IF=&I;//pointer IF menuju alamat memori variabel I
//sekarang alamat memori variabel I dan IF sama
*IF=16;//alamat memori pointer IF di isi 16, sekarang IF
bernilai 16
//pengisian nilai pointer IF langsung melalui alamat memorinya
printf("nilai dari IF=%d\n",*IF);

printf("nilai dari I=%d\n",I);
printf("nilai dari F=%d\n",F);
return 0;
}
Program 5.2
/* -----------------------------------------*/
/* Program sederhana kedua tentang pointer */
/* -----------------------------------------*/
#include <stdio.h>
void main()
{
int b,a=50;
int *pointer1;
pointer1 = &a;//pointer pointer1 menuju alamat memori variabel

a
b = *pointer1;//nilai variabel B di isi nilai dari alamat
pointer pointer1
//jadi nilai variabel B sama dengan nilai dari variabel A, tapi
//alamat memori variabel A dan B berbeda
//jadi nilai B di isi oleh nilai yang berasal dari alamat
pointer pointer1
45
printf("alamat a : %p\n",&a);
printf("alamat b : %p\n",&b);
printf("alamat pointer1 : %p\n\n",pointer1);
printf("isi a : %d\n",a);
printf("nilai dari b : %d\n",b);
printf("nilai yang ditunjuk oleh pointer1 : %d\n",*pointer1);
}
Program 5.3
/* -----------------------------------------*/
/* Program sederhana ketiga tentang pointer */
/* -----------------------------------------*/
#include <stdio.h>
void main(){
int *ptr;
int k;
k=7;
printf("Isi variabel k = %d",k);
printf("\nAlamat variabel k = %d",&k);
printf("\nAlamat variabel *ptr = %d",&ptr);
printf("\nIsi variabel *ptr = %d",ptr);
ptr=&k;
printf("\nAlamat variabel *ptr = %d",&ptr);
printf("\nIsi variabel *ptr = %d",ptr);
printf("\nIsi dari alamat %d = %d",ptr,*ptr);
printf("\n");
}
Program 5.4
/* -----------------------------------------*/
/* Program sederhana keempat tentang pointer */
/* -----------------------------------------*/
#include <stdio.h>
int hitung(int a, int *b){

*b = 15;
return a + *b;
main(){
int y,z,hasil;
y=10;
z=50;
46
printf("Sebelum Jalankan Fungsi\n");
printf("y=%d\n",y);
printf("z=%d\n\n",z);
hasil=hitung(y,&z);
printf("Setelah Jalankan Fungsi\n");
printf("y=%d\n",y);
printf("z=%d\n",z);
printf("hasil=%d\n",hasil);
}
6. Latihan :


Hasil Pengujian :
47

Pembahasan :
9. Kesimpulan :

Persiapan 5%
Waktu 10%
Total 100%
48
: Bandung
Andi Yogyakarta
49
JUDUL PRAKTEK:
Linked List Non Circular

Penerapan Linked List Non Circular 6
dalam pemrograman C

2. Tujuan Praktek :
Mampu menerapkan linked list non circular kedalam bahasa pemrograman C
3. Teori Dasar :
Linked list adalah suatu cara untuk menyimpan data dengan struktur sehingga
dapat secara otomatis menciptakan suatu tempat baru untuk menyimpan data
yang diperlukan. Program akan berisi suatu struct atau definisi kelas yang berisi
variabel yang memegang informasi yang ada didalamnya, dan mempunyai
suatu pointer yang menunjuk ke suatu struct sesuai dengan tipe datanya.
Struktur dinamis ini mempunyai beberapa keuntungan dibanding struktur array
yang bersifat statis. Struktur ini lebih dinamis, karena banyaknya elemen
dengan mudah ditambah atau dikurangi, berbeda dengan array yang ukurannya
bersifat tetap.
Manipulasi setiap elemen seperti menyisipkan, menghapus, maupun
menambah dapat dilakukan dengan lebih mudah.
Konsep dasar struktur data dinamis adalah alokasi memori yang dilakukan
secara dinamis. Pada konsep ini, terdapat suatu struktur yang disebut dengan
struktur referensi diri (self-referential structure), mempunyai anggota pointer
yang menunjuk ke struktur yang sama dengan dirinya sendiri.
Definisi ini dapat dituliskan secara sederhana dengan struktur :
struct node {
50
int info;
struct node *nextPtr;
}
Ilustrasi Struktur Linked List:
Gambar 6.1 Ilustrasi struktur linked list
Pada gambar diatas kita memiliki 4 buah Struktur node, yang masih-masing
menyimpan data dengan nilai 10, 20, 30 dan 40. Pointer P yang terdapat pada Struktur
node ke-1 berisi alamat dari Struktur node ke-2, Pointer P yang ada pada Struktur node
ke-2 berisi alamat dari Struktur node ke-3, dan Pointer P yang ada pada Struktur node
ke-3 berisi alamat dari Struktur node ke-4, Sedangkan Pointer P yang terdapat di
struktur node ke-4 akan berisi NULL, hal ini menunjukkan bahwa struktur node ke-4
berada di akhir rangkaian.

a. Buka CodeBlocks
51
Program 6.1
/* ----------------------------------------------*/
/* Program sederhana pertama tentang Linked List */
/* ----------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct nod {

int data;
struct nod *next;
} NOD, *NODPTR;
void CiptaSenarai(NODPTR *s)

{
*s = NULL;
}
NODPTR NodBaru(int m)
{
NODPTR n;
n = (NODPTR) malloc(sizeof(NOD));
if(n != NULL) {
n -> data = m;
n -> next = NULL;
}
return n;
}
void SisipSenarai (NODPTR *s, NODPTR t, NODPTR p)

{
if (p==NULL) {
t -> next = *s;
*s = t;
}
else {
t -> next = p -> next;
p ->next = t;
}
}
void CetakSenarai (NODPTR s)

{
NODPTR ps;
for (ps = s; ps != NULL; ps = ps -> next)
printf("%d -->", ps -> data);
printf("NULL\n");
}
int main ()
52
{
NODPTR pel;
NODPTR n;
CiptaSenarai(&pel);
n = NodBaru(55);
SisipSenarai(&pel, n, NULL);
n= NodBaru(75);
SisipSenarai(&pel, n, NULL);
CetakSenarai(pel);
return 0;
}
Program 6.2
/* ---------------------------------------------*/
/* Program sederhana kedua tentang Linked List */
/* ---------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <stdlib.h>
typedef struct node {

int lkey;
char name[10];
struct node* next;
} TNODE;
TNODE *first, *last;
int LoadNode(TNODE *p);

void FreeNode(TNODE *p);
void PrintNode(TNODE *p);
void CreateList()
{
TNODE *p;
int n=sizeof(TNODE);
first=last=0;
for(;;)
{
if( (p=(TNODE*)malloc(n))==0 )
{
printf("\nmemori tidak
cukup");
break;
}
if(LoadNode(p)!=1)
53
{
FreeNode(p);
break;
}
p->next=0;
if (first==0)
first=last=p;
else {
last->next=p;
last=p;
}
}
}
int LoadNode(TNODE *p)

{
char opt;
printf("\nMasukkan node baru?");
opt=getche();
opt=toupper(opt);
if(opt!='N') {
puts("\nMasukkan data untuk node:");
printf("\nlkey:\t");
if (scanf("%d",&(p->lkey))!=1) return 0;
printf("\nname:\t");if (scanf("%s",p-
>name)!=1) return 0;
return 1;
}
else
return -1;
}
void FreeNode(TNODE *p) {

free(p);
}
void ViewAllList()
{
TNODE *p;
p=first;
while(p) {
PrintNode(p);
p=p->next;
}
}
TNODE* FindNode(int key)

{
TNODE *p;
p=first;
while(p) {
54
if(p->lkey == key) return p;
p=p->next;
}
return 0;
}
void PrintNode(TNODE *p)

{
if(p) printf("\n%d\t%s",p->lkey,p->name);
}
TNODE* InsertBeforeFirst()
{
TNODE *p;
if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1))
{
if (first==0) {
p->next=0;
first=last=p;
}
else {
p->next=first;
first=p;
}
return p;
}
if(p==0)
printf("\nMemori tidak cukup");
else
FreeNode(p);
return 0;
}
TNODE* InsertBeforeKey(int key)

{
TNODE *p, *q, *q1;
q1=0;
q=first;
while(q) {
if(q->lkey == key) break;
q1=q;
q=q->next;
}
if(q==0) {
printf("\nTidak ada node yang mempunyai
kunci atau senarai kosong");
return 0;
}
if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1)) {
55
if(q==first) {
p->next=first;
first=p;
}
else {
p->next=q;
q1->next=p;
}
return p;
}
if(p==0)
else
FreeNode(p);
return 0;
}
TNODE* InsertAfterKey(int key)
{
TNODE *p, *q;
q=first;
while(q) {
if(q->lkey == key) break;
q=q->next;
}
if(q==0) {
kunci atau senarai kosong");
return 0;
}
{
if(q==last) {
p->next=0;
last->next=p;
last=p;
}
else {
p->next=q->next;
q->next=p;
}
return p;
}
if(p==0)
else
FreeNode(p);
return 0;
}
TNODE* InsertAfterLast()
56
{
TNODE *p;
{
p->next=0;
if (first==0)
first=last=p;
else {
last->next=p;
last=p;
}
return p;
}
if(p==0)
else
FreeNode(p);
return 0;
}
void RemoveFirst()
{
TNODE *p;
if(first==0)
return;
if(first==last) {
FreeNode(first);
first=last=0;
return;
}
p=first;
first=first->next;
FreeNode(p);
}
void RemoveLast()
{
TNODE *p, *q;
if(first==0)
return;
if(first==last) {
FreeNode(first);
first=last=0;
return;
}
q=0;
p=first;
while(p!=last) {
57
q=p;
p=p->next;
}
p=last;
FreeNode(p);
q->next=0;
last=q;
}
void RemoveByKey(int key)

{
TNODE *p, *q;
if(first==0)
return;
q=0;
p=first;
while(p) {
if(p->lkey == key) break;
q=p;
p=p->next;
}
if(!p) {
kunci");
return;
}
if(first==last) {
FreeNode(first);
first=last=0;
return;
}
if(p==first) {
first=first->next;
FreeNode(p);
return;
}
if(p==last) {
q->next=0;
last=q;
FreeNode(p);
return;
}
q->next=p->next;
FreeNode(p);
}
void DeleteList()
{
TNODE *p;
58
p=first;
while(p) {
first=first->next;
FreeNode(p);
p=first;
}
last=0;
}
void main()
{
CreateList();
ViewAllList();
InsertAfterLast();
ViewAllList();
RemoveFirst();
ViewAllList();
InsertAfterKey(1);
ViewAllList();
RemoveByKey(1);
ViewAllList();
DeleteList();
ViewAllList();
}
Program 6.3
/* ------------------------------------------------*/
/* Program sederhana ketiga tentang Linked List */
/* ------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
//definisikan struct
struct SNode{
int data;
struct SNode *next;
struct SNode *before;
};
struct SNode *n_awal, // node awal dari linked list

*n_tampil, //node bantu untuk tampilkan data
*n_bantu; //node bantu untuk insert node baru
int iterasi;
//inisialisasi linked list

void inisialisasi(){
n_awal = NULL;
}
59
//tampilkan linked list
void tampil_list(){
n_tampil = n_awal;
while(n_tampil != NULL){
printf("%d ", n_tampil -> data);
n_tampil = n_tampil -> next;
}
printf("\n");
}
//method untuk insert node baru

void insert_node(int data){
//node baru yang akan di insert

struct SNode *n_insert;
n_insert = (struct SNode *)malloc(sizeof(struct SNode));;
n_insert -> data = iterasi;
n_insert -> next = NULL;
n_insert -> before = NULL;
//kondisi linked list masih kosong

if (n_awal == NULL){
n_awal = n_insert;
} else {
n_bantu = n_awal;
// cari node terakhir

while (n_bantu -> next != NULL){
n_bantu = n_bantu -> next;
}
//hubungkan node terakhir dengan node baru

if(n_bantu -> next == NULL)
{
n_bantu -> next = n_insert;
n_insert -> before = n_bantu;
}
}
}
int main(int argc, char *argv[])

{
inisialisasi();
for(iterasi = 11; iterasi <= 15; iterasi++)

{
insert_node(iterasi);
60
}
tampil_list();
system("PAUSE");
return 0;
}
6. Latihan :
Buatlah program untuk memasukkan beberapa data dalam sebuah senarai (linked
list), jika akan mengakhiri tekan n maka akan muncul semua node yang masuk ke
dalam linked list tersebut.


Hasil Pengujian :
61
Pembahasan :
9. Kesimpulan :

Persiapan 5%
Waktu 10%
Total 100%
62
: Bandung
Andi Yogyakarta
63
JUDUL PRAKTEK:
Linked List Circular

Penerapan Linked List Circular dalam 7
pemrograman C

2. Tujuan Praktek :
Mampu menerapkan Linked List Circular kedalam bahasa pemrograman C
3. Teori Dasar :
Pada single linked list non circular, node terakhirnya menunjuk pada null, maka
pada single linked list circurlar node terakhirnya akan menunjuk ke awal dari
rangkaian linked list. Begitu juga pada Double linked list, dimana pada double
linked list circular node awal akan menunjuk ke node akhir, sedangkan node
akhir akan menunjuk ke node awal. Circular linked list sering disebut linked
list tertutup, sedangkan non circular linked list sering disebut linear linked list.
Gambar 7.1 Single Linked List Circular
Linked List Circular adalah double/single Linked List yang simpul terakhirnya
menunjuk ke simpul awal, dan simpul awalnya menunjuk ke simpul akhir, atau
dapat disebut Linked List yang dibuat seakan-akan merupakan sebuah
lingkaran dengan titik awal dan titik akhir saling bersebelahan, jika Linked List
tersebut masih kosong, ilustrasi Circular Linked List :
64
Gambar 7.2 Single Linked List Circular
Dalam double Linked List ( Linked List berpointer ganda ) dapat mengatasi kelemahan-
kelemahan single Linked List tersebut.
Gambar 7.3 Double Linked List Circular

a. Buka CodeBlocks
Program 7.1
/* -------------------------------------------------------*/
/* Program sederhana pertama tentang Linked List Circular */
/* -------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
65
struct SNode{
int data;
struct SNode *next;
};

int iterasi;

n_awal = NULL;
}

void tampil_list(){
n_tampil = n_awal;
}
printf("\n");
}
//method untuk membuat linked list menjadi circular

void buat_circular(){
n_bantu = n_awal;

}
//membuat linked list menjadi circular

{
n_bantu -> next = n_awal;
}
}


66

n_awal = n_insert;
} else {
n_bantu = n_awal;

}

{
}
}
}

{
inisialisasi();

{
}
tampil_list();
buat_circular();
system("PAUSE");
return 0;
}
Program 7.2
/* ------------------------------------------------------*/
/* Program sederhana kedua tentang Linked List Circular */
/* ------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
67
struct SNode{
int data;
struct SNode *next;
struct SNode *before;
};

int iterasi;

n_awal = NULL;
}

void tampil_list(){
n_tampil = n_awal;
}
printf("\n");
}
//method untuk membuat linked list menjadi circular

void buat_circular(){
n_bantu = n_awal;

}
//membuat linked list menjadi circular

{
n_bantu -> next = n_awal;
n_awal -> before = n_bantu;
}
}

68
n_insert -> before = NULL;

n_awal = n_insert;
} else {
n_bantu = n_awal;

}

{
n_insert -> before = n_bantu;
}
}
}

{
inisialisasi();

{
}
tampil_list();
buat_circular();
system("PAUSE");
return 0;
}
69
6. Latihan :
Buatlah program untuk menggabungkan program 7.1 dan program 7.2 dalam
bentuk menu.


Hasil Pengujian :
Pembahasan :
9. Kesimpulan :

Persiapan 5%
70
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
71
JUDUL PRAKTEK:
Teknik Stack

Penerapan teknik stack dalam 8
pemrograman C

2. Tujuan Praktek :
Mampu menerapkan Teknik Stack kedalam bahasa pemrograman C
3. Teori Dasar :
Secara sederhana tumpukan bisa diartikan sebagai kumpulan data yang seolah-
olah diletakkan di atas data yang lain. Dalam suatu tumpukan akan dapat
dilakukan operasi penambahan (penyisipan) dan pengambilan (penghapusan)
data melalui ujung yang sama, ujung ini merupakan ujung atas tumpukan.
Stack merupakan jenis linked list yang menerapkan konsep LIFO (Last In Fist
Out) artinya elemen daristruktur (node) yang dimasukkan pertama kali ke
dalam rangkaian akan dikeluarkan (diproses) terakhir kali sedangkan elemen
yang masuk terakhir akan diproses / dikeluarkan pertama. Dengan kata lain
setiap transaksi atau aktifitas yang ada dalam stack dilakukan pada kepalanya
(head) saja. Pada stack hanya ada 2 fungsi utama yaitu Push atau
menambah/memasukkan node (struktur) ke dalam stack, dan Pop atau
mengeluarkan/menghapus node dari stack.
cara kerja stack dapat di ilustrasikan sebagai berikut :
| D | ---> atas
|C|
|B|
| A | ---> bawah
72
Ilustrasi diatas merupakan tumpukan data, D sebagai node(struktur) yang atas (terkhir
dimasukkan) dan A sebagai node yang bawah (pertamakali dimasukkan). Jika kita
melakukan operasi Push (menambah), misalnya E, maka penambahan akan dilakukan
pada nilai yang paling atas, yaitu D, sehingga menjadi:
| E | ---> atas
|D|
|C|
|B|
| A | ---> bawah
Sehingga nilai E menjadi nilai atas yang baru, dan jika dilakukan operasi pop, maka
stack akan menjadi seperti gambar yang pertama diatas, yaitu nilai D menjadi nilai atas,
dan nilai E akan dihapus dari tumpukan (stack).
Gambar 8.1 Fungsi Utama Stack
73
a. Buka CodeBlocks
Program 8.1
/* ----------------------------------------*/
/* Program sederhana pertama tentang Stack */
/* ----------------------------------------*/
#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");
//Printf dan Puts memiliki Fungsi yang sama
puts("_____________________________________");
puts("1: Cek kondisi Stack");
puts("2: Tambah data (Push)");
puts("3: Keluarkan isi stack (Pop)");
puts("4: Kosongkan stack");
puts("5: Keluar");
printf("Pilihan Anda: ");
scanf("%d",&pilih);
switch(pilih){
case 1:
if (IsEmpty() == 1)
puts("Stack masih kosong");
else if ((IsEmpty() == 0) && (IsFull() == 0))
puts("Stack sudah terisi (belum penuh)");
else
puts("Stack sudah penuh");
break;
74
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("---Terimakasih---");
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
75
return 0;
}
int IsFull(){
if (tumpukan.top == max)
return 1;
else
return 0;
}
Program 8.2
/* ---------------------------------------*/
/* Program sederhana kedua tentang Stack */
/* ---------------------------------------*/
#include<stdio.h>
#include<conio.h>
#define MAX 5
#define true 1
#define false 0
char stack[MAX];
int top;
void init(void);
int full (void);
int empty (void);
char pop (void);
void clear (void);
void push (char info);
void baca (void);
main()
{
char pilih,elm;
printf("----Operasi Stack----\n");
init();
do
{
printf("operasi stack:\n");
printf("[1] PUSH\n");
printf("[2] POP\n");
printf("[3] CLEAR\n");
printf("[4] BACA\n");
printf("[5] SELESAI...\n");
printf(" Pilihan : ");scanf("%s",&pilih);
switch(pilih)
{
76
case '1': printf("PUSH ");scanf("%s",&elm);push(elm);break;
case '2': elm=pop();printf("POP %c\n",elm);break;
case '3': clear();break;
case '4': baca();break;
case '5': break;
default : printf("Salah pilih...\n");
}
printf("\n");
}while(pilih!='5');
getche();
}
void init(void)
{
top=0;
}
void push(char info)

{
if(full()!=true)
{ top++;
stack[top]=info; }
else printf("Stack overflow...\n");
}
char pop(void)
{
char info;
if(empty()!=true)
{ info=stack[top];
top--;
return(info);
}
else printf("Stack underflow...\n");
}
void clear(void)
{
top=0;
}
int full(void)
{
if(top==MAX) return(true);
else return(false);
}
int empty(void)
{
if(top==0) return(true);
else return(false);
}
77
void baca(void)
{
int i;
printf("isi stack : ");
if(top>0)
{
for(i=1;i<=top;i++)
printf("%c ",stack[i]);
}
else printf("(kosong)");
printf("\n");
}
Program 8.3
/* ---------------------------------------*/
/* Program sederhana ketiga tentang Stack */
/* ---------------------------------------*/
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef enum { FALSE = 0, TRUE = 1} BOOL;
struct nod {
char data;
struct nod *next;
};
typedef struct nod NOD;
BOOL TumpukanKosong(NOD *T) // Uji tumpukan kosong

{
return ((BOOL)(T == NULL));
}
NOD *NodBaru (char item) //Ciptakan Node Baru

{
NOD *n;
n = (NOD*) malloc(sizeof(NOD));
if(n != NULL) {
n->data = item;
n->next = NULL;
}
return n;
}
void CiptaTumpukan (NOD **T)

{
*T = NULL; // Sediakan tumpukan Kosong
78
}
void Push(NOD **T, char item) // Push

{
NOD *n;
n = NodBaru(item);
n->next = *T;
*T = n;
}
char Pop(NOD **T) // Pop

{
NOD *P; char item;
if ( ! TumpukanKosong(*T)) {
P = *T;
*T = (*T)->next;
item = P->data;
free(P);
}
return item;
}
void CetakTumpukan (NOD *T)

{
NOD *p;
printf("T --> ");
for (p = T; p != NULL; p = p->next) {
printf("[%c] --> ", p->data); }
printf("NULL\n");
}
int main()
{
NOD *T;
CiptaTumpukan(&T);
Push(&T, 'I');
Push(&T, 'D');
Push(&T, 'E');
CetakTumpukan(T);
return 0;
}
Program 8.4
/* ----------------------------------------*/
/* Program sederhana keempat tentang Stack */
/* ----------------------------------------*/
#include <stdio.h>
#define MAXSTACK 5
typedef struct{
int item[MAXSTACK];
int count;
79
} stack;
stack tumpukan;
void init(stack *s) {

printf ("**INISIALISASI**");
s->count=0;
}
int isEmpty(stack *s) {

return (s->count == 0);
}
int isFull(stack *s) {

return (s->count == MAXSTACK);
}
void push(stack *s, int dataIn) {

printf("**PUSH DATA %d \n", dataIn);
if (isFull(s) ==1) {
printf("Stack Sudah Penuh !\n\n");
} else {
s->item[s->count]=dataIn;
(s->count)++;
printf("Berhasil masuk %d \n\n", dataIn);
}
}
void pop (stack *s) {

printf("**POP DATA\n");
if (isEmpty(s)) {
printf ("Stack Kosong !\n");
} else {
int dataOut;
int top=(s->count)-1;
dataOut= s->item[top];
s->item[top]=0;
--(s->count);
printf("\t POP : %d\n",dataOut);
}}
void printStack(stack *s) {

printf("Terdapat %d data : \n\t",s->count);
int i=0;
for (i=MAXSTACK-1;i>=0;i--) {
printf("%d | ", s->item[i]);
}
printf("\n\n");
}
int main () {
int pilih,dataIn;
do {
80
printf ("1.Push\n");
printf ("2.POP\n");
printf ("Pilihan: ");
scanf ("%d", &pilih);
if (pilih<1)
printf ("\nPilhan Salah, Silahkan Ulangi Lagi.");
switch (pilih)
{
case 1:
printf ("\nElemen Push : ");
scanf ("%d", &dataIn);
push (&tumpukan, dataIn);
printStack(&tumpukan);
break;
case 2:
pop (&tumpukan);
if(&tumpukan == 0){
printf("\nStack Kosong\n\n");
} else {
printStack (&tumpukan);
}
break;
default:
printf ("\nExit");
}
} while(pilih < 3);
return 0; }
6. Latihan :
a. Buatlah program untuk memasukkan node baru ke dalam tumpukan.
b. Buatlah program untuk menampilkan kode pos (zip code) dari suatu negara
bagian dan kota dan semua informasi tersebut dimasukkan ke dalam sebuah
81
tumpukan. Apabila tidak ada keterangan yang dimasukkan berarti tumpukan
kosong. Tekan q jika akan keluar.
c. Gabungkan program pada soal latihan (a) dan (b) menjadi sebuah program
menu.


Hasil Pengujian :
82
83
84
85
Pembahasan :
9. Kesimpulan :
Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
86
JUDUL PRAKTEK:
Teknik Queue

Penerapan queue dalam pemrograman 9
C

2. Tujuan Praktek :
Mampu menerapkan queue (antrian) kedalam bahasa pemrograman C
3. Teori Dasar :
Pengertian Queue
Queue merupakan jenis Linked list yang menerapkan konsep FIFO (First In
First Out) atau kebalikan dari Stack (LIFO) artinya adalah data yang pertama
kali dimasukkan atau disimpan, maka data tersebut adalah yang pertama kali
akan diakses atau dikeluarkan, pada Queue elemen yang dimasukkan pertama
kali apabila dilakukan pemrosesan maka elemen tersebut yang akan diproses
terlebih dahulu. ilustrasinya seperti saat kita akan membeli tiket di Bioskop,
disitu orang yang datang untuk mengantri pertama kali akan dilayani terlebih
dahulu dan yang mengantri terakhir akan dilayani terakhir.
Terdapat 2 operasi dasar dari queue:
• Enqueue: proses penambahan elemen di posisi belakang
• Dequeue: proses pengambilan elemen di posisi depan Selain operasi dasar di
atas
Queue merupakan kumpulan suatu data yang dimana penambahan data hanya
dapat dilakukan dari sisi belakang dan penghapusan data nya dilakukan pada
posisi depan.
Gambar di bawah ini mengilustrasikan kerja sebuah queue:
87
Gambar 9.1 Ilustrasi kerja queue
Deklarasi queue dalam program

Sebuah queue di dalam program komputer dideklarasikan sebagai sebuah tipe
bentukan baru, di dalam Bahasa C, biasa disebut struct. Sebuah struktur data dari
sebuah queue setidaknya harus mengandung dua tiga variabel, yakni variabel
HEAD yang akan berguna sebagai penanda bagian depan antrian, variabel TAIL
yang akan berguna sebagai penanda bagian belakang antrian dan ARRAY DATA
dari yang akan menyimpan data-data yang dimasukkan ke dalam queue tersebut.
Berikut adalah syntax untuk mendeklarasikan struktur data dari sebuah queue
menggunakan Bahasa C:
typedef struct
{
int HEAD, TAIL;
int data[max+1];
}Queue;
dimana, nilai MAX didefinisikan sebagai jumlah tumpukan maksimum yang dapat
disimpan dalam queue. Setelah struktur data dari queue didefinisikan dengan syntax
di atas, maka setelah itu dapat dibuat variabel-variabel baru yang mengacu pada tipe
88
data Queue di atas, misalkan membuat sebuah variabel bernama antrian yang bertipe
Queue:
Queue antrian; 8
Dalam tulisan ini, sebuah queue 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 HEAD dan
TAIL. Sehingga, jika HEAD dan TAIL berada pada elemen array ke-0, berarti queue
tersebut dalam kondisi kosong (tidak ada data yang disimpan). Berikut adalah
ilustrasi dari sebuah queue kosong dengan ukuran nilai MAX = 8 :

a. Buka CodeBlocks
Program 9.1
/* ----------------------------------------*/
/* Program sederhana pertama tentang queue */
/* ----------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
//Mendefinisikan Maksimal angka yang dapat dimasukkan
89
#define MAX 8
//struct berfungsi untuk menampung informasi - informasi yang

saling berhubungan
typedef struct { int apa[MAX]; int depan; int belakang; }Queue;
Queue antri;
//Fungsi ini berfungsi untuk mengecek ada atau tidaknya Queue

int Kosong(){ if(antri.belakang == -1){return 1;}else{return 0;} }
//Fungsi ini berfungsi untuk mengecek sudah penuh atau tidaknya

Queue
int Penuh(){ if(antri.belakang == MAX-1){return 1;}else{return 0;}
}
//Fungsi ini berfungsi untuk memasukkan data yang akan dimasukkan

void Masukkan(){
int apa;
if(Kosong() == 1){
system("cls");
printf("\n\t\tData yang dimasukkan: ");
scanf("%d", &apa);
antri.depan = antri.belakang = 0;
antri.apa[antri.belakang]=apa;
printf("\n\t\t Data %d sudah masuk!",
antri.apa[antri.belakang]);
} else {
if(Penuh() == 0){
system("cls");
printf("\n\t\tData yang dimasukkan: ");
scanf("%d", &apa);
antri.belakang++;
antri.apa[antri.belakang]=apa;
printf("\n\t\t Data %d sudah masuk!",
antri.apa[antri.belakang]);
}else{ system("cls"); printf("\n\t\tData Penuh!"); }
}
}
//Fungsi ini berfungsi untuk mengeluarkaan data yang terdepan

void Keluarkan(){
system("cls");
int x;
int la = antri.apa[antri.depan];
for(x = antri.depan;x <= antri.belakang-1;x++){
antri.apa[x] = antri.apa[x+1]; printf(" ");
}
antri.belakang--;
if(antri.apa[antri.belakang] != 0){
printf("\n\t\tSatu data keluar.");
} else { printf("\n\t\tTidak ada Data!"); } return la;
}
90
//Fungsi ini berfungsi untuk me-reset data yang ada dengan kata
lain untuk menghapus data
void bersihkan(){
system("cls");
antri.depan = antri.belakang = -1;
printf("\n\t\tData menghilang semua!");
getch();
} else { system("cls"); printf("\n\t\tTidak ada Data!"); getch();
}
}
//Fungsi ini berfungsi untuk melihat data yang sudah dimasukkan

void lihat(){
int f;
system("cls");
printf("\n\t\tLihat data yang Ada: ");
for(f=antri.depan;f<=antri.belakang;f++){
if(antri.apa[f] != 0){
printf("%d", antri.apa[f]);
printf("|");
} else { printf("\tData kosong!"); };
}
getch();
} else { system("cls"); printf("\n\t\tTidak ada Data!"); getch();
}
}
//ini adalah menu programnya

void main() {
system("cls"); int pilih;
antri.depan=-1;
antri.belakang=-1;
do{
printf("\n\n\t\tPilih salah satu: \n");
printf("\n\t\t================= \n\n");
printf("\t\t1. Apakah Data Kosong ?\n");
printf("\t\t2. Apakah Data Penuh ?\n");
printf("\t\t3. Masukkan Data\n");
printf("\t\t4. Keluarkan Data\n");
printf("\t\t5. Lihat Data\n");
printf("\t\t6. Bersihkan Antrian\n");
printf("\t\t7. Selesai\n");
printf("\n\t\tPilihan Anda: ");
scanf("%d", &pilih);
if(pilih == 1) {
system("cls"); if(Kosong() == 1){printf("\n\t\tData masih
Kosong!");} else{printf("\n\t\tTidak Kosong!");}
91
getch(); printf("\n\t\t======== Enter ========"); }
else if(pilih == 2) {
system("cls"); if(Penuh() == 1){printf("\n\t\tData Penuh!");}
else{printf("\n\t\tData tidak Penuh!");}
getch(); printf("\n\t\t======== Enter ========"); }
else if(pilih == 3) { Masukkan(); getch(); printf("\n\t\t========
Enter ========"); }
else if(pilih == 4) { Keluarkan(); getch();
printf("\n\t\t======== Enter ========"); }
else if(pilih == 5) { lihat(); printf("\n\t\t======== Enter
========"); }
else if(pilih == 6) { bersihkan(); printf("\n\t\t======== Enter
========"); }
else if(pilih == 7) { exit(EXIT_SUCCESS); }
else { printf ("\n\t\tPilih yang ada saja..."); getch(); main();
} getch();
}while(pilih >=1 && pilih<=7);
getch();
}
Program 9.2
/* ---------------------------------------*/
/* Program sederhana kedua tentang queue */
/* ---------------------------------------*/
#include "stdio.h"
#include "stdlib.h"
struct bank
{
char nama[20],kode[20],keperluan[20];
float nominal;
};
int main()
{
struct bank data[10];
int pil,n,i,pil2,head=0,tail=0,pil3,m,e=0;
printf("\t\t\t PROGRAM ANTREAN DI KOPERASI\n\n");

awal :
printf(" MENU PILIHAN :\n");
printf("================ \n");
printf("1.INPUT\n");
printf("2.HAPUS\n");
printf("3.LIHAT\n");
printf("4.KELUAR\n\n");
printf("Masukan pilihan : ");scanf("%d",&pil);

system("cls");
92
switch(pil)
{
case 1:
{
if(tail==10)
{
printf("Maaf, Antrean Penuh!!");
}
else
{
input :
printf("jumlah data : ");
scanf("%d",&n);
system("cls");
for(i=0;i<n;i++)
{
printf("Input Data Ke-%d :\n\n",(tail+1)-head);
fflush(stdin);
printf("input nama : ");gets(data[tail].nama);
printf("input keperluan : ");
scanf("%s",&data[tail].keperluan);
printf("input kode : ");
scanf("%s",&data[tail].kode);
printf("input nominal : ");
scanf("%f",&data[tail].nominal); tail++;
printf("\n\n");
}
printf("ingin input lagi (1..2) : "); scanf("%d",&pil2);
if(pil2==1)
{
system("cls"); goto input;
}
else
{
system("cls"); goto awal;
}
}
} break;
case 2: { if(tail==NULL || head==tail)
{
printf("Maaf, tidak ada antrean\n");
system("pause"); system("cls"); goto awal;
}
else
{ printf("penghapusan berhasil\n");
e++; head++;
system("pause");
system("cls"); goto awal;
}
} break;
case 3 :
93
{
if(head==tail || head>tail)
{
printf("Maaf, Tidak Ada Data\n");
system("pause");
system("cls");
goto awal;
}
else
{
lihat :
printf("PILIHAN :\n\n");
printf("1.Lihat semua data\n");
printf("2.Lihat beberapa data\n");
printf("3.kembali\n\n");
printf("Pilihan Anda : ");

scanf("%d",&pil3);system("cls");
if(pil3==1)
{
printf("DATA ANTREAN : \n\n");
for(i=head;i<tail;i++)
{
printf("nama : %s\n",data[i].nama);
printf("kode : %s\n",data[i].kode);
printf("keperluan : %s\n",data[i].keperluan);
printf("nominal : %f\n\n",data[i].nominal);
}
system("pause");
system("cls");
goto lihat;
}
else if(pil3==2)
{
printf("masukan jumlah data : ");
scanf("%d",&m);system("cls");
m=m+e;
if(m<=tail)
{
printf("DATA ANTREAN : \n");
for(i=head;i<m;i++)
{
printf("nama :%s\n",data[i].nama);
printf("kode :%s\n",data[i].kode);
printf("keperluan :%s\n",data[i].keperluan);
printf("nominal :%2f\n\n",data[i].nominal);
}
system("pause");
system("cls");
goto lihat;
}
else
94
{
printf("Maaf, Hanya ada %d data\n",tail-e);
system("pause");
system("cls");
goto lihat;
}
}
else if(pil3==3)
{
system("cls");
goto awal;
}
else
{
printf("Maaf, Kode Yang Anda Masukan Tidak Ada\n\n");
system("cls");
goto lihat;
}
}
}
case 4 :
{
return 0;
}
default :
{
printf("Maaf,kode anda salah\n!");
system("pause");
system("cls");
goto awal;
}
}
Program 9.3
/* ---------------------------------------*/
/* Program sederhana ketiga tentang queue */
/* ---------------------------------------*/
#include "stdio.h"
#include "stdlib.h"
#define MAX 5
int queue[MAX];
int front = -1;
int rear = -1;
void main() {
95
int pil;
system("cls");
while(1){
//clrscr();
printf("\n+-------------------+\n");
printf("| Menu |\n");
printf("+-------------------+\n");
printf("| 1. Insert Queue |\n");
printf("| 2. Delete Queue |\n");
printf("| 3. Display Queue |\n");
printf("| 4. Exit |\n");
printf("+-------------------+\n");
printf("Masukkan Pilihan : ");
scanf("%d", &pil);
switch(pil){
case 1 :
system("cls");
insert();
break;
case 2 :
system("cls");
del();
break;
case 3 :
system("cls");
display();
break;
case 4 :
exit(1);
break;
default :
printf("\nInput Salah !"); } } }
insert() {
int add;
system("cls");
if(rear==MAX-1){
printf("Queue Overflow !!!\n");}
else {
if(front==-1)
front = 0;
printf("Masukkan Nilai Elemen Queue : ");
scanf("%d",&add);
rear=rear+1;
queue[rear] = add; } }
del() {
system("cls");
if (front==-1 || front > rear) {
printf("Queue Underflow \n");
return;
96
} else {
printf("Element Queue yang di Delete adalah : %d \n",
queue[front]);
front=front+1;
getch(); } }
display() {
int i;
system("cls");
if (front == -1){
printf("Queue kosong\n");
}else {
printf("Nilai Element Queue Adalah : \n");
for(i=front;i<=rear;i++){
printf("%d",queue[i]);
printf(" ");} }
getch();
}
Program 9.4
/* ---------------------------------------*/
/* Program sederhana keempat tentang queue */
/* ---------------------------------------*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define n 5
int q[n], f, r, x;
void awal()
{
f=0;
r=-1;
}
void insert()
{
if (r<n-1)
{
r=r+1;
q[r]=x;
}
else
{
printf("ANTRIAN PENUH");
}
}
void deleteq()
97
//hanya menampilkan satu data terdepan
//pakai while kalau mau menampilkan semua data antrian
{
if(f<r+1)
{
x=q[f];
f=f+1;
printf("%d",x);
if((f==r+1) && (r==n-1))

{
awal();
}
}
else
{
printf("ANTRIAN KOSONG");
}
}
void main()
{
int pilih;
awal();
atas:
printf("1. INSERT DATA\n");
printf("2. DELETE DATA\n");
printf("3. EXIT DATA\n\n");
printf("MASUKKAN PILIHAN ANDA : ");
scanf("%d",&pilih);
switch(pilih)
{
case 1 :
if(r<n-1)
{
printf("MASUKKAN BILANGAN : ");
scanf("%d",&x);
insert();
}
else
{
printf("ANTRIAN PENUH");
}
goto atas;
break;
case 2 :
deleteq();
break;
case 3 :
exit;
break;
98
default :
printf("MASUKKAN ANGKA ANTARA 1 SAMPAI 3");
goto atas;
break;
}
getch();
6. Latihan :
a. Buatlah program dalam bentuk menu untuk mengimplementasikan antrian.
Menu tersebut berisi memasukkan data, menghapus data, menampilkan data,
dan keluar
b. Jelaskan perbedaan antara program 9.1, 9.2, 9.3 dan 9.4.


Hasil Pengujian :
99
100
101
102
103
104
Pembahasan :
9. Kesimpulan :

Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
105
106
JUDUL PRAKTEK:
Konsep Tree

10
Penerapan tree dalam pemrograman C

2. Tujuan Praktek :
Mampu menerapkan tree kedalam bahasa pemrograman C
3. Teori Dasar :
Pengertian Tree
Tree merupakan salah satu bentuk struktur data tidak linear yang
menggambarkan hubungan yang bersifat hirarkis (hubungan one to many)
antara elemen-elemen. Tree bisa didefinisikan sebagai kumpulan simpul/node
dengan satu elemen khusus yang disebut root dan node lainnya(disebut
subtree).
Pengertian lain dari tree adalah sebuah struktur data yang secara bentuk
menyerupai sebuah pohon, yang terdiri dari serangkaian node (simpul) yang
saling berhubungan. Node-node tersebut dihubungkan oleh sebuah vektor.
Setiap node dapat memiliki 0 atau lebih node anak (child). Sebuah node yang
memiliki node anak disebut node induk (parent). Sebuah node anak hanya
memiliki satu node induk. Tree bertumbuh ke bawah, tidak seperti pohon di
dunia nyata yang tumbuh ke atas. Dengan demikian node anak akan
digambarkan berada di bawah node induknya.
Pegertian Binary Tree
Dalam tree terdapat jenis-jenis tree yang memiliki sifat khusus, diantaranya
adalah binary tree.
107
Binary tree adalah suatu tree dengan syarat bahwa tiap node (simpul) hanya boleh
memiliki maksimal dua subtree dan kedua subtree tersebut harus terpisah. Tiap node
dalam binary tree boleh memiliki paling banyak dua child (anak simpul), secara khusus
anaknya dinamakan kiri dan kanan.
Binary Tree merupakan himpunan vertex-vertex yang terdiri dari 2 subtree (dengan
disjoint) yaitu subtree kiri dan subtree kanan. Setiap vertex dalam binary tree
mempunyai derajat keluar max = 2.
Kunjungan pada pohon biner
Kunjungan pohon biner terbagi menjadi 3 bentuk binary tree :
1. Kunjungan secara preorder ( Depth First Order), mempunyai urutan :
a. Cetak isi simpul yang dikunjungi ( simpul akar ),
b. Kunjungi cabang kiri,
c. Kunjungi cabang kanan .
2. Kunjungan secara inorder ( symetric order), mempunyai urutan :
a. Kunjungi cabang kiri,
b. Cetak isi simpul yang dikunjungi (simpul akar),
c. Kunjungi cabang kanan .
3. Kunjungan secara postorder, mempunyai urutan :
a. Kunjungi cabang kiri,
b. Kunjungi cabang kanan,
c. Cetak isi simpul yang dikunjungi ( simpul akar ).
Pencarian Pohon Biner
Sebuah Pohon Pencarian Biner (PPB) adalah sebuah pohon biner yang memiliki sifat-
sifat berikut:
a. Setiap node memiliki sebuah nilai.
b. Subpohon kiri dari sebuah node hanya memuat nilai-nilai yang lebih kecil atau
sama dengan nilai dari node.
c. Subpohon kanan dari sebuah node hanya memuat nilai-nilai yang lebih besar atau
sama dengan nilai dari node.
108
Kelebihan utama dari pohon pencarian biner adalah keterkaitannya dengan algoritma
pengurutan dan algoritma pencarian yang dapat lebih efisien, seperti in-order traversal.
Pohon pencarian biner adalah sebuah struktur data dasar yang digunakan untuk
membentuk struktur data yang lebih abstrak seperti set, multiset, dan array asosiatif.
Jika PPB memperkenankan nilai-nilai duplikat, maka PPB merupakan sebuah multiset.
Pohon jenis ini menggunakan ketaksamaan longgar (non-strict inequalities), sehingga
semua yang berada di subpohon bagian kiri dari sebuah node adalah lebih kecil atau
sama dengan nilai dari node, dan semua yang berada di subpohon bagian kanan dari
node adalah lebih besar atau sama dengan nilai dari node.
Jika PPB tidak memperkenankan nilai-nilai duplikat, maka PPB merupakan sebuah set
dengan nilai-nilai unik, sama seperti set pada matematika (himpunan). Pohon tanpa
nilai-nilai duplikat menggunakan ketaksamaan kaku (strict inequalities), artinya
subpohon kiri dari sebuah node hanya memuat node-node dengan nilai yang lebih kecil
dari nilai node, dan subpohon kanan hanya memuat nilai-nilai yang lebih besar.
Beberapa definisi PPB menggunakan sebuah ketaksamaan longgar hanya pada satu
sisi, sehingga nilai-nilai duplikat diperkenankan. Walaupun demikian, definisi-definisi
PPB tersebut membatasi dengan baik bagaiman sebuah pohon dengan banyak nilai
duplikat dapat diseimbangkan.

a. Buka CodeBlocks
109
Program 10.1
/* ---------------------------------------*/
/* Program sederhana pertama tentang tree */
/* ---------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#define info(p) (p)->info
#define left(p) (p)->left
#define right(p) (p)->right
typedef struct treenode *data;
typedef struct treenode{
int info;
data right;
data left;
}node;
data root;
void insert(data *tree, int elem){
//Kamus
data item;
//Algoritma
item = (data) malloc (sizeof(node));
left (item) = right(item) = NULL;
info (item) = elem;
if(!(*tree)){
*tree = item;
return;
}
if(info(item) < info(*tree))
insert(&left(*tree),elem);
else if(info(item) > info(*tree))
insert(&right(*tree), elem);
}
//Buat prosedur inorder, preorder, postorder, main program
void inorder(data *tree){
if(*tree != NULL){
inorder(&left(*tree));
printf(" %d ", info(*tree));
inorder(&right(*tree));
}
}
void preorder(data *tree){
if(*tree != NULL){
preorder(&left(*tree));
preorder(&right(*tree));
}
}
void postorder(data *tree){
if(*tree != NULL){
postorder(&left(*tree));
110
postorder(&right(*tree));
}
}
//Program Utama
int main(){
insert (&root,2);
insert (&root,3);
insert (&root,1);
insert (&root,4);
printf("Inorder : ");
inorder(&root);
printf("\n");
printf("Preorder : ");
preorder(&root);
printf("\n");
printf("Postorder: ");
postorder(&root);
printf("\n");
getch();
return 0;
}
Program 10.2
/* --------------------------------------*/
/* Program sederhana kedua tentang tree */
/* --------------------------------------*/
include "stdio.h"
#include "malloc.h"
#define Nil NULL
struct nod
{
struct nod *left;
char data;
struct nod *right;
};
typedef struct nod NOD;

typedef NOD POKOK;
NOD *NodBaru(char item)

{
NOD *n;
n=(NOD *)malloc(sizeof(NOD));
if(n != Nil)
{
n -> data = item;
n -> left = Nil;
n -> right = Nil;
111
}
return n;
}
void BinaPokok(POKOK **T)

{
*T = Nil;
}
typedef enum {FALSE = 0, TRUE = 1}bool;

bool PokokKosong (POKOK *T)
{
return ((bool) (T == Nil));
}
void TambahNod(NOD **p, char item)

{
NOD *n;
n=NodBaru(item);
*p=n;
}
void preOrder(POKOK *T)

{
if(!PokokKosong(T))
{
printf(" %c ",T -> data );
preOrder(T -> left);
preOrder(T -> right);
}
}
void inOrder(POKOK *T)

{
if(!PokokKosong(T))
{
inOrder(T -> left);
inOrder(T -> right);
}
void postOrder(POKOK *T)

{
if(!PokokKosong(T))
{
postOrder(T -> left);
postOrder(T -> right);
112
}
int main()
{
printf("Program Traversal pada Tree\n");
printf("****************************\n\n");
POKOK *kelapa;
char buah;
BinaPokok(&kelapa);
TambahNod(&kelapa, buah = 'A');
TambahNod(&kelapa -> left, buah = 'B');
TambahNod(&kelapa -> left -> left, buah = 'C');
TambahNod(&kelapa -> left -> left -> left, buah = 'D');
TambahNod(&kelapa -> left -> left -> left -> right, buah =
'E');
TambahNod(&kelapa -> left -> left -> left -> right -> right,
buah = 'F');
TambahNod(&kelapa -> right, buah = 'G');
TambahNod(&kelapa -> right -> right, buah = 'H');
TambahNod(&kelapa -> right -> right -> left , buah = 'I');
TambahNod(&kelapa -> right -> right -> left -> right, buah =
'J');
printf("Tampilan secara Preorder : ");

preOrder(kelapa);
printf("\n");
printf("Tampilan secara Inorder : ");
inOrder(kelapa);
printf("\n");
printf("Tampilan secara Postorder : ");
postOrder(kelapa);
printf("\n\n");
return 0;
}
Program 10.3
/* --------------------------------------*/
/* Program sederhana ketiga tentang tree */
/* --------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
struct Node{
int data;
Node *kiri;
Node *kanan;
};
int count;
113
void tambah(Node **root, int databaru)
{
if((*root) == NULL){
Node *baru;
baru = new Node;
baru->data = databaru;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data telah Dimasukkan");
}
else if(databaru < (*root)->data)
tambah(&(*root)->kiri,databaru);
else if(databaru > (*root)->data)
tambah(&(*root)->kanan,databaru);
else if(databaru == (*root)->data)
printf("Data sudah ada!!");
}
void preOrder(Node *root){
if(root != NULL){
printf("%d " ,root->data);
preOrder(root->kiri);
preOrder(root->kanan);
}
}
void inOrder(Node *root){
if(root != NULL){
inOrder(root->kiri);
printf("%d ",root->data);
inOrder(root->kanan);
}
}
void postOrder(Node *root){
if(root != NULL){
postOrder(root->kiri);
postOrder(root->kanan);
printf("%d ",root->data);
}
}
void search(Node **root, int cari)
{
printf("Maaf,Data tidak ditemukan!");
}
else if(cari < (*root)->data)
search(&(*root)->kiri,cari);
else if(cari > (*root)->data)
search(&(*root)->kanan,cari);
else if(cari == (*root)->data)
printf("Data ditemukan!!!");
114
}
void hapus(Node **root, int del)
{
printf("Data tidak ada!!");
}
else if(del < (*root)->data)
hapus(&(*root)->kiri,del);
else if(del > (*root)->data)
hapus(&(*root)->kanan,del);
else if(del == (*root)->data)
{
(*root)=NULL;
printf("Data telah Terhapus");
}
}
int main(){
int pil,cari,del;
Node *pohon;
pohon = NULL;
do{
int data;
system("cls");
printf(" PROGRAM TREE LANJUTAN \n");
printf("================================\n");
printf(" 1. Masukkan Data \n");
printf(" 2. Transverse \n");
printf(" 3. Cari \n");
printf(" 4. Hapus \n");
printf(" 5. Clear Data \n");
printf(" 6. Keluar \n");
printf("================================\n");
printf("Masukkan Pilihan Anda : ");
scanf("%d",&pil);
switch(pil){
case 1:
printf("Masukkan data baru : ");
scanf("%d", &data);
tambah(&pohon,data);
break;
case 2:
printf("\nPreOrder : ");
if(pohon!=NULL) preOrder(pohon);
else printf("Data masih kosong");
printf("\ninOrder : ");
if(pohon!=NULL) inOrder(pohon);
printf("\npostOrder : ");
if(pohon!=NULL) postOrder(pohon);
break;
case 3:
115
printf("Cari data : ");
scanf("%d", &cari);
search(&pohon,cari);
break;
case 4:
printf("Hapus data : ");
scanf("%d", &del);
hapus(&pohon,del);
break;
case 5:
pohon = NULL;
printf("Semua data telah terhapus");
break;
case 6:
return 0;
default:
printf("Maaf, pilihan Anda Salah");
}
getch();
}while(pil!=7);
}
Program 10.4
/* --------------------------------------*/
/* Program sederhana keempat tentang tree */
/* --------------------------------------*/
#include<stdio.h>
typedef struct node{
char data;
node *kiri;
node *kanan;
};
node *akar=NULL;
addNode(node **akar, char isi) {
if((*akar)==NULL){
node *baru;
baru= new node;
baru->data = isi;
baru->kiri = NULL;
baru->kanan = NULL;
(*akar)=baru;
}
}
preOrder(node *akar) {
if(akar !=NULL) {
printf("%c ", akar->data);
preOrder(akar->kiri);
preOrder(akar->kanan);
116
}
}
inOrder(node *akar) {
if(akar !=NULL) {
inOrder(akar->kiri);
inOrder(akar->kanan);
}
}
postOrder(node *akar) {
if(akar !=NULL) {
postOrder(akar->kiri);
postOrder(akar->kanan);
}
}
main(){
char abjad;
printf("\n\n\tPosisi Awal Tree:\n\n");
printf("\t R\n\t / \\\n\t A E\n\t /\n\t S\n\t
/ \\\n\t I T\n\n");
addNode(&akar,abjad='R');
addNode(&akar->kiri,abjad='A');
addNode(&akar->kanan,abjad='E');
addNode(&akar->kiri->kiri,abjad='S');
addNode(&akar->kiri->kiri->kiri,abjad='I');
addNode(&akar->kiri->kiri->kanan,abjad='T');
printf("Tampilan PreOrder : ");
preOrder(akar);
printf("\nTampilan InOrder : ");
inOrder(akar);
printf("\nTampilan PostOrder : ");
postOrder(akar);
}
6. Latihan :
a. Buatlah program untuk menampilkan PreOrder, InOrder dan PostOrder dari
tree berikut ini :
117
(Elemen tree dimasukkan oleh user)
b. Buatlah program untuk menampilkan PreOrder, InOrder dan PostOrder dari
tree pada gambar soal a dimana elemen tree bukan user yang memasukkan.


Hasil Pengujian :
118
119
Pembahasan :
9. Kesimpulan :

Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
120
JUDUL PRAKTEK:
Konsep Graph

Penerapan graph dalam pemrograman 11
C

2. Tujuan Praktek :
Mampu menerapkan graph kedalam bahasa pemrograman C
3. Teori Dasar :
Graf adalah kumpulan noktah (simpul) di dalam bidang dua dimensi yang
dihubungkan dengan sekumpulan garis (sisi). Graph dapat digunakan untuk
merepresentasikan objek-objek diskrit dan hubungan antara objek-objek
tersebut. Representasi visual darigraph adalah dengan menyatakan objek
sebagai noktah, bulatan atau titik (Vertex), sedangkan hubungan antara objek
dinyatakan dengan garis (Edge).
G = (V, E)
Dimana
G = Graph
V = Simpul atau Vertex, atau Node, atau Titik
E = Busur atau Edge, atau arc
Graf merupakan suatu cabang ilmu yang memiliki banyak terapan. Banyak
sekali struktur yang bisa direpresentasikan dengan graf, dan banyak masalah
yang bisa diselesaikan dengan bantuan graf. Seringkali graf digunakan untuk
merepresentasikan suaru jaringan. Misalkan jaringan jalan raya dimodelkan
graf dengan kota sebagai simpul (vertex/node) dan jalan yang menghubungkan
setiap kotanya sebagai sisi (edge) yang bobotnya (weight) adalah panjang dari
121
jalan tersebut.
Ada beberapa cara untuk menyimpan graph di dalam sitem komputer. Struktur
data bergantung pada struktur graph dan algoritma yang digunakan untuk
memmanipulasi graph. Secara teori salah satu dari keduanya dapat dibedakan antara
struktur list dan matriks, tetapi dalam penggunaannya struktur terbaik yang sering
digunakan adalah kombinasi keduanya.
a. Graph tak berarah (undirected graph atau non-directed graph) :
 Urutan simpul dalam sebuah busur tidak dipentingkan. Misal busur e1 dapat
disebut busur AB atau BA
b. Graph berarah (directed graph) :
 Urutan simpul mempunyai arti. Misal busur AB adalah e1 sedangkan busur BA
adalah e8.
c. Graph Berbobot (Weighted Graph)
 Jika setiap busur mempunyai nilai yang menyatakan hubungan antara 2 buah
simpul, maka busur tersebut dinyatakan memiliki bobot.
 Bobot sebuah busur dapat menyatakan panjang sebuah jalan dari 2 buah titik,
jumlah rata-rata kendaraan perhari yang melalui sebuah jalan, dll.
Gambar 11.1 Contoh Graf Berbobot
122
Representasi graf
Dalam pemrograman, agar data yang ada dalam graph dapat diolah, maka graph harus
dinyatakan dalam suatu struktur data yang dapat mewakili graph tersebut. Dalam hal
ini graph perlu direpresentasikan kedalam bentuk array dan dimensi yang sering
disebut matrix atau direpresentasikan dalam bentuk linked list. Bentuk mana yang
dipilih biasanya tergantung kepada efisiensi dan kemudahan dalam membuat program.
Berikut ini beberapa bentuk representasi graph:
1. Representasi graf dalam bentuk Matrix
a. Adjacency Matrik Graf Tak Berarah
Gambar 11.2 a Gambar 11.2 b

Matrik yang digambarkan pada gambar 11.2b merupakan representasi dalam
bentuk Adjacency Matrik dari graf yang digambarkan pada gambar 11.2a.
Beberapa hal yang dapat dilihat atau dapat diterangkan pada Adjacency Matrik
tersebut adalah sebagai berikut :
1. Matrik yang terbentuk adalah matrik bujur sangkar n x n, dimana n =
jumlah simpul yang ada dalam graf tersebut. Matrik ini menyatakan
hubungan antara simpul satu dengan simpul lainnya.
2. Matrik yang terbentuk adalah matrik simetris dengan sumbu simetris
adalah diagonal dari titik kiri atas ke titik kanan bawah.
3. Data yang tedapat baik dalam baris maupun kolom, dapat menyatakan
degree sebuah simpul. Contoh : baik pada baris D maupun kolom D jumlah
angka 1 nya adalah 3 buah, dimana jumlah ini menyatakan degree simpul
D.
123
b. Adjacency Matrik Graf Berarah

Matrik yang digambarkan pada gambar 2b merupakan representasi dalam bentuk
Adjacency Matrik dari graf yang digambarkan pada gambar 2a. Beberapa hal
yang dapat dilihat atau dapat diterangkan pada Adjacency Matrik tersebut adalah
sebagai berikut :
1. Matrik yang terbentuk adalah matrik bujur sangkar n x n, dimana n =
jumlah simpul yang ada dalam graf tersebut. Matrik ini menyatakan
hubungan antara simpul satu dengan simpul lainnya.
2. Matrik yang terbentuk mungkin simetris mungkin juga tidak simetris.
Menjadi Simetris bila hubungan antara dua buah simpul (v1 dan v2)
terdapat busur dari v1 ke v2 dan juga sebaliknya.
3. Hal pokok yang dinyatakan oleh matrik ini adalah : busur yang ’keluar’
dari suatu simpul. Dengan demikian, data yang terdapat dalam suatu baris,
dapat menyatakan outdegree simpul yang bersangkutan.
Contoh : Jumlah elemen yang nilainya = 1 pada baris B ada 3 elemen,ini
menyatakan jumlah outdegree simpul B adalah 3 buah.
4. Data yang terdapat dalam suatu kolom, dapat menyatakan indegree simpul
bersangkutan.
Contoh : Jumlah elemen yang nilainya 1 pada kolom B ada 2 elemen, ini
menyatakan indegree simpul B adalah 2 buah.
124
c. Adjacency Matrik Graf Berbobot Tak Berarah
Nilai yang ada dalam tiap elemen matrik, menyatakan bobot busur yang
menghubungkan dua buah simpul yang bersangkutan. Untuk dua buah simpul
yang tidak berhubungan langsung oleh sebuah busur, maka dianggap
dihubungkan oleh sebuah busur yang nilai bobotnya tidak terhingga. Dalam
pemograman, karena keperluan algoritma, maka dari total bobot seluruh busur
yang ada atau yang mungkin ada.
Contoh: pada gambar 3a simpul A dan C tidak berhubungan langsung melalui
sebuah busur, maka untuk elemen matrik yang bersangkutan diisi dengan nilai
999 karena nilai 999 dalam kasus ini cukup mewakili nilai tidak terhingga.
2. Representasi graf dalam bentuk Linked List

Adjacency List
125
Bila ingin direpresentasikan dalam bentuk linked list, dapat diilustrasikan secara
sederhana seperti gambar 11.5b. Dari ilustrasi sederhana tersebut terlihat ada 5 buah
simpul A,B,C,D,dan E yang dibariskan dari atas kebawah seperti pada gambar 11.5a.
Kemudian dari masing-masing simpul ’keluar’ pointer kearah kanan yang
menunjuksimpul-simpul lain. Salah satu contoh, yang dapat dilihat pada gambar 4b
dimana A menunjuk simpul B dan simpul D
(a) (b) (c)

Gambar 11.6 (a), (b), (c)
Dalam Adjacency List, kita perlu membedakan antara simpul-vertex dan simpul-edge.
Simpul-vertex untuk menyatakan simpul atau vertex, dan simpul-edge untuk
menyatakan hubungan antar simpul yang biasa disebutbusur. Struktur keduanya bisa
sama, bisa juga tidak sama,tergantung kebutuhan.Untuk memudahkan pembuatan
program, struktur kedua macam simpul dibuat sama seperti yang digambarkan pada
gambar 11.6c. Yang membedakan antara simpul-vertex dan simpul-edge, adalah
anggapan terhadap simpul tersebut. Dalam contoh ini, terlihat struktur simpul dibuat
terdiri dari 3 elemen. Satu elemen untuk INFO, dua elemen untuk pointer.pointer kiri
(left) dan pointer kanan (right)
Struct tipes{
Struct tipes *Left;
int INFO;
Struct tipes *Right;
};
Struct tipes *First,*Pvertex,*Pedge;
126
Bila simpul dianggap sebagai simpul-vertex, maka : Pointer left digunakan untuk
menunjuk simpul berikutnya dalam untaian simpul-simpul yang ada,atau diisi NULL
bila sudah tidak ada simpul yang peluditunjuk.Sedangkan pointer Right digunakan
untuk menunjuk simpul edge yang pertama.
Bila Simpul dianggap sebagai simpul-edge, maka : Pointer left digunakan untuk
menunjuk simpul-vertex ‘tujuan’ yang berhubungan dengan simpul-vertex ‘asal’ dan
pointer right digunakan untuk menunjuk simpul-edge berkiutnya bila masih ada, atau
diisi NULL bila tak ada lagi simpul-busur yang ditunjuk.

a. Buka CodeBlocks
Program 11.1
/* ----------------------------------------*/
/* Program sederhana pertama tentang graph */
/* ----------------------------------------*/
#include "stdio.h"
#include "conio.h"
typedef struct tipes {
struct tipes *Left;
int INFO;
struct tipes *Right;
};
typedef struct tipes simpul;
simpul *P,*FIRST,*LAST,*PVertex,*PEdge,*Q,*R,*S;
simpul *PointS[4];
int main(void)
{
//system(cls);
int A[4][4] = { 0,1,0,0, 1,0,1,1,
1,0,0,0, 0,1,1,0 };
127
char NmS[4] = {'A','B','C','D'};
int I,J;
//simpul vertex yang pertama

I=0;J=0;
P=new simpul;
P->INFO = NmS[0];
FIRST = P;
LAST = P;
P->Left = NULL;
P->Right = NULL;
PointS[0] = P;
printf("\n %c",P->INFO);
printf(" alamat %d", PointS[0]);
//simpul vertex yang berikutnya

for(I=1;I<=3;I++)
{P = new simpul;
P->INFO = NmS[I];
LAST->Left = P;
LAST = LAST->Left;
P->Left = NULL;
P->Right = NULL;
PointS[I] = P;
printf("\n %c", P->INFO);
printf(" alamat %d",PointS[I]);
}
//simpul Edge untuk semua vertex

Q = FIRST;
for(I=0;I<=3;I++)
{R=Q;
printf("\nvertex %c .... ", Q->INFO);
for(J=0;J<=3;J++)
{if (A[I][J] != 0)
{
P = new simpul;
P->INFO = A[I][J];
P->Right = P;
P->Left = PointS[J];
printf("\n berhubungan dengan %c",P->Left->INFO);
printf(" bobot %d;", P->INFO);
P->Right = NULL;
R = P;
}
}
printf("\n");
Q = Q->Left;
}
return 0;
}
128
Program 11.2
/* ----------------------------------------*/
/* Program sederhana kedua tentang graph */
/* ----------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#define IN 99
#define N 6
int dijkstra(int cost[][N], int source, int target); //membuat

jalur graf yang nantinya akan dihubungkan oleh jalan yang mempunyai
jarak yang bernilai tertentu
int dijsktra(int cost[][N],int source,int target)
{
int dist[N],prev[N],selected[N]={0},i,m,min,start,d,j;
char path[N];
for(i=1;i< N;i++)
{
dist[i] = IN;
prev[i] = -1;
}
start = source;
selected[start]=1;
dist[start] = 0;
while(selected[target] ==0)
{
min = IN;
m = 0;
for(i=1;i< N;i++)
{
d = dist[start] +cost[start][i];
if(d< dist[i]&&selected[i]==0)
{
dist[i] = d;
prev[i] = start;
}
if(min>dist[i] && selected[i]==0)
{
min = dist[i];
m = i;
}
}
start = m;
selected[start] = 1;
}
start = target;
129
j = 0;
while(start != -1)
{
path[j++] = start+65;
start = prev[start];
}
path[j]='\0';
strrev(path);
printf("%s", path);
return dist[target];
}
int main() //memanggil fungsi-fungsi yang terdapat pada blok

program selanjutnya kemudian untuk menginput serta mencetak output
program tersebut.
{
int cost[N][N],i,j,w,ch,co; //pendeklarasian agar
setiap variable yang digunakan tidak terdapat error serta
menghindari penggunaan variable yang tidak dikenal oleh program.
int source, target,x,y;
printf("\t****Lintaan Algoritma Terpendek (DIJKSRTRA's
ALGORITHM)****\n\n"); //Header program dibuat agar setiap
penggunanya dapet mengerti mengenai program yang mereka kerjakan.
for(i=1;i< N;i++) //dua fungsi for awal untuk me-
looping dari suatu graf yang telah dibuat pada blok program int
dijstra yang mana blok tersebut menggunakan I,,j serta N sebagai
varable
for(j=1;j< N;j++)
cost[i][j] = IN;
for(x=1;x< N;x++)
{
for(y=x+1;y< N;y++)
{
printf(" Masukkan nilai dari
jalur antara simpul %d dan %d: ",x,y);
scanf("%d",&w);
cost [x][y] = cost[y][x] = w;
}
printf("\n");
}
printf("\n Masukkan asal simpul: "); //inputan pada
simpul awal yang akan dicari nilai terdekatnya dengan simpul
berikutnya, dimana &source merupakan variabel dari simpul yang akan
dicari.
scanf("%d", &source);
printf("\n Masukkan target simpul: "); //menginput
target simpul yang akan dicari, dimana variabel &target merupakan
tujuan terakhir untuk mencari nilai terdekatnya.
scanf("%d", &target);
co = dijsktra(cost,source,target);
printf("\n Jalur Terpendek: %d",co);
130
getch();
return(0);
}
Program 11.3
/* ----------------------------------------*/
/* Program sederhana ketiga tentang graph */
/* ----------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#define N 6
int Vertex[N] = {1,2,3,4,5,6};

int Edge[N][N] = {{0,4,0,3,0,5},
{0,0,3,4,4,0},
{0,0,0,2,0,0},
{0,0,0,0,3,0},
{0,0,0,0,0,1},
{0,0,0,0,0,0}};
typedef struct {
int V[N];
int E[N][N];
}GraphTB;
void Jalur(GraphTB G) {
int i, j;
printf("Daftar Garis (Edge) : \n");

for(i=0; i<N; i++)
for(j=i+1; j<N; j++)
if(G.E[i][j]>0)
printf("(%d, %d) = %d\n", G.V[i], G.V[j],
G.E[i][j]);
}
void DataGraph(GraphTB *G) {

int i, j;
for (i=0; i<N; i++)

G->V[i] = Vertex[i];
for (i=0; i<N; i++)

G->E[i][j] = Edge[i][j];
}
void DataGraphRand(GraphTB *G) {

int i,j;
131
for (i=0; i<N; i++)
G->V[i] = Vertex[i];
srand(0); for (i=0; i<N; i++)
G->E[i][j] = rand()/10000*3;
void main() {
GraphTB G, GRand;
DataGraph(&G);
Jalur(G);
DataGraphRand(&GRand);
Jalur(GRand);
}
Program 11.4
/* ----------------------------------------*/
/* Program sederhana keempat tentang graph */
/* ----------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define N 6
int Vertex[N] = {1,2,3,4,5,6};
int Garis[N][N] = {{0,4,0,3,0,5},

{0,0,3,4,4,0},
{0,0,0,2,0,0},
{0,0,0,0,3,0},
{0,0,0,0,0,1},
{0,0,0,0,0,0}};
typedef struct edge {

int bobot;
int VTujuan;
struct edge *next;
}Edge;
typedef struct {
int V[N];
Edge *EFront, *ERear;
}GraphTB;
void Jalur(GraphTB *G, int i) {
132
printf("\n%d : ", G->V[i]);
while(G->EFront != NULL) {
printf("-----> %d, %d : ", G->EFront->bobot, G->EFront-
>VTujuan);
G->EFront = G->EFront->next;
}
}
void DataGraph(GraphTB *G, int i) {

int j;
Edge *ptr;
for (j=0; j<N; j++) {

G->V[j] = Vertex[j];
}
for(j=i+1; j<N; j++) {
if (Garis[i][j]>0) {
ptr=(Edge *) malloc (sizeof(Edge));
ptr->bobot = Garis[i][j];
ptr->VTujuan = G->V[j];
ptr->next = NULL;
if(G->EFront == NULL)
G->EFront = G->ERear =ptr;
else
{
G->ERear->next = ptr;
G->ERear = ptr;
}
}
}
}
void DataGraphRand(GraphTB *G, int i) {

int j;
Edge *ptr;
int BilRand;
for (j=0; j<N; j++) {

G->V[j] = Vertex[j];
}
for(j=i+1; j<N; j++) {
BilRand = rand()/10000;
if (BilRand>0) {
ptr=(Edge *) malloc (sizeof(Edge));
ptr->bobot = BilRand;
ptr->VTujuan = G->V[j];
ptr->next = NULL;
if(G->EFront == NULL)
G->EFront = G->ERear =ptr;
else
133
{
G->ERear->next = ptr;
G->ERear = ptr;
}
}
}
}
void main() {
GraphTB G[N], GRand[N];
int i;
srand(0);
printf("\nDaftar Garis (Edge) : \n");

for(i=0; i<N; i++) {
G[i].EFront=NULL;
DataGraph(&G[i], i);
Jalur(&G[i], i);
}
for(i=0; i<N; i++) {

GRand[i].EFront=NULL;
DataGraphRand(&GRand[i], i);
Jalur(&GRand[i], i);
}
}
6. Latihan :
a. Buatlah program matriks adjacency pada graf tak berarah dengan pembobot.
b. Buatlah program untuk list adjacency pada graf tak berarah dengan pembobot.


Hasil Pengujian :
134
135
Pembahasan :
9. Kesimpulan :
136
Persiapan 5%
Waktu 10%
Total 100%

: Bandung
Andi Yogyakarta
137

Struktur Data

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Struktur Data

Diunggah oleh

Hak Cipta:

Format Tersedia

LEMBARAN IDENTITAS DAN PENGESAHAN

PENYUSUNAN MODUL PRAKTEK

1. Judul : Praktek Struktur Data

Mengetahui, Padang, 30 November 2016

Ervan Asri, M. Kom Rasyidah, S.Si., MM .

Drs. Albar, MKom

Padang, November 2016

a. Identitas Mata Kuliah

HALAMAN JUDUL ............................................................................................... i

DAFTAR ISTILAH ............................................................................................. xiv

Gambar 1.1 Hasil pengujian program 1.1 .............................................................. 5

Jobsheet ini dibuat sebagai bahan acuan materi dan pelaksanaan

a. Petunjuk bagi Mahasiswa

b. Petunjuk bagi Dosen

TOPIK KEGIATAN PRAKTEK:

1. Jumlah Jam : 1 Pertemuan

Software Bahasa Pemrograman C (CodeBlocks)

5. Langkah Kerja dan Gambar Kerja :

c. Jalankan program-program diatas

8. Hasil Pengujian dan Pembahasan :

Gambar 1.1 Hasil pengujian program 1.1

Gambar 1.2 Hasil Pengujian program 1.2

Gambar 1.3 Hasil pengujian program 1.3

Gambar 1.4 Hasil pengujian program 1.4

10. Lembar Penilaian :

11. Daftar Pustaka :

TOPIK KEGIATAN PRAKTEK:

1. Jumlah Jam : 1 Pertemuan

Ada 2 cara pendeklarasian struct, yaitu :

Software Bahasa Pemrograman C (CodeBlocks)

c. Jalankan program-program diatas

7. Keselamatan dan Kesehatan Kerja (K3) :

Gambar 2.1 Hasil pengujian program 2.1

Gambar 2.2 Hasil Pengujian program 2.2

11. Daftar Pustaka :

TOPIK KEGIATAN PRAKTEK:

1. Jumlah Jam : 2 Pertemuan

Software Bahasa Pemrograman C (CodeBlocks)

5. Langkah Kerja dan Gambar Kerja :

printf(" Mangurutkan data dengan Bubble Sort(Descanding)\n ");

// Prosedur merge sort

while ((kiri <= left_end) && (tengah <= kanan))

for (i=0; i <= num_elements; i++)

void mergeSort(int Data[], int temp[], int array_size)

mergeSort(Data, temp, MAX);

//input data array

//memanggil procedure v_SelAsc

//menampilkan kembali data array

void v_SelAsc(int A[5],int N)

void v_Tukar(int *P,int *M)

c. Jalankan program-program diatas

7. Keselamatan dan Kesehatan Kerja (K3) :

8. Hasil Pengujian dan Pembahasan :

Gambar 3.1 Hasil pengujian program 3.1

Gambar 3.2 Hasil Pengujian program 3.2

Gambar 3.4 Hasil pengujian program 3.4

10. Lembar Penilaian :

11. Daftar Pustaka :

TOPIK KEGIATAN PRAKTEK:

1. Jumlah Jam : 2 Pertemuan

Software Bahasa Pemrograman C (CodeBlocks)

printf(" Program Pencarian Data (Sequential Search)\n");

printf("Ditemukan sebanyak %d kali\n",jum);

printf(" Program pencarian data (Binary Search) \n");

void v_Tukar(int P,int M)

TNODE first, last;