ARRAY UNTUK PENGURUTAN, ANTRIAN,
DAN TUMPUKAN
Soal & Penyelesaian
1.
Tulislah sebuah program C++ untuk merealisasikan
pengurutan Bubble.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
//arrayPengurutanBubble.cpp
//Mendemonstrasikan pengurutan Bubble
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class ArrayBub
{
private:
vector<double> v; //vector v
int jumElemen; //jumlah item data
void
tukar(int satu, int dua) //fungsi anggota private
{
double
temp = v[satu];
v[satu] = v[dua];
v[dua] = temp;
}
public:
ArrayBub(int maks) : jumElemen(0)
//konstruktor
{
v.resize(maks); //ukuran vector
}
void
sisip(double nilai) //menempatkan
elemen ke dalam array
{
v[jumElemen] = nilai; //menyisipkan
jumElemen++; //mengdalamkremen ukuran
}
void
tampil() //menampilkan isi array
{
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
cout
<< v[j] << " "; //menampilkan
cout
<< endl;
}
void pengurutanBubble() //mengurutkan
array
{
int luar, dalam;
for(luar=jumElemen-1; luar>1;
luar--) //loop luar (mundur)
for(dalam=0; dalam<luar; dalam++)
//loop dalam (maju)
if( v[dalam] > v[dalam+1] ) //tidak terurut?
tukar(dalam, dalam+1); //tukar them
} //akhir
pengurutanBubble()
}; //akhir kelas ArrayBub
int main()
{
int ukuranMaks = 100; //ukuran array
ArrayBub
arr(ukuranMaks); //menciptakan array
arr.sisip(77);
//menyisipkan 10 item
arr.sisip(99);
arr.sisip(44);
arr.sisip(55);
arr.sisip(22);
arr.sisip(88);
arr.sisip(11);
arr.sisip(00);
arr.sisip(66);
arr.sisip(33);
arr.tampil();
//menampilkan array
arr.pengurutanBubble(); //melakukan pengurutan Bubble
arr.tampil();
//menampilkan array
getch();
return 0;
} //akhir main()
|
77 99 44 55 22 88 11 0 66 33
0 11 22 33 44 55 66 77 88 99
2.
Tulislah sebuah program C++ untuk merealisasikan
pengurutan Penyisipan.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
//arrayPengurutanPenyisipan.cpp
//Mendemonstrasikan pengurutan penyisipan
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class ArrayPenyisipan
{
private:
vector<double> v; //vector v
int jumElemen; //jumlah item data
public:
ArrayPenyisipan(int max) :
jumElemen(0) //konstruktor
{
v.resize(max); //ukuran vector
}
void sisip(double nilai) //menempatkan elemen ke dalam array
{
v[jumElemen] = nilai; //menyisipkan
jumElemen++; //menginkremen ukuran
}
void tampil() //menampilkan isi array
{
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
cout
<< v[j] << " "; //menampilkan
cout
<< endl;
}
void pengurutanPenyisipan()
{
int dalam, luar;
for(luar=1; luar<jumElemen;
luar++) //loop luar sebagai pembagi
{
double temp = v[luar]; //menghapus
item yang ditandai
dalam
= luar; //menggeser
while(dalam>0 &&
v[dalam-1] >= temp) //sampai satu lebih kecil,
{
v[dalam] = v[dalam-1]; //menggeser item ke kanan
--dalam; //ke kiri satu posisi
}
v[dalam] = temp; //menyisipkan item yang ditandai
} //akhir
for
} //akhir
pengurutanPenyisipan()
}; //akhir kelas ArrayPenyisipan
int main()
{
int ukuranMaks = 100; //ukuran array
ArrayPenyisipan
arr(ukuranMaks); //menciptakan array
arr.sisip(77);
//menyisipkan 10 item
arr.sisip(99);
arr.sisip(44);
arr.sisip(55);
arr.sisip(22);
arr.sisip(88);
arr.sisip(11);
arr.sisip(00);
arr.sisip(66);
arr.sisip(33);
arr.tampil();
//menampilkan array
arr.pengurutanPenyisipan();
//melakukan pengurutan penyisipan
arr.tampil();
//menampilkan array kembali
getch();
return 0;
} //akhir main()
|
77 99 44 55 22 88 11 0 66 33
0 11 22 33 44 55 66 77 88 99
3.
Tulislah sebuah program C++ untuk merealisasikan
pengurutan Penyisipan terhadap objek-objek.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
//pengurutanPenyisipanObjek.cpp
//Mendemonstrasikan pengurutan objek dengan pengurutan
penyisipan
#include
<iostream>
#include
<string>
#include
<vector>
#include
<conio.h>
using namespace std;
class Orang
{
private:
string namaBelakang;
string namaDepan;
int usia;
public:
Orang(string belakang, string depan, int a) :
//konstruktor
namaBelakang(belakang), namaDepan(depan), usia(a)
{ }
void tampilOrang()
{
cout << "Nama belakang: "
<< namaBelakang;
cout
<< ", nama depan: " << namaDepan;
cout
<< ", usia: "
<< usia << endl;
}
string getBelakang() //membaca nama
belakang
{ return namaBelakang; }
}; //akhir kelas Orang
class ArraySisipObjek
{
private:
vector<Orang*> v; //vektor yang
memuat pointer ke Orang
int jumElemen; //jumlah item data
public:
ArraySisipObjek(int maks) :
jumElemen(0) //konstruktor
{
v.resize(maks); //ukuran vector
}
//menempatkan
Orang ke dalam array
void sisip(string belakang, string
depan, int usia)
{
v[jumElemen] = new
Orang(belakang, depan, usia);
jumElemen++; //menginkremen ukuran
}
void tampil() //menampilkan isi array
{
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
v[j]->tampilOrang(); //menampilkan
}
void pengururanPenyisipan()
{
int dalam, luar;
for(luar=1; luar<jumElemen;
luar++)
{
Orang* temp = v[luar]; //luar sebagai pembagi
dalam
= luar; //menggeser
//sampai satu lebih kecil ditemukan,
while( dalam>0 &&
v[dalam-1]->getBelakang() > temp->getBelakang() )
{
v[dalam] = v[dalam-1]; //menggeser satu item ke
kanan
--dalam; //ke kiri satu posisi
}
v[dalam] = temp; //menyisipkan item yang ditandai
} //akhir
for
} //akhir pengururanPenyisipan()
}; //akhir kelas ArraySisipObjek
int main()
{
int ukuranMaks = 100; //ukuran array
ArraySisipObjek
arr(ukuranMaks); //menciptakan array
arr.sisip("Rismon", "Sianipar", 24); //menyisipkan 10
item
arr.sisip("Robert", "Tohonan", 37);
arr.sisip("Rico", "Chandra", 43);
arr.sisip("Rotua", "Marolop", 63);
arr.sisip("Rini", "Meika", 21);
arr.sisip("Eva", "Teti", 29);
arr.sisip("Patricia", "Siahaan", 72);
arr.sisip("Vivian", "Jozen", 54);
arr.sisip("Jodi", "Pratama", 22);
arr.sisip("Jonathan", "Sitanggang", 18);
cout <<
"Sebelum pengurutan: " << endl;
arr.tampil();
//menampilkan array
arr.pengururanPenyisipan();
//pengurutan penyisipan
cout <<
"Setelah pengurutan: " << endl;
arr.tampil();
//menampilkan array
getch();
return 0;
} //akhir main()
|
Sebelum pengurutan:
Nama belakang: Rismon, nama depan: Sianipar,
usia: 24
Nama belakang: Robert, nama depan: Tohonan,
usia: 37
Nama belakang: Rico, nama depan: Chandra, usia:
43
Nama belakang: Rotua, nama depan: Marolop,
usia: 63
Nama belakang: Rini, nama depan: Meika, usia:
21
Nama belakang: Eva, nama depan: Teti, usia: 29
Nama belakang: Patricia, nama depan: Siahaan,
usia: 72
Nama belakang: Vivian, nama depan: Jozen, usia:
54
Nama belakang: Jodi, nama depan: Pratama, usia:
22
Nama belakang: Jonathan, nama depan:
Sitanggang, usia: 18
Setelah pengurutan:
Nama belakang: Eva, nama depan: Teti, usia: 29
Nama belakang: Jodi, nama depan: Pratama, usia:
22
Nama belakang: Jonathan, nama depan:
Sitanggang, usia: 18
Nama belakang: Patricia, nama depan: Siahaan,
usia: 72
Nama belakang: Rico, nama depan: Chandra, usia:
43
Nama belakang: Rini, nama depan: Meika, usia:
21
Nama belakang: Rismon, nama depan: Sianipar,
usia: 24
Nama belakang: Robert, nama depan: Tohonan,
usia: 37
Nama belakang: Rotua, nama depan: Marolop,
usia: 63
Nama belakang: Vivian, nama depan: Jozen, usia:
54
4.
Tulislah sebuah program C++ untuk merealisasikan
tumpukan dengan array.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
//arrayTumpukan.cpp
//Mendemonstrasikan tumpukan menggunakan array.
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class Tumpukan
{
private:
int ukuranMaks; //ukuran tumpukan
vector
vector<double> tumpukanVector; //tumpukan vector
int atas; //atas dari tumpukan
public:
Tumpukan(int s) : ukuranMaks(s), atas(-1)
//konstruktor
{
tumpukanVector.reserve(ukuranMaks); //ukuran vector
}
void
push(double j) //menempatkan item
ke atas tumpukan
{
tumpukanVector[++atas] = j; //menginkremen atas,
}
//menyisipkan item
double
pop() //mengambil item dari atas
{
return tumpukanVector[atas--];
//mengakses item,
}
//mendekremen atas
double
peek() //menengok ke atas tumpukan
{
return tumpukanVector[atas];
}
bool
apaKosong() //true jika tumpukan kosong
{
return (atas == -1);
}
bool
apaPenuh() //true jika tumpukan penuh
{
return (atas == ukuranMaks-1);
}
}; //akhir kelas Tumpukan
int main()
{
Tumpukan
tumpukan(10); //menciptakan tumpukan baru, ukuran 10
tumpukan.push(20); //menempatkan item pada tumpukan
tumpukan.push(40);
tumpukan.push(60);
tumpukan.push(80);
while( !tumpukan.apaKosong() )
//sampai kosong,
{ //menghapus
item dari tumpukan
double nilai = tumpukan.pop();
cout <<
nilai << " "; //menampilkan
} //akhir while
cout <<
endl;
getch();
return 0;
} //akhir main()
|
80 60 40 20
5.
Tuliskanlah sebuah program C++ yang menggunakan
tumpukan untuk membalikkan urutan karakter dalam suatu kata.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
//arrayTumpukanBalikKarakter.cpp
//Tumpukan dipakai untuk membalik sebuah kata
#include
<iostream>
#include
<vector>
#include
<string>
#include
<conio.h>
using namespace std;
class Tumpukan
{
private:
int ukuranMaks; //ukuran tumpukan
vector
vector<double> tumpukanVector; //tumpukan vector
int atas; //atas dari tumpukan
public:
Tumpukan(int s) : ukuranMaks(s), atas(-1)
//konstruktor
{
tumpukanVector.reserve(ukuranMaks); //ukuran vector
}
void
push(double j) //menempatkan item
ke atas tumpukan
{
tumpukanVector[++atas] = j; //menginkremen atas,
}
//menyisipkan item
double
pop() //mengambil item dari atas
{
return tumpukanVector[atas--];
//mengakses item,
}
//mendekremen atas
double
peek() //menengok ke atas tumpukan
{
return
tumpukanVector[atas];
}
bool
apaKosong() //true jika tumpukan kosong
{
return (atas == -1);
}
bool
apaPenuh() //true jika tumpukan penuh
{
return (atas == ukuranMaks-1);
}
}; //akhir kelas Tumpukan
class Pembalik
{
private:
string masukan; //string masukan
string keluaran; //string keluaran
public:
Pembalik(string in) : masukan(in)
//konstruktor
{ }
string lakukanPembalikan()
//membalikkan kata
{
//membaca
ukuran tumpukan maks
int ukuranTumpukan =
masukan.length();
//menciptakan
tumpukan
Tumpukan
tumpukan(ukuranTumpukan);
for(int j=0; j<masukan.length(); j++)
{
char ch = masukan[j]; //membaca
sebuah char dari masukan
tumpukan.push(ch); //menempatkan pada tumpukan
}
keluaran
= "";
while( !tumpukan.apaKosong() )
{
char ch = tumpukan.pop(); //menghapus
sebuah char,
keluaran = keluaran + ch; //menempelkan pada keluaran
}
return keluaran;
} //akhir
lakukanPembalikan()
}; //akhir kelas Pembalik
int main()
{
string masukan, keluaran;
while(true)
{
cout <<
"Masukkan sebuah kata:
";
cin >>
masukan; //membaca sebuah kata
if( masukan.length() < 2 )
//keluar jika satu karakter
break;
//menciptakan
sebuah Pembalik
Pembalik
pembalik(masukan);
keluaran =
pembalik.lakukanPembalikan();
cout
<< "Dibalik: "
<< keluaran << endl;
} //akhir while
getch();
return 0;
} //akhir main()
|
Masukkan sebuah kata: Siantar_Medan
Dibalik: nadeM_ratnaiS
Masukkan sebuah kata:
6.
Tuliskanlah sebuah program C++ yang menggunakan
tumpukan untuk mencocokkan pasangan delimiter
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
//arrayTumpukanMencocokkanDelimiter.cpp
//Tumpukan dipakai untuk memeriksa delimiter.
#include
<iostream>
#include
<string>
#include
<vector>
#include
<conio.h>
using namespace std;
////////////////////////////////////////////////////////////////
class Tumpukan
{
private:
int ukuranMaks; //ukuran tumpukan
vector
vector<double> tumpukanVector; //tumpukan vector
int atas; //atas dari tumpukan
public:
Tumpukan(int s) : ukuranMaks(s), atas(-1)
//konstruktor
{
tumpukanVector.reserve(ukuranMaks); //ukuran vector
}
void
push(double j) //menempatkan item
ke atas tumpukan
{
tumpukanVector[++atas] = j; //menginkremen atas,
}
//menyisipkan item
double
pop() //mengambil item dari atas
{
return
tumpukanVector[atas--]; //mengakses item,
}
//mendekremen atas
double
peek() //menengok ke atas tumpukan
{
return tumpukanVector[atas];
}
bool
apaKosong() //true jika tumpukan kosong
{
return (atas == -1);
}
bool
apaPenuh() //true jika tumpukan penuh
{
return (atas == ukuranMaks-1);
}
}; //akhir kelas Tumpukan
class PemeriksaDelimiter
{
private:
string masukan; //string masukan
public:
PemeriksaDelimiter(string in) : masukan(in)
//konstruktor
{ }
void periksa()
{
//membaca
ukuran tumpukan maks
int ukuranTumpukan = masukan.length();
Tumpukan tumpukan(ukuranTumpukan);
//menciptakan tumpukan
bool apaError = false; //bendera error
//membaca
runtun char secar bergiliran
for(int j=0;
j<masukan.length(); j++)
{
char ch = masukan[j]; //membaca char
switch(ch)
{
case '{': //simbol-simbol pembuka
case '[':
case '(':
tumpukan.push(ch); //menempatkan pada tumpukan
break;
case '}': //simbol-simbol penutup
case ']':
case ')':
//jika
tumpukan tidak kosong,
if( !tumpukan.apaKosong() )
{
//menghapus
dan memeriksa
char chx = tumpukan.pop();
if( (ch=='}' &&
chx!='{') ||
(ch==']' && chx!='[') ||
(ch==')' && chx!='(') )
{
apaError = true;
cout << "Delimiter
tidak cocok: "
<< ch
<< " pada "
<< j << endl;
}
}
else
{
apaError = true;
cout << "Delimiter
salah-tempat: "
<< ch << " pada
" << j << endl;
}
break;
default:
break;
} //akhir
switch
} //akhir for
//pada titik
ini, semua karakter telah diproses
if( !tumpukan.apaKosong() )
cout
<< "Delimiter kanan tidak
ada" << endl;
else if( !apaError )
cout
<< "OK" <<
endl;
} //akhir
periksa()
}; //akhir kelas PemeriksaDelimiter
int main()
{
string masukan;
while(true)
{
cout <<
"Masukkan string yang memuat
beberapa delimiter "
<<
"(tanpa spasi): ";
cin >>
masukan; //membaca string
if( masukan.length() == 1 ) //keluar
jika 'q', dan lainnya.
break;
//make a
PemeriksaDelimiter
PemeriksaDelimiter periksa(masukan);
periksa.periksa(); //periksa delimeter
} //akhir while
getch();
return 0;
} //akhir main()
|
Masukkan string yang memuat beberapa delimiter
(tanpa spasi): (x^2+y^2))
Delimiter salah-tempat: ) pada 9
Masukkan string yang memuat beberapa delimiter
(tanpa spasi): ([x^2+y^2})
Delimiter tidak cocok: } pada 9
Masukkan string yang memuat beberapa delimiter
(tanpa spasi): [x^2+y^2]
OK
7.
Tulislah sebuah program C++ untuk merealisasikan
antrian menggunakan array.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
//arrayAntrian.cpp
//mendemonstrasikan antrian
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class Antrian
{
private:
int ukuranMaks;
vector<int> vectorAntrian;
int depan;
int belakang;
int jumItem;
public:
//konstruktor
Antrian(int
s) : ukuranMaks(s), depan(0), belakang(-1), jumItem(0)
{
vectorAntrian.resize(ukuranMaks); }
void sisip(int j) //menempatkan item di belakang antrian
{
if(belakang == ukuranMaks-1)
belakang
= -1;
//menginkremen
belakang dan menyisipkan
vectorAntrian[++belakang] = j;
jumItem++; //satu item lagi ditambah
}
int hapus() //menghapus item dari
depan antrian
{
//membaca
nilai dan menginkremen depan
int temp = vectorAntrian[depan++];
if(depan == ukuranMaks)
depan
= 0;
jumItem--;
//satu item berkurang
return temp;
}
int intipDepan() //mengintip di depan
antrian
{ return vectorAntrian[depan]; }
bool apaKosong() //true jika antrian
kosong
{ return (jumItem==0); }
bool apaPenuh() //true jika antrian
penuh
{ return (jumItem==ukuranMaks); }
int ukuran() //jumlah item dalam
antrian
{ return jumItem; }
}; //akhir kelas Antrian
int main()
{
Antrian
antrian(5); //Antrian memuat 5 item
antrian.sisip(10);
//menyisipkan 4 item
antrian.sisip(20);
antrian.sisip(30);
antrian.sisip(40);
antrian.hapus();
//menghapus 3 item
antrian.hapus();
// (10, 20, 30)
antrian.hapus();
antrian.sisip(50);
//menyisipkan 4 item lagi
antrian.sisip(60);
antrian.sisip(70);
antrian.sisip(80);
while( !antrian.apaKosong() )
//menghapus dan menampilkan
{ // semua item
int n = antrian.hapus(); //(40, 50,
60, 70, 80)
cout <<
n << " ";
}
cout <<
endl;
getch();
return 0;
} //akhir main()
|
40 50 60 70 80
8.
Tulislah sebuah program C++ untuk merelasisasikan
kelas Antrian pada nomor 7 tanpa
variabel kelas jumItem.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
//arrayAntrianTanpaJumItem.cpp
//mendemonstrasikan antrian tanpa variabel jumItem
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class Antrian
{
private:
int ukuranMaks;
vector<int> vectorAntrian;
int depan;
int belakang;
public:
//konstruktor
Antrian(int s) : ukuranMaks(s), depan(0),
belakang(-1)
{
vectorAntrian.resize(ukuranMaks); }
void sisip(int j) //menempatkan item di belakang antrian
{
if(belakang == ukuranMaks-1)
belakang = -1;
//menginkremen belakang dan menyisipkan
vectorAntrian[++belakang] = j;
}
int hapus() //menghapus item dari
depan antrian
{
//membaca
nilai dan menginkremen depan
int temp = vectorAntrian[depan++];
if(depan == ukuranMaks)
depan
= 0;
return temp;
}
int intipDepan() //mengintip di depan
antrian
{ return vectorAntrian[depan]; }
bool
apaKosong() //true jika antrian kosong
{ return (belakang+1==depan || (depan+ukuranMaks-1==belakang)); }
bool apaPenuh() //true jika antrian
penuh
{ return (belakang+2==depan ||
(depan+ukuranMaks-2==belakang)); }
int ukuran() //jumlah item dalam
antrian
{
if(belakang >= depan)
return belakang-depan+1;
else
return (ukuranMaks-depan) +
(belakang+1);
}
}; //akhir kelas Antrian
int main()
{
Antrian
antrian(5); //Antrian memuat 5 item
antrian.sisip(10); //menyisipkan 4 item
antrian.sisip(20);
antrian.sisip(30);
antrian.sisip(40);
antrian.hapus();
//menghapus 3 item
antrian.hapus();
// (10, 20, 30)
antrian.hapus();
antrian.sisip(50); //menyisipkan 4 item lagi
antrian.sisip(60);
antrian.sisip(70);
antrian.sisip(80);
while( !antrian.apaKosong() )
//menghapus dan menampilkan
{ // semua item
int n = antrian.hapus(); //(40, 50,
60, 70, 80)
cout <<
n << " ";
}
cout <<
endl;
getch();
return 0;
} //akhir main()
|
40 50 60 70 80
9.
Tulislah sebuah program C++ untuk merelasisasikan antrian
prioritas.
Penyelesaian:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
//arrayAntrianPrioritas.cpp
//mendemonstrasikan antrian prioritas
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class AntrianPrioritas
{
//vector dalam
tatanan terurut,
//dari maks pada
0 sampai min pada ukuran-1
private:
int ukuranMaks;
vector<double> vectorAntrian;
int jumItem;
public:
//konstruktor
AntrianPrioritas(int s) :
ukuranMaks(s), jumItem(0)
{
vectorAntrian.resize(ukuranMaks); }
void sisip(double item) //menyisipkan item
{
int j;
if(jumItem==0) //jika tida ada item,
vectorAntrian[jumItem++] = item; //sisip pada 0
else //jika ada,
{
for(j=jumItem-1; j>=0; j--)
//mulai di akhir,
{
//jika item baru lebih besar,
if( item > vectorAntrian[j] )
vectorAntrian[j+1] = vectorAntrian[j];
else //jika lebih kecil,
break;
}
//akhir for
vectorAntrian[j+1] = item; //menyisipkan item
jumItem++;
} //akhir
else (jumItem > 0)
} //akhir
sisip()
double hapus() //menghapus item
minimum
{ return vectorAntrian[--jumItem]; }
double intipMin() //mengintip pada
item minimum
{ return vectorAntrian[jumItem-1]; }
bool apaKosong() //true jika antrian
kosong
{ return (jumItem==0); }
bool apaPenuh() //true jika antrian
penuh
{ return (jumItem == ukuranMaks); }
}; //akhir kelas AntrianPrioritas
int main()
{
AntrianPrioritas
antrianP(5); //antrian prioritas, ukuran 5
antrianP.sisip(30);
//penyisipan tak-terurut
antrianP.sisip(50);
antrianP.sisip(10);
antrianP.sisip(40);
antrianP.sisip(20);
while( !antrianP.apaKosong() )
{ //penghapusan
terurut
double item = antrianP.hapus();
cout <<
item << " "; //10, 20, 30, 40, 50
} //akhir while
cout <<
endl;
getch();
return 0;
} //akhir main()
|
10 20 30 40 50
No comments:
Post a Comment