ARRAY
Array
adalah kumpulan data-data beripe sama dan menggunakan nama yang sama.
Dengan menggunakan array, sejumlah variabel dapat memakai nama yang sama.
Antara satu variabel dengan
variabel yang lain di dalam array dibedakan berdasarkan subscript. Sebuah
subscript berupa bilangan didalam tanda kurung siku.
Melalui subscript
inilah masing-masing elemen array dapat diakses.
Nilai subscribe
pertama secara default adalah 0.
·
Reperensi
Array
Misalkan kita memiliki sekumpulan data ujian
seorang siswa, ujian pertama bernilai 90, kemudian 95,78,85. Sekarang
kita ingin menyusunnya sebagai suatu data kumpulan ujian seorang siswa.
Dalam array kita menyusunnya sebagai berikut:
ujian[0] = 90;
ujian[1] = 95;
ujian[2] = 78;
ujian[3] = 85;
Empat pernyataan diatas
memberikan nilai kepada array ujian. Tetapi sebelum kita memberikan nilai
kepada array, kita harus mendeklarasikannya terlebih dahulu, yaitu :
int ujian[4];
Pemrogram juga dapat
menginisialisasi array sekaligus mendeklarasikannya, sebagai contoh :
int
ujian[4] = {90,95,78,85};
·
Array
2 Dimensi
Karena fungsi sizeof() mengembalikan
jumlah byte yang sesuai dengan argumennya, maka operator tersebut dapat
digunakan untuk menemukan jumlah elemen array, misalnya
int array[ ] = {26,7,82,166};
cout<<sizeof(array)/sizeof(int);
Akan
mengembalikan nilai 4, yaitu sama dengan jumlah elemen yang dimiliki array
array.
·
Melewatkan
Array Sebagai Argumen fungsi
Array dapat dikirim dan dikembalikan
oleh fungsi Pada saat array dikirim ke dalam fungsi, nilai aktualnya dapat
dimanipulasi.
Contoh :
#include <iostream.h>
void ubah(int x[]);
void main()
{
int ujian[] = {90,95,78,85};
ubah(ujian);
cout<<" Elemen kedua dari array ujian adalah
"<<ujian[1]<<endl;
}
void ubah(int x[])
{
x[1] = 100;
}
Keluarannya : Elemen kedua dari array
ujian adalah 100
STRUCT Dalam C++
• In:
C++
• Comment!
Definisi Struktur (struct) sendiri
adalah kumpulan dari variabel yang dinyatakan dengan sebuah nama , dengan sifat
setiap variabel dapat memiliki tipe yang berlainan.
Dalam pemrograman C++, jika kita membuat
suatu program yang memerlukan berbagai tipe data yang akan digunakan. Tentunya
dengan nama variable yang banyak pula. Dalam program yang sederhana, jika kita
manggunakan sedikit variable tentu tidak jadi masalah. Akan tetapi jika kita
akan membuat sebuah program yang lebih kompleks, dengan berbagai macam nama dan
tipe variable dalam pendeklarasianya. Dengan struct, kita bisa mengelompokkan
berbagai nama dan tipe variable tersebut sesuai dengan kelompoknya. Hal ini
tentunya bisa berguna untuk memudahkan dalam mengelompokkan sebuah variable.
Sebagai contoh umum, ada terdapat berbagai nama variable : nama, npm, alamat,
dll. Variabel – variable tersebut dapat kita kelompokkan menjadi satu dengan
nama data_mahasiswa. Kemudian jika terdapat variable mata_kuliah, nilai, sks,
kelas, dll dapat kita kelompokkan menjadi satu dengan nama krs. Itulah sebagian
gambaran umum tentang struct. Masih bingung karena bahasa yang terlalu beribet?
Klo gitu, Langsung saja ke teori. Okey..
Dalam mendeklarasikan struct, ada
beberapa cara penulisan yang biasa digunakan.
Pertama :
struct nama_struct {
tipe_data_1 nama_var_1;
tipe_data_2 nama_var_2;
tipe_data_3 nama_var_3;
……
};
Yang kedua adalah dengan deklarasi
menggunakan typedef.
typedef struct {
tipe_data_1 nama_var_1;
.
.
tipe_data_n nama_var_n;
} nama_struct;
Kemudian untuk mendeklarasikan sebuah
variable dengan tipe data struct yang telah dibuat sebelumnya adalah :
struct tipe_struct nama_variabel;
Jika pendeklarasian struct sebelumnya
menggunakan typedef, maka untuk mendeklarasikan sebuah variable dengan tipe
data struct adalah :
tipe_struct nama_variabel;
Dan untuk mengakses sebuah struct adalah
dengan menggunakan operator titik (.)
nama_var_struct . nama_var_elemen;
NESTED STRUCT
Di dalam sebuah struct dapat
dimungkinkan terdapat sebuah struct lagi. Jadi hal ini dapat diartikan struct
di dalam struct. Hampir mirip nested loop, yaitu for di dalam for.
Contoh :
struct tanggal {
int hari;
int bulan;
int tahun;
};
struct karyawan {
char NIP [10];
char nama [20];
struct tanggal tgl_masuk;
float gaji;
};
STRUCT OF ARRAY
Sebuah struct yang di dalamnya tedapat
variable dengan tipe data array.
Contoh :
struct data {
char nama[20];
char alamat[100];
};
ARRAY OF STRUCT
Sebuah array yang setiap data elemennya
bertipe struct. Umumnya dipakai untuk menyimpan object data yang terstruktur,
misal: data mahasiswa, karyawan, buku, barang, dsb.
Contoh :
typedef struct {
char npm [10];
char nama [20];
char alamat [30];
unsigned angkatan;
float ipk;
} mahasiswa ;
mahasiswa data[100];
// deklarasi var, menyiapkan 100 data
dengan tipe data mahasiswa (struct yang telah dibuat sebelumnya).
CONTOH PROGRAM
Program untuk memasukkan data mahasiswa.
Source code :
#include “stdio.h”
#include “string.h”
#include “conio.h”
typedef struct {
char npm [10];
char nama [20];
char alamat [30];
int angkatan;
float ipk;
} mhs ;
void main()
{
mhs student[100];
char lagi = ‘y’; int i;
for( i = 0; lagi == ‘y’; i++)
{
printf(“nNPM = “); gets(student[i].npm);
printf(“Nama = “);
gets(student[i].nama);
printf(“Alamat = “);
gets(student[i].alamat);
printf(“Angkatan = “); scanf(“%i”,
&student[i].angkatan);
printf(“IPK = “); scanf(“%f”,
&student[i].ipk);
printf(“nMasukkan Lagi (y/t) ? “); lagi
= getche(); flushall();
}
printf(“nnData yang sudah dimasukkan
adalah:n”);
for( int j = 0; j < i; j++)
{
printf(“nNPM : %s”, student[j].npm);
printf(“nNama : %s”, student[j].nama);
printf(“nAlamat : %s”,
student[j].alamat);
printf(“nAngkatan : %i”,
student[j].angkatan);
printf(“nIPK : %f n”, student[j].ipk);
}
}
OUTPUT PROGRAM
Contoh Program
ANALISA PROGRAM
Dalam program di atas, kita
mendeklarasikan sebuah struct dengan nama mhs. Dalam struct mhs, terdapat lima
variable yang dideklarasikan, yaitu array npm, nama, alamat dengan tipe char,
kemudian angkatan dengan tipe integer, serta ipk dengan tipe float.
Setelah mendeklarasikan sebuah struct,
masuk ke fungsi main. Di dalam fungsi main, terlebih dahulu mendeklarasikan
sebuah array student dengan tipe mhs dengan ukuran 100. Maksudnya kita bisa
menginput sampai dengan 100 data mahasiswa ke dalam array student. Inilah yang
disebut dengan array of struct seperti yang telah dijelaskan sebelumnya.
Kemudian program masuk ke dalam looping
untuk memasukkan data. Maksud dari script gets(student[i].npm); adalah perintah
untuk memasukkan seduah data ke array student yang mengakses variabel npm yang
ada di dalam struct dengan urutan data ke i.
Looping akan berhenti jika user
menginputkan karakter selain ‘y’ yang artinya keluar dari looping. Kemudian
program akan menampilkan data yang sudah diinputkan.
UNION
Union memungkinkan suatu lokasi memori
ditempati oleh 2 atau lebih variabel dengan tipe data berlainan. Jumlah memory
yang diperlukan untuk menampung sebuah variabel union ditentukan oleh field
terbesar. Jika elemen-elemen sebuah union terdiri dari data bertipe integer dan
char maka memory yang dibutuhkan adalah sebesar int. Jika elemen-elemen sebuah
union berupa int, float, dan char maka memory yang diperlukan adalah sebesar
float.
Dalam pendeklarasian union, sama dengan
cara mendeklarasikan sebuah struct. Cara mengakses union juga sama seperti
struct.
Contoh :
union bil_bulat
{
unsigned int no;
unsigned char nama[2];
} ;
Pengertian
Class dalam c++
kelas merupakan suatu tipe data yang
menggabungkan data dan fungsi untuk
mengakses
data. Sebagai contoh suatu kelas kalkulator yang mengandung data
bilangan1
dana bilangan2 dan memiliki fungsi untuk mengakses data tersebut,
seperti:
inisialisasi(), penjumlahan(), pengurangan(), perkalian dan pembagian.
Data
dan fungsi yang berada dalam sebuah kelas dinamakan anggota. Secara lebih
khusus,
data yang terletak dalam kelas dinamakan anggota data dan fungsi yang
berada
dalam kelas disebut anggota fungsi atau fungsi anggota atau terkadang
di
sebut metode
contoh
c++ :
Class
kalkulator
{
private:
int
bolangan1;
int
bilangan2;
public:
void
inisialisai(int bilangan1, int bilangan2);
int
penjumlahan();
int
pengurangan();
int
perkalian();
float
pembagian();
:: OPERASI FILE ::
KONSEP
DASAR
• Bahasa C mendukung penyimpanan dan
pembacaan data dari sebuah file.
• File: sembarang sumber untuk
penyimpanan/pembacaan data, mencakup keyboard, layar/monitor, printer, file
pada disk, dsb.
• Pengaksesan file pada C menggunakan
konsep stream. Stream merupakan penghubung antara programmer dengan file.
• Sebuah stream terhubung dengan file
melalui operasi open dan terputus dari file melalui operasi close.
• Ada dua tipe stream: text (untuk tipe
data karakter) dan biner (untuk sembarang tipe data).
PERINTAH MEMBUKA FILE DAN
MENGHUBUNGKANNYA DENGAN STREAM dengan fopen (library stdio.h) DAN MENUTUPNYA
DENGAN fclose
FILE
*fopen(char *nama_file, char *mode)
FILE
*fclose(FILE *pointer_file)
Mode
merupakan cara pengaksesan file. Berikut daftar mode yang dapat digunakan:
Mode Arti
r Membuka sebuah file teks untuk
pembacaan
w Membuat sebuah file teks untuk
penulisan
a Menambahkan data ke sebuah file teks
rb Membuka sebuah file binary untuk
pembacaan
wb Membuat sebuah file binary untuk
penulisan
ab Menambahkan data ke sebuah file binary
r+ Membuka sebuah file teks untuk
pembacaan/penulisan
w+ Membuat sebuah file teks untuk
pembacaan/penulisan
a+ Menambahkan data/membuat file teks untuk
pembacaan/penulisan
r+b
atau rb+ Membuka sebuah file binary
untuk pembacaan/penulisan
w+b
atau wb+ Membuat sebuah file binary untuk
pembacaan/penulisan
a+b
atau ab+ Menambahkan data ke file binary
untuk pembacaan/penulisan
• Jika operasi open berhasil, fopen()
mengembalikan sebuah file pointer yang valid.
• Jika operasi gagal, maka
fopen()mengembalikan sebuah null pointer, sehingga harus selalu dicek pada saat
pembukaan file. Contoh:
FILE *fp;
if((fp=fopen(“fileku.txt”,”r”)==NULL)
{
printf(“Error
dalam pembukaan file\n”);
exit(1);
}
fclose(fp); //menutup stream file
FUNGSI UNTUK OPERASI FILE TEKS
• fgetc() dan fputc()
Sintaks:
int fgetc(FILE *fp);
int fputc(int ch, FILE *fp);
Contoh:
#include
<stdio.h>
#include
<stdlib.h>
void
main()
{
FILE *fp;
int i;
int ch;
fp = fopen("foo.abc",
"w");//buka file foo.abc untuk ditulisi
for (i=0;i<10;i++) { //loop untuk meletakkan karakter2
fputc('A',fp); //menuliskan karakter A
fputc('\n',fp); //menuliskan pergantian baris
}
fclose(fp);
if((fp = fopen("foo.abc",
"r"))==NULL) {
printf("Error
reading file...\n");
exit(1);
}
while (ch!=EOF) { //baca file sampai tanda EOF (End of File) ch=fgetc(fp); //ambil satu karakter
putchar(ch); //menampilkan karakter ke layar
}
fclose(fp);
}
• fgets() dan fputs()
Sintaks:
int fputs(char *str, FILE *fp);
char *fgets(char *str, int num, FILE
*fp);
Contoh:
#include
<stdio.h>
#include
<stdlib.h>
void
main()
{
FILE *fp;
char ch[14];
fp = fopen("foo.abc",
"w");//buka file foo.abc untuk ditulisi
fputs("String
Contoh",fp);//menuliskan string
fclose(fp);
if((fp = fopen("foo.abc",
"r"))==NULL) {
printf("Error
reading file...\n");
exit(1);
}
puts(fgets(ch,sizeof(ch),fp));//cetak
string di foo ke layar
fclose(fp);
}
• fscanf() dan fprintf()
Mirip dengan sintaks scanf() dan printf()
Dapat digunakan untuk sembarang file
(tidak hanya monitor/layar)
Dapat menggunakan format data
Sintaks:
int fprintf(FILE *fp, const char
*format, …);
int fscanf(FILE *fp, const char
*format, …);
Contoh:
#include
<stdio.h>
#include
<stdlib.h>
void
main()
{
FILE *fp;
int i;
char x[100];
fp = fopen("foo.abc",
"w"); //buka file foo.abc
untuk ditulisi
fprintf(fp, "\nSample
Code\n\n"); //menuliskan sesuatu
for (i = 1; i <= 10 ; i++) {
fprintf(fp, "i = %d\n",
i);
}
fclose(fp);
if((fp=fopen("foo.abc","r"))==NULL)
{
printf("Error
membuka file\n");
exit(1);
}
while(!feof(fp)) {
fscanf(fp,"%s",&x);
puts(x);
}
fclose(fp);
}
• fread() dan fwrite()
Untuk membaca dan menulis blok data
(mis. Karakter, integer, structure, dll)
Untuk dapat menggunakan fwrite(), file
harus dibuka dengan tambahan opsi “b” (binary)
Sintaks: fwrite(void *buffer, int b_byte, int c, file *fp);
fread(void
*buffer, int b_byte, int c, file *fp);
Keterangan:
buffer
: pointer ke area di memori yang
menampung data yg akan dibaca ke file
b_byte
: banyaknya byte data yang
akan dibaca/tulis (dapat menggunakan
sizeof(buffer))
c : banyaknya blok
data yang akan dibaca/ditulis
fp : pointer ke file
Pointer
Pointer (variabel penunjuk) adalah
suatu variabel yang berisi alamat lokasi suatu memori tertentu. Jadi isi dari
variabel pointer merupakan alamat dari lokasi memori yang digunakan untuk
menyimpan data dan bukan nilai data itu sendiri. Misalnya X adalah suatu
variabel biasa yang berisi nilai karakter ‘J’. X bukan variabel pointer. Nilai
dari X ini oleh kompiler C++ akan diletakkan di suatu lokasi memori tertentu.
Nilai ini dapat diakses jika diketahui alamat memorinya. Untuk mengetahui
alamat memori yang digunakan oleh variabel X dalam menyimpan nilai datanya
dapat diketahui dengan ungkapan &X. Alamat tersebut dapat ditulis dengan
mengambil sebuah variabel lagi yang disebut dengan variabel pointer, misalnya:
Alamat_X = &X. Alamat_X adalah variabel pointer karena variabel ini
menunjuk ke lokasi memori di mana nilai data dari variabel X disimpan.
Contoh pada
sebuah baris program berikut:
char
*Alamat_X, X;
X = ‘J’;
Alamat_X =
&X;
Dari baris
program di atas, dapat ditemukan bahwa:
Nilai X =
‘J’
Nilai
Alamat_X = 2527:24C7
Dengan ilustrasi sebagai berikut :
Ini berarti variabel X menyimpan
nilai datanya yaitu ‘J’ pada alamat lokasi memori 2527:24C7. Alamat_X adalah
variabel pointer yang menunjuk pada alamat lokasi memori yang digunakan oleh
variabel X. Sebelum digunakan, variabel pointer harus dideklarasikan terlebih
dahulu dengan diawali suatu asterisk (“*”).
Bahasa C/C++ menyediakan dua buah
operator pointer, yaitu operator ‘&’ dan operator ‘*’. Operator ‘&’
digunakan untuk mendapatkan alamat lokasi memori yang digunakan oleh sebuah
variabel biasa (dalam contoh di atas, &X digunakan untuk mendapatkan alamat
memori yang digunakan oleh variabel X). Sedangkan operator ‘*’ digunakan untuk
mendapatkan nilai data yang ditunjuk oleh variabel pointer pada alamat memori
tersebut.
Contoh 1:
#include
#include
void main()
{
char *Alamat_X, X, Y, Z;
X = 'J';
Alamat_X = &X;
Y = X;
Z = *Alamat_X;
cout<<"Nilai variabel X
adalah "<<
cout<<"Nilai variabel Y
adalah "<<
cout<<"Nilai variabel Z
adalah "<<
cout<<"Nilai variabel X
berada di alamat memori ";printf("%p",Alamat_X);
}
Jika program ini dijalankan, akan
didapatkan hasil:
Pada contoh-contoh di atas, kita
mengalokasikan alamat lokasi memori yang digunakan oleh sebuah variabel pointer
dengan menggunakan variabel bantu (dalam hal ini adalah variabel X). Jika kita
ingin menciptakan sebuah variabel pointer tanpa menggunakan bantuan variabel
biasa, kita harus terlebih dahulu mengalokasikan alamat lokasi memori variabel
pointer yang akan digunakan. Kompiler C++ tidak dapat mengalokasikan secara
otomatis alamat lokasi memori sebuah variabel pointer pada saat pertama kali
variabel tersebut dideklarasikan. Untuk mengatasi hal ini, kita dapat
menggunakan alokasi dinamis yang dapat dilakukan dengan pemanggilan fungsi
standar malloc() dengan prototipenya berada pada file malloc.h. Cara alokasi
dinamis ini akan menggunakan memori yang masih kosong. Fungsi malloc() akan
mengalokasikan secara dinamis blok memori yang masih kosong untuk digunakan
oleh variabel pointer.
Link list
Linked
list (list bertaut) adalah salah satu struktur data dasar yang sangat
fundamental dalam bidang ilmu komputer. Dengan menggunakan linked list maka
programmer dapat menimpan datanya kapanpun dibutuhkan. Linked list mirip dangan
array, kecuali pada linked list data yang ingin disimpan dapat dialokasikan
secara dinamis pada saat pengoperasian program (run-time).
Linked
List sering disebut juga Senarai Berantai
Linked
List saling terhubung dengan bantuan variabel pointer
Masing-masing
data dalam Linked List disebut dengan node (simpul) yang menempati alokasi
memori secara dinamis dan biasanya berupa struct yang terdiri dari beberapa
field.
Operasi-Operasi
yang ada pada Linked List
Insert
Istilah
Insert berarti menambahkan sebuah simpul baru ke dalam suatu linked list.
IsEmpty
Fungsi
ini menentukan apakah linked list kosong atau tidak.
Find
First
Fungsi
ini mencari elemen pertama dari linked list
Find
Next
Fungsi
ini mencari elemen sesudah elemen yang ditunjuk now
Retrieve
Fungsi
ini mengambil elemen yang ditunjuk oleh now. Elemen tersebut lalu dikembalikan
oleh fungsi.
Update
Fungsi
ini mengubah elemen yang ditunjuk oleh now dengan isi dari sesuatu
Delete
Now
Fungsi
ini menghapus elemen yang ditunjuk oleh now. Jika yang dihapus adalah elemen
pertama dari linked list (head), head akan berpindah ke elemen berikut.
Delete
Head
Fungsi
ini menghapus elemen yang ditunjuk head. Head berpindah ke elemen sesudahnya.
Clear
Fungsi
ini menghapus linked list yang sudah ada. Fungsi ini wajib dilakukan bila anda
ingin mengakhiri program yang menggunakan linked list. Jika anda melakukannya,
data-data yang dialokasikan ke memori pada program sebelumnya akan tetap
tertinggal di dalam memori.
Operasi-operasi
untuk Stack dengan Linked List
IsEmpty
Fungsi
memeriksa apakah stack yang adamasih kosong.
Push
Fungsi
memasukkan elemen baru ke dalam stack. Push di sini mirip dengan insert dalam
single linked list biasa.
Pop
Fungsi
ini mengeluarkan elemen teratas dari stack.
Clear
Fungsi
ini akan menghapus stack yang ada.
Operasi-operasi
Queue dengan Double Linked List
IsEmpty
Fungsi
IsEmpty berguna untuk mengecek apakah queue masih kosong atau sudah berisi
data. Hal ini dilakukan dengan mengecek apakah head masih menunjukkan pada Null
atau tidak. Jika benar berarti queue masih kosong.
IsFull
Fungsi
IsFull berguna untuk mengecek apakah queue sudah penuh atau masih bisa
menampung data dengan cara mengecek apakah Jumlah Queue sudah sama dengan
MAX_QUEUE atau belum. Jika benar maka queue sudah penuh.
EnQueue
Fungsi
EnQueue berguna untuk memasukkan sebuah elemen ke dalam queue (head dan tail
mula-mula meunjukkan ke NULL).
DeQueue
Procedure
DeQueue berguna untuk mengambil sebuah elemen dari queue. Hal ini dilakukan
dengan cara menghapus satu simpul yang terletak paling depan (head).
Single
Linked List Circular
Single
Linked List Circular (SLLC) adalah Single Linked List yang pointer nextnya
menunjuk pada dirinya sendiri. Jika Single Linked List tersebut terdiri dari
beberapa node, maka pointer next pada node terakhir akan menunjuk ke node
terdepannya.
Pengertian:
Node
: rangkaian beberapa simpul
Single
: artinya field pointer-nya hanya satu buah saja dan satu arah.
Linked
List : artinya node-node tersebut saling terhubung satu sama lain.
Circular
: artinya pointer next-nya akan menunjuk pada dirinya sendiri sehingga berputar
Deklarasi:
Deklarasi
node dibuat dari struct berikut ini:
typedef
struct TNode{
int
data;
TNode
*next;
};
Pembentukan
node baru
Digunakan
keyword new yang berarti mempersiapkan sebuah node baru
berserta
alokasi memorinya.
TNode
*baru;
baru
= new TNode;
baru->data
= databaru;
baru->next
= baru;
Dibutuhkan
satu buah variabel pointer: head
Head
akan selalu menunjuk pada node pertama
Penambahan
data di depan
Penambahan
node baru akan dikaitan di node paling depan, namun pada saat pertama kali
(data masih kosong), maka penambahan data dilakukan pada head nya.
Pada
prinsipnya adalah mengkaitkan data baru dengan head, kemudian head akan
menunjuk pada data baru tersebut sehingga head akan tetap selalu menjadi data
terdepan. Untuk menghubungkan node terakhir dengan node terdepan dibutuhkan
pointer bantu.
Penambahan
data di depan
void
insertDepan(int databaru){
TNode
*baru,*bantu;
baru
= new TNode;
baru->data
= databaru;
baru->next
= baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else
{
bantu
= head;
while(bantu->next!=head){
bantu=bantu->next;
}
baru->next
= head;
head
= baru;
bantu->next
= head;
}
printf(”Data
masuk\n“);
}
Penambahan
data di belakang
Penambahan
data dilakukan di belakang, namun pada saat pertama kali data langsung ditunjuk
pada head-nya.
Penambahan
di belakang lebih sulit karena kita membutuhkan pointer bantu untuk mengetahui
data terbelakang, kemudian dikaitkan dengan data baru. Untuk mengetahui data
terbelakang perlu digunakan perulangan.
Penambahan
data di belakang
void
insertBelakang (int databaru){
TNode
*baru,*bantu;
baru
= new TNode;
baru->data
= databaru;
baru->next
= baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else
{
bantu
= head;
while(bantu->next
!= head){
bantu=bantu->next;
}
bantu->next
= baru;
baru->next
= head;
}
printf(”Data
masuk\n“);
}
Operasi
Penghapusan
Penghapusan
node dilakukan dengan memutus rantai node kemudian menghapus node. Jika node
berada di tengah rangkaian, rangkaian yang terputus perlu disambung kembali.
Untuk memudahkan penghapusan simpul dibutuhkan dua cursor sebagai simpul bantu.
Selain cursor juga dibutuhkan simpul head sebagai acuan awal simpul dalam
rangkaian.
Berikut
langkah langkah untuk menghapus simpul dalam rangkaian:
Buat cursor bantu yang menunjuk ke awal
node(simpul).
Pindahkan cursor ke node berikutnya
Putus sambungan awal node dengan node
berikutnya.
Hapus rangkaian
Jika berada di akhir rangkaian, putuskan
dari rangkaian sebelumnya
Jika di tengah rangkaian, pindahkan
penunjukan node berikutnya, atau di akhir, atau setelah node yang akan dihapus
Ilustrasi
Hapus Depan
void
hapusDepan (){
TNode
*hapus,*bantu;
if
(isEmpty()==0){
int
d;
hapus
= head;
d
= head->data;
if(head->next
!= head){
bantu
= head;
while(bantu->next!=head){
bantu=bantu->next;
}
head
= head->next;
delete
hapus;
bantu->next
= head;
}else{
head=NULL;
}
printf(“%d
terhapus\n“,d);
}
else printf(”Masih kosong\n“);
}
Ilustrasi
Hapus Belakang
void
hapusBelakang(){
TNode
*hapus,*bantu;
if
(isEmpty()==0){
int
d;
hapus
= head;
if(head->next
== head){
head
= NULL;
}else{
bantu
= head;
while(bantu->next->next
!= head){
bantu
= bantu->next;
}
hapus
= bantu->next;
d
= bantu->data;
bantu->next
= head;
delete
hapus;
}
printf(“%d
terhapus\n“,d);
}
else printf(”Masih kosong\n“);
}
Stack
Ilustrasi
Stack
Terdapat
dua buah kotak yang ditumpuk, kotak yang satu akan ditumpuk diatas kotak yang
lainnya. Jika kemudian stack 2 kotak tadi, ditambah kotak ketiga, keempat,
kelima, dan seterusnya, maka akan diperoleh sebuah stack kotak yang terdiri
dari N kotak.
Ilustrasi
Stack – Cont
OPERASI
PADA STACK
2
operasi dasar yang bisa dilaksanakan
pada
sebuah stack, yaitu:
Operasi Push (menyisipkan data) memasukkan data ke dalam stack
Operasi Pop (menghapus data) menghapus elemen yang terletak pada posisi
paling atas dari sebuah stack
Contoh
program Stack
01 #include <cstdlib>
02 #include <string>
03 #include <iostream>
04
05 using namespace std;
06
07 int top=-1;
08 char stack[2];//asumsi max stack 100
09 char x;
10
11 void push()
12 {
13
cout<<"masukkan satu
karakter: ";
14
cin>>x;
15
top++;
16
stack[top]=x;
17
}
18
19 void pop()
20 {
21
if(top<0)
22
{
23 cout<<"stack
kosong"<<endl;
24 return;
25 }
26
27
x=stack[top];
28
top--;
29
cout<<"karakter yang di 'POP' adalah
"<<x<<endl;
30
}
31
32 void cetak()
33 {
34
if(top<0)
35
{
36 cout<<"stack
kosong" <<endl;
37 return ;
38 }
39
40 int i=0;
41 for(i=top;i>=0;i--)
42 cout<<stack[i]<<endl;
43 }
44
45 int main(int argc, char *argv[])
46 {
47
int input;
48
cout<<"MASUKKAN PILIHAN: "<<endl;
49
cout<<"\tpush=1"<<endl;
50
cout<<"\tpop=2"<<endl;
51
cout<<"\tcetak=3"<<endl;
52
cout<<"\tquit=4"<<endl;
53
while(true)
54
{
55 cout<<"\nMasukan
pilihan: ";
56 cin>>input;
57 if(input==1)
58 {push();}
59 else if(input==2)
60 {pop();}
61 else if(input==3)
62 {cetak();}
63 else if(input==4)
64 {break;}
65 else
66 {
67 cout<<"Perintah '
"<<input<<" tidak dikenal"<<endl;
68 }
69 }
70
71
system("PAUSE");
72
return EXIT_SUCCESS;
73 }
QUEQUE
Queue
merupakan kumpulan data yang penambahan elemennya hanya bisa dilakukan pada
sisi belakang dan penghapusannya hanya bisa dilakukan pada sisi depan. Konsep
utamanya berkebalikan dari stack (tumpukan), yaitu First In First Out. Contoh :
orang antri beli tiket ke bioskop, Mahasiswa antri bayar KRS atau pun nasabah
menganti di bank. Implementasi antrian menggunakan dua pointer, yaitu pointer
yang menunjukkan elemen terdepan dan elemen terakhir.
Operasi
antrian
1.
Menambah elemen baru pada bagian belakang antrian
2.
Menghapus elemen baru pada bagian depan antrian
3.
Melakukan pengecekan apakah antrian kosong. tidak mungkin menghapus antrian
yang sudah kosong.
Nah,
pada program ini melakukan kalkulasi antrian FIFO (Firs In First Out). Namun
dalam program ini tidak menggunakan Function untuk memisahkan proses.
Cara
kerja dari program ini adalah dengan menampilkan 5 menu pilihan diantaranya
adalah :
Push
Pop
Tampilkan Data
Bersihkan Data
Keluar Program
dengan
definisi sebagai berikut :
Push
Memasukkan
satu data ke dalam proses antrian. Bila antrian penuh maka akan ditampilkan
sebuah peringatan bahwa data antrian penuh. Bila antrian kosong maka akan
diminta memasukkan 1 data untuk menjalani antrian.
Pop
Mengeluarkan
satu data dari antrian. Data yang dikeluarkan adalah data yang pertama kali
dimasukkan. Dan untuk antrian sebelumnya akan menempati antrian yang di
keluarkan. Bila data dalam antrian kosong, maka akan ditampilkan peringatan
bahwa data antrian kosong.
Tampilkan
Data
Digunakan
untuk menampilkan semua data dalam antrian.
Bersihkan
Data
Digunakan untuk membersihkan data /
menghapus semua data yang ada di dalam antrian. Bila data dalam antrian kosong,
maka akan ditampilkan peringatan bahwa data kosong. Bila akan melakukan
pembersihan data maka akan ditampilkan peringatan apakah yakin akan menhapus.
Bila dipilih “Y” maka data tersebut semua akan dihapus, bila memilih “N” maka
akan dikembalikan ke pilihan menu. Berikut syntax programnya dalam bahasa
C++:#include <iostream>
using namespace std;
int main(){
int antrian[]={0,0,0,0,0};
int menu, properties;
char konfirmasi;
cout << "==================
MENU PILIHAN ANTRIAN FIFO ==================" << endl;
cout << "== 1. Push /
Masukkan Data
==" << endl;
cout << "== 2. Pop /
Keluarkan Data
==" << endl;
cout << "== 3. Tampilkan
Data
==" << endl;
cout << "== 4. Bersihkan
Data
==" << endl;
cout << "== 5. Keluar
Program ==" << endl;
cout <<
"==============================================================="
<< endl;
cout << "Syarat dan
Ketentuan Berlaku : " << endl;
cout << "- Data Maksimal 5
" << endl;
cout << "- Data Masukan
Harus Berupa Angka selain 0 (nol) " << endl;
cout <<
"==============================================================="
<< endl;
properties = 0;
while (properties == 0){
cout << "Silahkan
pilihan menu = ";
cin >> menu;
switch (menu) {
case 1 : if(antrian[0] != 0){
cout <<
"Maaf data antrian penuh, Anda tidak bisa melakukan PUSH" <<
endl;
cout <<
"=========================================================="
<<endl;
} else {
for (int an=4 ;
an>=0 ; an--){
if
(antrian[an] == 0){
cout
<< "Masukkan Angka = ";
cin
>> antrian[an];
cout
<< "=========================================================="
<<endl;
break;
}
}
}
break;
case 2 : if(antrian[4] == 0){
cout <<
"Maaf data antrian kosong, Anda tidak bisa melakukan POP" <<
endl;
cout <<
"=========================================================="
<<endl;
} else {
int dataAkhir;
dataAkhir = antrian[4];
for (int an=4 ;
an>=1 ; an--){
antrian[an]
= antrian[an-1];
}
antrian[0] = 0;
cout << "Data yang
dikeluarkan adalah = " << dataAkhir <<endl;
cout <<
"=========================================================="
<<endl;
}
break;
case 3 : cout << "Data yang ada dalam
antrian adalah = " << endl;
for(int as=0 ;
as<=4 ; as++){
cout <<
"Data ke-" << as;
cout <<
" adalah = " << antrian[as] << endl;
}
cout <<
"=========================================================="
<<endl;
break;
case 4 : if(antrian[4] == 0){
cout << "Maaf data
antrian kosong, Tidak ada data yang akan dihapus" << endl;
cout <<
"=========================================================="
<<endl;
} else {
cout <<
"Data yang ada dalam antrian akan dihapus, Apakah yakin (Y/N) = "
<< endl;
cin >>
konfirmasi;
if (konfirmasi
== 'Y' || konfirmasi == 'y'){
for(int as=0 ; as<=4
; as++){
antrian[as] = 0;
}
cout
<< "Data telah terhapus !" << endl;
cout <<
"=========================================================="
<<endl;
}
}
break;
case 5 : properties = 1;
cout <<
"" << endl;
cout <<
" =========
$$$$$$$$$$$$$$$$$$$$$$$$$$ =========" << endl;
cout <<
" ===
===" << endl;
cout <<
"=== Anda telah keluar dari
program antrian FIFO ==="
<< endl;
cout <<
"=== Terima
Kasih ==="
<< endl;
cout <<
" === ===" << endl;
cout <<
" =========
$$$$$$$$$$$$$$$$$$$$$$$$$$ =========" << endl;
break;
default : cout << "Maaf pilihan Anda tidak
ada dalam Menu" <<endl;
break;
}
}
return 0;
}
Three
Tree merupakan salah satu bentuk
struktur data tidak linear yang menggambarkan hubungan yang bersifat hierarkis
(hubungan one to many) antara elemen-elemen. Tree 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. Sesuai konvensi ilmu komputer, 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.
2.
Binary Tree (Pohon Biner)
Binary
tree adalah pohon yang setiap simpul/nodenya hanya dapat memiliki subpohon
maksimal 2. Pada pohon biner, umumnya kedua node anak disebut dengan posisinya,
yaitu kiri dan kanan.
Ilustrasi
binary tree:
tree
1.
Deklarasi tree
struct node
{ int data; //menyimpan nilai node
struct node *left;
struct node *right;}; // kiri dan kanan
bertipe pointer
2.
Inisialisasi tree
Node *pohon;
pohon
= NULL; //karena belum memiliki node maka pointer *pohon menunjuk ke null
3.
Kunjungan Pohon:
Ada
3 urutan dasar yang dapat digunakan untuk mengunjungi pohon, yaitu :
a.
PreOrder : cetak isi node yang dikunjungi, kunjungi Left Child, kunjungi Right
Child.
void preOrder(Node *root){
if(root != NULL){
printf("%d ",root->data);
//cetak isi node
preOrder(root->kiri); //kunjungi
kiri.jika null,langsung kunjungi kanan
preOrder(root->kanan);}} //jika tidak
null,ulang dari pertama dan terapkan untuk kanan
b.
InOrder : kunjungi Left Child, cetak isi node yang dikunjungi, kunjungi Right
Child.
void inOrder(Node *root){
if(root != NULL){
inOrder(root->kiri); //kunjungi
kiri,jika null langsung lanjut
printf("%d ",root->data);
//cetak isi node kiri
inOrder(root->kanan);}} //jika tidak
null,ulang dari pertama dan terapkan untuk kanan
c.
PostOrder : kunjungi Left Child, kunjungi Right Child cetak isi node yang
dikunjungi.
void postOrder(Node *root){
if(root != NULL){
postOrder(root->kiri); //kunjungi
kiri,jika null langsung lanjut
postOrder(root->kanan); //jika tidak
null,ulang dari pertama dan terapkan untuk kanan
printf("%d ",root->data);}}
//cetak isi node yang dikunjungi
4.
Contoh
1: #include <stdio>
2: #include <conio>
3: typedef struct Node{ int data
4: Node *kiri;
No comments:
Post a Comment