Materi Pertemuan 02-05 PENGOLAHAN FILE LANJUT
Disusun oleh : Danang Junaedi
OBJEKTIF
Dalam bab ini mahasiswa mempelajari tentang pengenalan :
1. Proses pengelolaan data pada file sequential menggunakan kategori tertentu(Konsolidasi tanpa separator) dan menggunakan simbol tertentu sebagai pembatas kelompok data (Konsolidasi dengan menggunakan separator)
2. Proses penggabungan data pada file sequential (merging) 3. Proses pemisahan data pada file sequential (splitting) 4. Proses pembaharuan data pada file sequential (updating) 5. Pembuatan file library header
TUJUAN & SASARAN
Setelah mempelajari materi dalam pertemuan ini mahasiswa diharapkan dapat :
1. Mengetahui bagaimana pengelolaan data pada file sequential pada proses pengelompokan data (konsolidasi), penggabungan data, pemisahan data serta pembaharuan data menggunakan bahasa pemrograman C/C++.
2. Mengetahui penerapan proses pengelolaan data pada file sequential menggunakan bahasa pemrograman C/C++
3. Mengetahui bagaimana membuat pengelolaan data pada file sequential menggunakan bahasa pemrograman C/C++.
4. Mengetahui bagaimana membuat file library header menggunakan bahasa pemrograman C/C++
WAKTU & TEMPAT
1. 4 x (2 x 50) menit pertemuan di kelas
2. 5 x (2 x 60) menit pertemuan di laboratorium komputer
3. 5 x (2 x 50) menit belajar di rumah
Sebelumnya kita telah mempelajari dasar pengelolaan data pada file sequential di mata kuliah Pemrograman Terstruktur I untuk proses pembuatan file, input data ke dalam file, dan membaca data dari dalam file sequential. Pada sub bab – sub bab berikut ini anda akan mempelajari lebih lanjut materi pengelolaan file, selain itu juga mempelajari pembuatan file library header pada C atau C++.
1.1
Kelompok Data Pada File SequentialSeperti kita ketahui sebelumnya, bahwa file adalah kumpulan data dengan kapasitas yang cukup besar dan disimpan dalam media penyimpanan sekunder, sehingga sifatnya permanen. Dikarenakan jumlah data yang cukup banyak itulah, kadang kita akan mengalami kesulitan jika diminta untuk memberikan informasi mengenai data yang ada di dalam file secara ringkas atau singkat. Atas dasar inilah proses pengelompokan data dilakukan, sehingga proses penyusunan informasi yang merupakan kesimpulan dari seluruh data yang ada dalam file akan lebih mudah dilakukan.
Pada mata kuliah Pemrograman Terstruktur II ini, kita tidak akan mempelajari bagaimana proses pengelompokan data, namun kita hanya memanfaatkan file yang data-data didalamnya sudah terkelompok atau tersusun berdasarakan urutan atau aturan tertentu.
Sehingga jika anda penasaran dengan bagaimana proses pembuatan atau penyusunan data mejadi kelompok data tertentu bisa anda pelajari sendiri.
Data-data dalam file sequential dapat dikelompokan dengan menggunakan simbol tertentu yang digunakan sebagai pembatas antar kelompok data atau biasa disebut separator.
Selain itu juga, data hanya disusun berdasarkan urutan atau susunan tertentu, sehingga tidak ada batas khusus antar kelompok data. Sebagai ilustrasi anda dapat lihat Tabel 1 berikut ini :
Tabel 1. Ilustrasi kelompok data dalam file
Kelompok data tanpa pembatas Kelompok data menggunakan pembatas No.Sales Kd-Brg Jumlah
A-010 Brg-11X 10 A-010 Brg-22Y 25 A-019 Brg-10A 15 A-101 Brg-10A 20 A-101 Brg-22Y 10 A-101 Brg-33P 20 A-212 Brg-11X 50 A-212 Brg33P 25
No.Sales Kd-Brg Jumlah
*** *** 0 A-010 Brg-11X 10 A-010 Brg-22Y 25
*** *** 0 A-019 Brg-10A 15
*** *** 0 A-101 Brg-10A 20 A-101 Brg-22Y 10 A-101 Brg-33P 20
*** *** 0 A-212 Brg-11X 50 A-212 Brg33P 25
*** *** 0
Untuk membuat file seperti di atas, dapat kita lakukan dengan dua cara, yaitu 1. Membuat program untuk proses input data
Disini anda sebagai programmer ”terpaksa” harus membuat program khusus untuk memasukan data ke dalam file. File yang dihasilkan tergantung program yang dibuat, anda bisa menghasilkan file teks ataupun file biner. Jika ingin melihat isi file anda bisa menggunakan aplikasi pemroses teks (untuk file teks) atau ”terpaksa lagi” harus membuat program khusus untuk proses pembacaan data dalam file (untuk file biner).
Gimana programnya ??? lihat lagi materi matakuliah Pemrograman Terstruktur I, atau anda bisa lihat contoh di modul praktikum (sekalipun program tersebut ”sengaja”
dibuat salah)
2. Menggunakan aplikasi pemroses teks
Aplikasi pemroses teks yang bisa anda gunakan diantaranya wordpad, notepad, textpad dan lainnya. File yang dihasilkan dengan menggunakan cara ini biasanya adalah file teks. Cara ini memang jauh lebih mudah dibandingkan dengan membuat program khusus, selain itu juga kita bisa melihat atau mebaca isi dari file tersebut menggunakan aplikasi pemroses teks yang ada. Namun jika mempertimbangkan
Separator/
Pembatas Data
keamanan data, cara ini kurang aman, karena setiap orang pasti bisa membaca isi dari file tersebut.
1.2
Pengelolaan Kelompok Data Pada File SequentialBerdasarkan ilustrasi pada tabel 1 di atas, kita bisa membuat kesimpulan informasi pada file tersebut, misalnya jumlah total barang untuk seluruh, jumlah total barang per sales, jumlah rata-rata seluruh barang dan sebagainya. Untuk mendapatkan informasi-informasi tersebut kita harus menyesuaikan dengan bentuk data dalam file, apakah menggunakan pembatas atau tidak, karena hal ini menentukan bagaimana kita harus menyusun algoritma dan mengimplementasikannya dalam program. Dalam mata kuliah algoritma II anda sudah mendapatkan bentuk atau struktur pengelolaan data dalam file dengan dan tanpa menggunakan pembatas.
Pada tabel 2, tabel 3, tabel 4 dan tabel 5 berikut ini anda dapat melihat konversi dari algoritma pengelolaan data pada file sequential yang menggunakan pembatas dan tidak menggunakan pembatas berdasarkan data pada table 1 di atas. Struktur dalam tabel tersebut dapat anda kembangkan tergantung kebutuhan informasi yang diminta.
Tabel 2. Konversi struktur algoritma ke dalam bahasa C++ (library header : stdio.h) untuk pengelolaan data pada file sequential yang tidak menggunakan pembatas (konsolidasi tanpa
separator
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipIn : SEQFILE of {input terurut menurut kunci}
(*)RekIn : rekaman (1) EOF : <mark, Val>
Current_categ : Keytype {identifikasi seluruh kategori yang sedang diproses}
Algoritma :
OPEN(ArsipIn, RekIn) IF EOP THEN
Kasus-kosong ELSE
{minimal ada satu kategori}
Inisialisasi_seluruh_categ REPEAT
{Proses satu kategori}
Init-categ
Current-categ RekIn.KeyIn
REPEAT
Proses-current-categ READ(ArsipIn, Rek)
UNTIL (keyIn <> current-categ) Terminasi-categ
UNTIL EOP
Terminasi-seluruh-kategori ENDIF
CLOSE(ArsipIn)
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *ArsipIn;
rekaman RekIn;
KeyType Current_Kateg;
ArsipIn = fopen(”Nama File”,”rt”);
If (feof(ArsipIn)) { //Kasus Kosong } else {
//baca record pertama
fscanf(ArsipIn,”format KeyType &
ValType”, RekIn.KeyIn, RekIn.ValIn);
// Inisialisasi_seluruh_categ loop{
//Init_categ
Current_Kateg = RekIn.KeyIn; atau strcpy(Current_Kateg, RekIn.KeyIn);
loop{
//Proses current_Kateg
fscanf(ArsipIn,”format KeyType &
ValType”,RekIn.KeyIn, RekIn.ValIn);
until(RekIn.KeyIn != current_categ);
//Terminasi_Kateg until(feof(ArsipIn));
//Terminasi seluruh kategori }
fclose(ArsipIn);
Tabel 3. Konversi struktur algoritma ke dalam bahasa C++ (library header : fstream.h) untuk pengelolaan data pada file sequential yang menggunakan pembatas (konsolidasi tanpa
separator
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipIn : SEQFILE of {input terurut menurut kunci}
(*)RekIn : rekaman (1)EOF : <mark, Val>
Current_categ : Keytype {identifikasi seluruh kategori yang sedang diproses}
Algoritma :
OPEN(ArsipIn, RekIn) IF EOP THEN
Kasus-kosong ELSE
{minimal ada satu kategori}
Inisialisasi_seluruh_categ REPEAT
{Proses satu kategori}
Init-categ
Current-categ RekIn.KeyIn
REPEAT
Proses-current-categ READ(ArsipIn, Rek)
UNTIL (keyIn <> current-categ) Terminasi-categ
UNTIL EOP
Terminasi-seluruh-kategori ENDIF
CLOSE(ArsipIn)
#include <fstream.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ofstream ArsipIn; atau fstream ArsipIn;
rekaman RekIn;
KeyType Current_Kateg;
ArsipIn.open(”Nama File”,ios::out);
If (ArsipIn.eof()) { //Kasus Kosong } else {
//baca record pertama
ArsipIn.read((char *) &RekIn, sizeof(RekIn));
// Inisialisasi_seluruh_categ loop{
//Init_categ
Current_Kateg = RekIn.KeyIn; atau strcpy(Current_Kateg, RekIn.KeyIn);
loop{
//Proses current_Kateg
ArsipIn.read((char *) &RekIn, sizeof(RekIn));
until(RekIn.KeyIn != current_categ);
//Terminasi_Kateg until(ArsipIn.eof());
//Terminasi seluruh kategori }
ArsipIn.close();
Tabel 4. Konversi struktur algoritma ke dalam bahasa C++ (library header : stdio.h) untuk pengelolaan data pada file sequential yang tidak menggunakan pembatas (konsolidasi dengan
separator
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi}
type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipIn : SEQFILE of {input terurut menurut kunci}
(*) RekIn : rekaman (1) EOF : <mark, Val>
Algoritma :
Inisialisasi-seluruh categ OPEN(ArsipIn, RekIn) IF EOP THEN
Kasus-kosong ELSE
{minimal ada satu kategori}
REPEAT
{Skip separator}
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *ArsipIn;
rekaman RekIn;
// Inisialisasi_seluruh_categ ArsipIn = fopen(”Nama File”,”rt”);
If (feof(ArsipIn)) { //Kasus Kosong } else {
fscanf(ArsipIn,”format KeyType &
ValType”, RekIn.KeyIn, RekIn.ValIn);
loop{
Algoritma Bahasa C atau C++
WHILE (NOT EOP) AND
(Separator(KeyIn)) DO READ(ArsipIn, RekIn)
ENDWHILE
{KeyIn bukan separator, KeyIn adalah elemen Pertama dari Next-Categ atau EOP}
{Tidak dibedakan antara kasus kategori kosong atau tidak}
Init-categ
WHILE (NOT EOP) AND
(NOT separator(KeyIn)) DO {Proses satu kategori}
Proses-current-categ READ(ArsipIn, Rek)
Terminasi-categ ENDWHILE
UNTIL EOP
Terminasi-seluruh-kategori ENDIF
CLOSE(ArsipIn)
//skip separator while(! feof(ArsipIn) &&
Separator(RekIn.KeyIn)){
fscanf(ArsipIn,”format KeyType &
ValType”, RekIn.KeyIn, RekIn.ValIn);
}
//Init_categ
while(! feof(ArsipIn) &&
! Separator(RekIn.KeyIn)) {
//Proses curret kategori
fscanf(ArsipIn,”format KeyType &
ValType”,RekIn.KeyIn, RekIn.ValIn);
//Terminasi_Kateg }
until(feof(ArsipIn));
//Terminasi seluruh kategori }
fclose(arsipIn)
Tabel 5. Konversi struktur algoritma ke dalam bahasa C++ (library header : fstream.h) untuk pengelolaan data pada file sequential yang menggunakan pembatas (konsolidasi dengan
separator
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi}
type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipIn : SEQFILE of {input terurut menurut kunci}
(*) RekIn : rekaman (1) EOF : <mark, Val>
Algoritma :
Inisialisasi-seluruh categ OPEN(ArsipIn, RekIn) IF EOP THEN
Kasus-kosong ELSE
{minimal ada satu kategori}
REPEAT
{Skip separator}
WHILE (NOT EOP) AND
(Separator(KeyIn)) DO READ(ArsipIn, RekIn)
ENDWHILE
{KeyIn bukan separator, KeyIn adalah elemen Pertama dari Next-Categ atau EOP}
{Tidak dibedakan antara kasus kategori kosong atau tidak}
Init-categ
WHILE (NOT EOP) AND
(NOT separator(KeyIn)) DO {Proses satu kategori}
Proses-current-categ READ(ArsipIn, Rek)
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ofstream ArsipIn; atau fstream ArsipIn;
rekaman RekIn;
// Inisialisasi_seluruh_categ ArsipIn.open(”Nama File”,ios::out);
If (ArsipIn.eof()) { //Kasus Kosong } else {
ArsipIn.read((char *) &RekIn, sizeof(RekIn));
loop{
//skip separator while(! feof(ArsipIn) &&
Separator(RekIn.KeyIn)){
ArsipIn.read((char *) &RekIn, sizeof(RekIn));
}
//Init_categ
while(! feof(ArsipIn) &&
! Separator(RekIn.KeyIn)) {
//Proses curret kategori ArsipIn.read((char *) &RekIn, sizeof(RekIn));
Algoritma Bahasa C atau C++
Terminasi-categ ENDWHILE
UNTIL EOP
Terminasi-seluruh-kategori ENDIF
CLOSE(ArsipIn)
//Terminasi_Kateg }
until(ArsipIn.eof());
//Terminasi seluruh kategori }
ArsipIn.close();
1.3 Penggabungan Data Pada File Sequential
Data dalam file bisa anda tambahkan dengan cara memasukan data tersebut satu per satu ke dalam file. Selain cara tersebut, kadang anda bisa memperoleh data dari file yang lain, sehingga anda tidak perlu memasukan data tersebut satu persatu, melainkan hanya menyalin (mengcopy) data tersebut ke dalam file tertentu. Proses penyalinan dari dari beberapa file ke dalam sebuah file disebut sebagai proses penggabungan atau merging.
Pada tabel 6 dan tabel 7 berikut ini anda dapat melihat konversi dari algoritma penggabungan data pada file sequential. Struktur dalam tabel tersebut dapat anda kembangkan tergantung kebutuhan hasil penggabungan data yang diminta.
Tabel 6. Konversi struktur algoritma ke dalam bahasa C++ (library header : stdio.h) untuk penggabungan data pada file sequential
Algoritma Bahasa C atau C++
Versi OR
{Keytype adalah suatu type dari kuncirekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipGabung : SEQFILE of {input terurut menurut kunci}
(*)RekGabung : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(Arsip1, Rek1) OPEN(Arsip2, Rek2)
REWRITE(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada Arsip1 dan Arsip2
READ(Arsip1,Rek1)
READ(Arsip2,Rek2)
WHILE (NOT EOF(Arsip1) OR NOT EOF(Arsip2)) DO
IF (Rek1.KeyIn <= Rek2.KeyIn) THEN WRITE(ArsipGabung,Rek1)
READ(Arsip1,Rek1)
ELSE
WRITE(ArsipGabung,Rek2)
READ(Arsip2,Rek2)
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *Arsip1, *Arsip2;
rekaman Rek1,Rek2;
FILE *ArsipGabung;
rekaman RekGabung;
Arsip1 = fopen(”Nama File1”,”rt”);
Arsip2 = fopen(”Nama File2”,”rt”);
ArsipGabung = fopen(”Nama FileGabung”, ”wt”);
If (feof(Arsip1) && feof(Arsip2)) { //Kasus Kosong }
else {
//baca record pertama pada Arsip1 dan Arsip2
fscanf(Arsip1,”format KeyType &
ValType”,Rek1.KeyIn, Rek1.ValIn);
fscanf(Arsip2,”format KeyType &
ValType”,Rek2.KeyIn, Rek2.ValIn);
while{! feof(Arsip1) ||
! feof(Arsip2)) {
if(Rek1.KeyIn <= Rek2.KeyIn) {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek1.KeyIn, Rek1.ValIn);
fscanf(Arsip1,”format KeyType &
ValType”, Rek1.Key1, Rek1.Val1);
else {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek2.KeyIn, Rek1.ValIn);
fscanf(Arsip2,”format KeyType &
ValType”, Rek2.KeyIn, Rek2.ValIn);
Algoritma Bahasa C atau C++
ENDIF ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipGabung)
} } }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipGabung);
Versi AND
{Keytype adalah suatu type dari kuncirekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipGabung : SEQFILE of {input terurut menurut kunci}
(*)RekGabung : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(Arsip1, Rek1) OPEN(Arsip2, Rek2)
REWRITE(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada Arsip1 dan Arsip2
READ(Arsip1,Rek1)
READ(Arsip2,Rek2)
WHILE (NOT EOF(Arsip1) AND NOT EOF(Arsip2)) DO
IF (Rek1.KeyIn <= Rek2.KeyIn) THEN WRITE(ArsipGabung,Rek1)
READ(Arsip1,Rek1)
ELSE
WRITE(ArsipGabung,Rek2)
READ(Arsip2,Rek2)
ENDIF ENDWHILE
WHILE (NOT EOF(Arsip1)) DO WRITE(ArsipGabung,Rek1)
READ(Arsip1,Rek1)
ENDWHILE
WHILE (NOT EOF(Arsip2)) DO WRITE(ArsipGabung,Rek2)
READ(Arsip2,Rek2)
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *Arsip1, *Arsip2;
rekaman Rek1,Rek2;
FILE *ArsipGabung;
rekaman RekGabung;
Arsip1 = fopen(”Nama File1”,”rt”);
Arsip2 = fopen(”Nama File2”,”rt”);
ArsipGabung = fopen(”Nama FileGabung”, ”wt”);
If (feof(Arsip1) && feof(Arsip2)) { //Kasus Kosong }
else {
//baca record pertama pada Arsip1 dan Arsip2
fscanf(Arsip1,”format KeyType &
ValType”,Rek1.KeyIn, Rek1.ValIn);
fscanf(Arsip2,”format KeyType &
ValType”,Rek2.KeyIn, Rek2.ValIn);
while{! feof(Arsip1) &&
! feof(Arsip2)) {
if(Rek1.KeyIn <= Rek2.KeyIn) {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek1.KeyIn, Rek1.ValIn);
fscanf(Arsip1,”format KeyType &
ValType”, Rek1.KeyIn, Rek1.ValIn);
else {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek2.KeyIn, Rek1.ValIn);
fscanf(Arsip2,”format KeyType &
ValType”, Rek2.KeyIn, Rek2.ValIn);
} }
while{! feof(Arsip1)) {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek1.KeyIn, Rek1.ValIn);
fscanf(Arsip1,”format KeyType &
ValType”, Rek1.Key1, Rek1.ValIn);
}
while{! feof(Arsip2)) {
fwrite(ArsipGabung,”format KeyType & ValType”, Rek2.KeyIn, Rek2.ValIn);
fscanf(Arsip2,”format KeyType &
ValType”, Rek1.KeyIn, Rek2.ValIn);
Algoritma Bahasa C atau C++
ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipGabung)
} }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipGabung);
Tabel 7. Konversi struktur algoritma ke dalam bahasa C++ (library header : fstream.h) untuk penggabungan data pada file sequential
Algoritma Bahasa C atau C++
Versi OR
{Keytype adalah suatu type dari kuncirekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipGabung : SEQFILE of {input terurut menurut kunci}
(*)RekGabung : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(Arsip1, Rek1) OPEN(Arsip2, Rek2)
REWRITE(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada Arsip1 dan Arsip2
READ(Arsip1,Rek1)
READ(Arsip2,Rek2)
WHILE (NOT EOF(Arsip1) OR NOT EOF(Arsip2)) DO
IF (Rek1.KeyIn <= Rek2.KeyIn) THEN WRITE(ArsipGabung,Rek1)
READ(Arsip1,Rek1)
ELSE
WRITE(ArsipGabung,Rek2) READ(Arsip2,Rek2)
ENDIF ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipGabung)
#include <fstream.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ofstream Arsip1, Arsip;
rekaman Rek1,Rek2;
ifstream ArsipGabung;
rekaman RekGabung;
Arsip1.open(”Nama File1”,ios::out);
Arsip2.open(”Nama File2”,ios::out);
ArsipGabung.open(”Nama FileGabung”, ios::app);
If (Arsip1.eof() && Arsip2.eof()) { //Kasus Kosong }
else {
//baca record pertama pada Arsip1 dan Arsip2
Arsip1.read((char *) &Rek1, sizeof(Rek1));
Arsip2.read((char *) &Rek2, sizeof(Rek2));
while{! Arsip1.eof() ||
! Arsip2.eof()) {
if(Rek1.KeyIn <= Rek2.KeyIn) { ArsipGabung.write((char *) &Rek1, sizeof(Rek1));
Arsip1.read((char *) &Rek1, sizeof(Rek1));
else {
ArsipGabung.write((char *) &Rek2, sizeof(Rek2));
Arsip2.read((char *) &Rek2, sizeof(Rek2));
} } }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipGabung);
Versi AND
{Keytype adalah suatu type dari kuncirekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
#include <fstream.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ofstream Arsip1, Arsip;
Algoritma Bahasa C atau C++
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipGabung : SEQFILE of {input terurut menurut kunci}
(*)RekGabung : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(Arsip1, Rek1) OPEN(Arsip2, Rek2)
REWRITE(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada Arsip1 dan Arsip2
READ(Arsip1,Rek1)
READ(Arsip2,Rek2)
WHILE (NOT EOF(Arsip1) AND NOT EOF(Arsip2)) DO
IF (Rek1.KeyIn <= Rek2.KeyIn) THEN WRITE(ArsipGabung,Rek1)
READ(Arsip1,Rek1)
ELSE
WRITE(ArsipGabung,Rek2) READ(Arsip2,Rek2)
ENDIF ENDWHILE
WHILE (NOT EOF(Arsip1)) DO WRITE(ArsipGabung,Rek1) READ(Arsip1,Rek1)
ENDWHILE
WHILE (NOT EOF(Arsip2)) DO WRITE(ArsipGabung,Rek2) READ(Arsip2,Rek2)
ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipGabung)
rekaman Rek1,Rek2;
ifstream ArsipGabung;
rekaman RekGabung;
Arsip1.open(”Nama File1”,ios::out);
Arsip2.open(”Nama File2”,ios::out);
ArsipGabung.open(”Nama FileGabung”, ios::app);
If (Arsip1.eof() && Arsip2.eof()) { //Kasus Kosong }
else {
//baca record pertama pada Arsip1 dan Arsip2
Arsip1.read((char *) &Rek1, sizeof(Rek1));
Arsip2.read((char *) &Rek2, sizeof(Rek2));
while{! Arsip1.eof() &&
! Arsip2.eof()) {
if(Rek1.KeyIn <= Rek2.KeyIn) { ArsipGabung.write((char *) &Rek1, sizeof(Rek1));
Arsip1.read((char *) &Rek1, sizeof(Rek1));
else {
ArsipGabung.write((char *) &Rek2, sizeof(Rek2));
Arsip2.read((char *) &Rek2, sizeof(Rek2));
} }
while{! feof(Arsip1)) {
ArsipGabung.write((char *) &Rek1, sizeof(Rek1));
Arsip1.read((char *) &Rek1, sizeof(Rek1));
}
while{! feof(Arsip2)) {
ArsipGabung.write((char *) &Rek2, sizeof(Rek2));
Arsip2.read((char *) &Rek2, sizeof(Rek2));
} }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipGabung);
1.4
Pemisahan Data Pada File SequentialDikarenakan jumlah data yang semakin besar atau karena suatu kondisi tertentu, data dalam file harus dipecah atau dipisahkan menjadi beberapa file. Salah satu tujuannya adalah untuk mempermudah membuat kesimpulan informasi dari data-data yang ada di dalam file tersebut. Proses pemecahan atau pemisahan dari dari beberapa file ke dalam sebuah file disebut sebagai proses pemisahan atau splitting.
Pada tabel 8 dan tabel 9 berikut ini anda dapat melihat konversi dari algoritma
pemisahan data pada file sequential. Struktur dalam tabel tersebut dapat anda kembangkan
tergantung kebutuhan hasil pemisahan data yang diminta.
Tabel 8. Konversi struktur algoritma ke dalam bahasa C++ (library header : stdio.h) untuk pemisahan data pada file sequential
Algoritma Bahasa C atau C++
Versi OR
{Keytype adalah suatu type dari kuncirekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipUtama : SEQFILE of {input terurut menurut kunci}
(*)RekUtama : rekaman (2)EOF : <mark, Val>
Kategori {batasan yang digunakan untuk proses pemisahan)
Algoritma :
REWRITE(Arsip1, Rek1) REWRITE(Arsip2, Rek2) OPEN(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada ArsipUtama READ(ArsipUtama,RekUtama)
WHILE (NOT EOF(ArsipUtama)) DO IF (Kategori) THEN
WRITE(ArsipGabung,Rek1)
ELSE
WRITE(ArsipGabung,Rek2)
ENDIF
READ(Arsip1,Rek1)
ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipUtama)
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *Arsip1, *Arsip2;
rekaman Rek1,Rek2;
FILE *ArsipUtama;
rekaman RekUtama;
Arsip1 = fopen(”Nama File1”,”wt”);
Arsip2 = fopen(”Nama File2”,”wt”);
ArsipUTAMA = fopen(”Nama FileGabung”, ”rt”);
If (feof(ArsipUtama)) { //Kasus Kosong } else {
//baca record pertama pada ArsipUtama fscanf(ArsipUtama,”format KeyType &
ValType”,RekUtama.KeyIn, RekUtama.ValIn);
while{! feof(ArsipUtama)) { if(Kategori) {
fwrite(Arsip1,”format KeyType & ValType”, RekUtama.KeyIn, RekUtama.ValIn);
else {
fwrite(Arsip2,”format KeyType & ValType”, RekUtama.KeyIn, RekUtama.ValIn);
}
fscanf(ArsipUtama,”format KeyType &
ValType”, RekUtama.Key1, RekUtama.Val1);
} }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipUtama);
Tabel 9. Konversi struktur algoritma ke dalam bahasa C++ (library header : fstream.h) untuk pemisahan data pada file sequential
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
Arsip1, Arsip2 : SEQFILE of
{input terurut menurut kunci}
(*)Rek1,Rek2 : rekaman (2)EOF : <mark, Val>
ArsipUtama : SEQFILE of {input terurut menurut kunci}
#include <fstream.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ifstream Arsip1, Arsip2;
rekaman Rek1,Rek2;
ofstream ArsipUtama;
Algoritma Bahasa C atau C++
(*)RekUtama : rekaman (2)EOF : <mark, Val>
Kategori {batasan yang digunakan untuk proses pemisahan)
Algoritma :
REWRITE(Arsip1, Rek1) REWRITE(Arsip2, Rek2) OPEN(ArsipGabung,RekGabung)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada ArsipUtama READ(ArsipUtama,RekUtama)
WHILE (NOT EOF(ArsipUtama)) DO IF (Kategori) THEN
WRITE(Arsip1,RekUtama)
ELSE
WRITE(Arsip2,RekUtama)
ENDIF
READ(ArsipUtama,RekUtama)
ENDWHILE ENDIF
CLOSE(Arsip1) CLOSE(Arsip2) CLOSE(ArsipUtama)
rekaman RekUtama;
Arsip1.open(”Nama File1”,ios::app);
Arsip2.open(”Nama File2”,ios::app);
ArsipUTAMA.open(”Nama FileGabung”, ios::out);
If (ArsipUtama.eof()) { //Kasus Kosong } else {
//baca record pertama pada ArsipUtama ArsipUtama.read((char *) &RekUtama, sizeof(RekUtama));
while{! ArsipUtama.eof()) { if(Kategori) {
Arsip1.write((char *) &RekUtama, sizeof(RekUtama));
else {
Arsip2.write((char *) &RekUtama, sizeof(RekUtama));
}
ArsipUtama.read((char *) &RekUtama, sizeof(RekUtama));
} }
fclose(Arsip1);
fclose(Arsip2);
fclose(ArsipUtama);
1.5
Pembaharuan Data Pada File SequentialProses penyalinan atau penggabungan data dari beberapa file kadang akan duplikasi data di dalam file hasil penggabungan tersebut. Duplikasi data terjadi jika dalam satu file terdapat sebuah data yang sama namun ditulis lebih dari satu kali, hal ini akan mengakibatkan semakin besarnya ukuran file dikarenakan penambahan jumlah data dalam file. Oleh karena itu diperlukan penanganan khusus untuk data tersebut, salah satunya adalah dengan mengubah salah satu komponen dari data tersebut, sehingga tidak ada duplikasi data dalam file. Proses pengubahan komponen ini dapat dilakukan dengan cara menimpa nilai pada salah satu komponen data yang lama dengan nilai pada komponen data yang baru (penimpaan) atau melakukan operasi aritmatika pada komponen data tersebut (penjumlahan, pengurangan, perkalian dan seterusnya). Proses pengubahan nilai ini disebut sebagai proses pembaharuan data atau updating.
Pada tabel 10 dan tabel 11 berikut ini anda dapat melihat konversi dari algoritma pembaharuan data pada file sequential. Struktur dalam tabel tersebut dapat anda kembangkan tergantung kebutuhan hasil pemisahan data yang diminta.
Tabel 10. Konversi struktur algoritma ke dalam bahasa C++ (library header : stdio.h) untuk pembaharuan data pada file sequential
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipLama, ArsipBaru : SEQFILE of {input terurut menurut kunci}
(*)RekLama,RekBaru : rekaman (2)EOF : <mark, Val>
ArsipUpdate : SEQFILE of {input terurut menurut kunci}
#include <stdio.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
FILE *ArsipLama, *ArsipBaru;
rekaman RekLama,RekBaru;
FILE *ArsipUpdate;
Algoritma Bahasa C atau C++
(*)RekUpdate : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(ArsipLama, RekLama) OPEN(ArsipBaru, RekBaru) REWRITE(ArsipUpdate,RekUpdate)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada ArsipLama dan ArsipBaru
READ(ArsipLama,RekLama)
READ(ArsipBaru,RekBaru)
WHILE (NOT EOF(ArsipLama) AND NOT EOF(ArsipBaru)) DO IF (RekLama.KeyIn=RekBaru.KeyIn) THEN
RekUpdate.KeyIn RekBaru.KeyIn atau RekUpdate.KeyIn RekLama.KeyIn RekUpdate.ValIn //hasil proses RekLama dan RekBaru WRITE(ArsipUpdate,RekUpdate)
READ(ArsipLama,RekLama)
READ(ArsipBaru,RekBaru)
ELSE
IF (RekLama.KeyIn<=RekBaru.KeyIn) THEN
WRITE(ArsipUpdate,RekLama)
READ(ArsipLama,RekLama)
ELSE
WRITE(ArsipUpdate,RekBaru)
READ(ArsipBaru,RekBaru)
ENDIF ENDIF ENDWHILE
WHILE (NOT EOF(ArsipLama)) DO WRITE(ArsipUpdate,RekLama)
READ(ArsipLama,RekLama)
ENDWHILE
WHILE (NOT EOF(ArsipBaru)) DO WRITE(ArsipUpdate,RekBaru)
READ(ArsipBaru,RekBaru)
rekaman RekUpdate;
ArsipLama = fopen(”Nama File1”,”rt”);
ArsipBaru = fopen(”Nama File2”,”rt”);
ArsipUpdate = fopen(”Nama FileUpdate”, ”wt”);
If (feof(ArsipLama) && feof(ArsipBaru)) { //Kasus Kosong }
else {
//baca record pertama pada ArsipLama dan ArsipBaru
fscanf(ArsipLama,”format KeyType &
ValType”,RekLama.KeyIn, RekLama.ValIn);
fscanf(ArsipBaru,”format KeyType &
ValType”,RekBaru.KeyIn, RekBaru.ValIn);
while{! feof(ArsipLama) &&
! feof(ArsipBaru)) {
if(RekLama.KeyIn == RekBaru.KeyIn) {
RekUpdate.KeyIn = RekBaru.KeyIn atau RekUpdate.KeyIn = Reklama.KeyIn RekUpdate.ValIn = //hasil proses RekLama dan RekBaru fwrite(ArsipUpdate,”format KeyType & ValType”, RekUpdate.KeyIn, RekUpdate.ValIn);
fscanf(ArsipLama,”format KeyType &
ValType”, RekLama.KeyIn, RekLama.ValIn);
fscanf(ArsipBaru,”format KeyType &
ValType”, RekBaru.KeyIn, RekBaru.ValIn);
} else {
if(RekLama.KeyIn <= RekBaru.KeyIn) {
fwrite(ArsipUpdate,”format KeyType & ValType”, RekLama.KeyIn, RekLama.ValIn);
fscanf(ArsipLama,”format KeyType &
ValType”, RekLama.KeyIn, RekLama.ValIn);
else {
fwrite(ArsipUpdate,”format KeyType & ValType”, RekBaru.KeyIn, RekLama.ValIn);
fscanf(ArsipLama,”format KeyType &
ValType”, RekLama.KeyIn, RekLama.ValIn);
} } }
while{! feof(ArsipLama)) {
fwrite(ArsipUpdate,”format KeyType & ValType”, RekLama.KeyIn, RekLama.ValIn);
fscanf(ArsipLama,”format KeyType &
ValType”, RekLama.Key1, RekLama.ValIn);
}
while{! feof(ArsipBaru)) {
fwrite(ArsipUpdate,”format KeyType & ValType”, RekBaru.KeyIn, RekBaru.ValIn);
fscanf(ArsipBaru,”format KeyType &
ValType”, RekLama.KeyIn, RekBaru.ValIn);
}
Algoritma Bahasa C atau C++
ENDWHILE ENDIF
CLOSE(ArsipLama) CLOSE(ArsipBaru) CLOSE(ArsipUpdate)
}
fclose(ArsipLama);
fclose(ArsipBaru);
fclose(ArsipUpdate);
Tabel 11. Konversi struktur algoritma ke dalam bahasa C++ (library header : fstream.h) untuk pembaharuan data pada file sequential
Algoritma Bahasa C atau C++
{Keytype adalah suatu type dari kunci rekaman, Valtype adalah type dari harga rekaman}
{Keytype dan Valtype harus terdefinisi } type rekaman : < KeyIn : Keytype, ValIn : Valtype >
{KeyIn : kunci, ValIn : harga lain yang direkam}
ArsipLama, ArsipBaru : SEQFILE of {input terurut menurut kunci}
(*)RekLama,RekBaru : rekaman (2)EOF : <mark, Val>
ArsipUpdate : SEQFILE of {input terurut menurut kunci}
(*)RekUpdate : rekaman (2)EOF : <mark, Val>
Algoritma :
OPEN(ArsipLama, RekLama) OPEN(ArsipBaru, RekBaru) REWRITE(ArsipUpdate,RekUpdate)
IF EOP THEN Kasus-kosong ELSE
//baca record pertama pada ArsipLama dan ArsipBaru
READ(ArsipLama,RekLama)
READ(ArsipBaru,RekBaru)
WHILE (NOT EOF(ArsipLama) AND NOT EOF(ArsipBaru)) DO IF (RekLama.KeyIn=RekBaru.KeyIn) THEN
RekUpdate.KeyIn RekBaru.KeyIn atau RekUpdate.KeyIn RekLama.KeyIn RekUpdate.ValIn //hasil proses RekLama dan RekBaru WRITE(ArsipUpdate,RekUpdate)
READ(ArsipLama,RekLama) READ(ArsipBaru,RekBaru)
ELSE
IF (RekLama.KeyIn<=RekBaru.KeyIn) THEN
WRITE(ArsipUpdate,RekLama) READ(ArsipLama,RekLama)
ELSE
WRITE(ArsipUpdate,RekBaru) READ(ArsipBaru,RekBaru)
ENDIF ENDIF ENDWHILE
WHILE (NOT EOF(ArsipLama)) DO
#include <fstream.h>
#include <string.h>
Typedef struct{ KeyType KeyIn, ValType ValIn}rekaman;
ofstream ArsipLama, ArsipBaru;
rekaman RekLama,RekBaru;
ifstream ArsipUpdate;
rekaman RekUpdate;
ArsipLama.open(”Nama File1”,ios::out);
ArsipBaru.open(”Nama File2”,ios::out);
ArsipUpdate.open(”Nama FileUpdate”, ios::app);
If (ArsipLama.eof() && ArsipBaru.eof()) { //Kasus Kosong }
else {
//baca record pertama pada ArsipLama dan ArsipBaru
ArsipLama.read((char *) &RekLama, sizeof(RekLama));
ArsipBaru.read((char *) &RekBaru, sizeof(RekBaru));
while{! ArsipLama.eof() &&
! ArsipBaru.eof()) {
if(RekLama.KeyIn == RekBaru.KeyIn) {
RekUpdate.KeyIn = RekBaru.KeyIn atau RekUpdate.KeyIn = Reklama.KeyIn RekUpdate.ValIn = //hasil proses RekLama dan RekBaru ArsipUpdate.write((char *)
&RekUpdate,sizeof(RekUpdate));
ArsipLama.read((char *) &RekLama, sizeof(RekLama));
ArsipBaru.read((char *) &RekBaru, sizeof(RekBaru));
} else {
if(RekLama.KeyIn <= RekBaru.KeyIn) {
ArsipUpdate.write((char *) &RekLama,sizeof(RekLama));
ArsipLama.read((char *) &RekLama, sizeof(RekLama));
else {
ArsipUpdate.write((char *) &RekBaru,sizeof(RekBaru));
ArsipBaru.read((char *) &RekBaru, sizeof(RekBaru));
} } }
while{! feof(ArsipLama)) {
Algoritma Bahasa C atau C++
WRITE(ArsipUpdate,RekLama) READ(ArsipLama,RekLama)
ENDWHILE
WHILE (NOT EOF(ArsipBaru)) DO WRITE(ArsipUpdate,RekBaru) READ(ArsipBaru,RekBaru)
ENDWHILE ENDIF
CLOSE(ArsipLama) CLOSE(ArsipBaru) CLOSE(ArsipUpdate)
ArsipUpdate.write((char *) &RekLama,sizeof(RekLama));
ArsipLama.read((char *) &RekLama, sizeof(RekLama));
}
while{! feof(ArsipBaru)) { ArsipUpdate.write((char *) &RekBaru,sizeof(RekBaru));
ArsipBaru.read((char *) &RekBaru, sizeof(RekBaru));
} }
fclose(ArsipLama);
fclose(ArsipBaru);
fclose(ArsipUpdate);