REKURSI
Soal & Penyelesaian
1.
Tulislah sebuah program C++ untuk merealisasikan
rekursi dalam menampilkan argumen fungsi secara vertikal.
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
|
//rekursiArgumenVertikal.cpp
//Mendemonstrasikan fungsi
rekursi tulis_vertikal.
#include <iostream>
#include <conio.h>
using namespace std;
void tulis_vertikal(int
n);
//Prakondisi: n >= 0.
//Pascakondisi: Angka n
ditulis secara vertikal
//dengan tiap dijit pada
baris terpisah.
int main( )
{
cout << "tulis_vertikal(3):" << endl;
tulis_vertikal(3);
cout << "tulis_vertikal(12345):" << endl;
tulis_vertikal(12345);
cout << "tulis_vertikal(123456789):" << endl;
tulis_vertikal(123456789);
getch();
return
0;
}
void tulis_vertikal(int
n)
{
if
(n < 10)
{
cout << n << endl;
}
else
//n dua atau lebih dijit
{
tulis_vertikal(n / 10);
cout << (n % 10) << endl;
}
}
|
tulis_vertikal(3):
3
tulis_vertikal(12345):
1
2
3
4
5
tulis_vertikal(123456789):
1
2
3
4
5
6
7
8
9
2.
Tulislah sebuah program C++ untuk operasi pemangkatan
menggunakan rekursi.
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
|
//rekursiPemangkatan.cpp
//Mendemonstrasikan fungsi
rekursif pemangkatan.
#include <iostream>
#include <cstdlib>
#include <conio.h>
using namespace std;
int pangkat(int x, int n);
//Prakondisi: n >= 0.
//Menghasilkan x yang
dipangkat dengan n.
int main( )
{
for
(int n = 0; n < 7; n++)
cout << "3 dipangkat dengan " << n
<< " adalah " << pangkat(3, n)
<< endl;
getch();
return
0;
}
int pangkat(int x, int n)
{
if
(n < 0)
{
cout << "Argumen ilegal.\n";
exit(1);
}
if
(n > 0)
return
(pangkat(x, n - 1)*x );
else
// n == 0
return
(1);
}
|
3 dipangkat dengan 0 adalah 1
3 dipangkat dengan 1 adalah 3
3 dipangkat dengan 2 adalah 9
3 dipangkat dengan 3 adalah 27
3 dipangkat dengan 4 adalah 81
3 dipangkat dengan 5 adalah 243
3 dipangkat dengan 6 adalah 729
3.
Tulislah sebuah program C++ untuk pencarian biner menggunakan
rekursi.
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
|
//rekursiPencarianBiner.cpp
//Mendemonstrasikan fungsi rekursif pencarian biner.
#include
<iostream>
#include
<conio.h>
using namespace std;
const int
UKURAN_ARRAY = 10;
void pencarianBiner(const int a[], int awal, int akhir,
int kunci, bool& ditemukan, int&
lokasi);
int main( )
{
int a[UKURAN_ARRAY];
const int indeks_akhir = UKURAN_ARRAY - 1;
int kunci, lokasi;
bool ditemukan;
cout <<
"Masukkan angka yang ingin
dicari: ";
cin >>
kunci;
pencarianBiner(a,
0, indeks_akhir, kunci, ditemukan, lokasi);
if (ditemukan)
cout <<
kunci << " ada pada indeks
"
<<
lokasi << endl;
else
cout <<
kunci << " tidak ada dalam
array." << endl;
getch();
return 0;
}
void pencarianBiner(const int a[], int awal, int akhir,
int kunci, bool& ditemukan, int&
lokasi)
{
int tengah;
if (awal > akhir)
{
ditemukan = false;
}
else
{
tengah =
(awal + akhir)/2;
if (kunci == a[tengah])
{
ditemukan
= true;
lokasi =
tengah;
}
else if (kunci < a[tengah])
{
pencarianBiner(a, awal, tengah - 1, kunci, ditemukan, lokasi);
}
else if (kunci > a[tengah])
{
pencarianBiner(a, tengah + 1, akhir, kunci, ditemukan, lokasi);
}
}
}
|
Masukkan angka yang ingin dicari: 25
25 tidak ada dalam array.
4.
Tulislah sebuah program C++ untuk merealisasikan
program anagram menggunakan rekursi.
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
|
//rekursiAnagram.cpp
//menciptakan anagram
#include
<iostream>
#include
<string>
#include
<conio.h>
using namespace std;
class Kata
{
private:
int ukuran; //panjang kata masukan
int kounter;
string strKerja;
void rotasi(int);
void tampilKata();
public:
Kata(string); //konstruktor
void anagram(int);
};
//konstruktor
Kata::Kata(string
strMasukan) : strKerja(strMasukan), kounter(0)
{ //menginisialisasi strKerja
ukuran =
strMasukan.length(); //jumlah karakter
}
void Kata::anagram(int ukuranBaru)
{
if(ukuranBaru == 1) //jika terlalu
kecil,
return; //keluar
for(int j=0; j<ukuranBaru; j++) //untuk tiap posisi,
{
anagram(ukuranBaru-1); //sisa anagram
if(ukuranBaru==2)
tampilKata();
rotasi(ukuranBaru);
}
}
//merotasi kiri semua karakter
void Kata::rotasi(int ukuranBaru)
{
int j;
int posisi = ukuran - ukuranBaru;
char temp = strKerja[posisi];
//menyimpan karakter pertama
for(j=posisi+1; j<ukuran; j++) //menggeser
ke kiri
strKerja[j-1]
= strKerja[j];
strKerja[j-1] =
temp;
}
void Kata::tampilKata()
{
if(kounter < 99)
cout <<
" ";
if(kounter < 9)
cout <<
" ";
cout <<
++kounter << " ";
cout <<
strKerja << " ";
if(kounter%6 == 0)
cout <<
endl;
}
int main()
{
string masukan;
int pjg;
cout <<
"Masukkan sebuah kata:
";
cin >>
masukan;
pjg =
masukan.length();
Kata
kata(masukan);
kata.anagram(pjg);
getch();
return 0;
} //akhir main()
|
Masukkan sebuah kata: sinar
1
sinar 2 sinra 3 siarn
4 sianr 5 sirna 6 siran
7
snari 8 snair 9 snria
10 snrai 11 sniar 12 snira
13
sarin 14 sarni 15 sainr
16 sairn 17 sanri 18 sanir
19
srina 20 srian 21 srnai
22 srnia 23 srain 24 srani
25
inars 26 inasr 27 inrsa
28 inras 29 insar 30 insra
31
iarsn 32 iarns 33 iasnr
34 iasrn 35 ianrs 36 iansr
37
irsna 38 irsan 39 irnas
40 irnsa 41 irasn 42 irans
43
isnar 44 isnra 45 isarn
46 isanr 47 isrna 48 isran
49
narsi 50 naris 51 nasir
52 nasri 53 nairs 54 naisr
55
nrsia 56 nrsai 57 nrias
58 nrisa 59 nrasi 60 nrais
61
nsiar 62 nsira 63 nsari
64 nsair 65 nsria 66 nsrai
67
niars 68 niasr 69 nirsa
70 niras 71 nisar 72 nisra
73
arsin 74 arsni 75 arins
76 arisn 77 arnsi 78 arnis
79
asinr 80 asirn 81 asnri
82 asnir 83 asrin 84 asrni
85
ainrs 86 ainsr 87 airsn
88 airns 89 aisnr 90 aisrn
91
anrsi 92 anris 93 ansir
94 ansri 95 anirs 96 anisr
97
rsina 98 rsian 99 rsnai 100 rsnia 101 rsain 102 rsani
103 rinas 104 rinsa 105 riasn 106 rians 107
risna 108 risan
109 rnasi 110 rnais 111 rnsia 112 rnsai 113
rnias 114 rnisa
115 rasin 116 rasni 117 rains 118 raisn 119
ransi 120 ranis
5.
Tulislah sebuah program C++ untuk pencarian biner
menggunakan rekursi yang lebih sistematis.
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
|
//rekursiPencarianBinerLengkap.cpp
//Mendemonstrasikan pencarian biner rekursif
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class ArrayTerurut
{
private:
vector<double> v; //vector v
int jumElemen; //jumlah item data
public:
ArrayTerurut(int max) //konstruktor
{
v.resize(max); //ukuran array
jumElemen
= 0;
}
int bacaUkuran() //menghasilkan
jumlah elemen
{ return jumElemen; }
int cari(double kunciPencarian)
{
return cariRekursif(kunciPencarian,
0, jumElemen-1);
}
int cariRekursif(double kunciPencarian, int batasBawah, int batasAtas)
{
int posSkrg;
posSkrg =
(batasBawah + batasAtas ) / 2;
if(v[posSkrg]==kunciPencarian)
return posSkrg; //ditemukan
else if(batasBawah > batasAtas)
return jumElemen; //tidak ditemukan
else //membagi rentang
{
if(v[posSkrg] < kunciPencarian) //ada di potongan atas
return cariRekursif(kunciPencarian,
posSkrg+1, batasAtas);
else //ada di potongan bawah
return cariRekursif(kunciPencarian,
batasBawah, posSkrg-1);
} //akhir
else
} //akhir
cariRekursif()
void sisip(double nilai) //menempatkan elemen ke dalam array
{
int j;
for(j=0; j<jumElemen; j++)
if(v[j] > nilai) //(pencarian
linier)
break;
for(int k=jumElemen; k>j; k--)
v[k]
= v[k-1];
v[j]
= nilai;
jumElemen++;
} //akhir
sisip()
void tampil()
{
for(int j=0; j<jumElemen; j++)
cout
<< v[j] << " ";
cout
<< endl;
}
}; //akhir kelas ArrayTerurut
int main()
{
int ukuranMaks = 100; //ukuran array
ArrayTerurut
arr(ukuranMaks); //array terurut
arr.sisip(72);
//menyisipkan item-item
arr.sisip(90);
arr.sisip(45);
arr.sisip(126);
arr.sisip(54);
arr.sisip(99);
arr.sisip(144);
arr.sisip(27);
arr.sisip(135);
arr.sisip(81);
arr.sisip(18);
arr.sisip(108);
arr.sisip(9);
arr.sisip(117);
arr.sisip(63);
arr.sisip(36);
arr.tampil();
//menampilkan array
int kunciPencarian = 27; //mencari
item dengan nilai 27
if( arr.cari(kunciPencarian) !=
arr.bacaUkuran() )
cout <<
"Menemukan " <<
kunciPencarian << endl;
else
cout <<
"Tidak ditemukan " << kunciPencarian << endl;
getch();
return 0;
} //akhir main()
|
9 18 27 36 45 54 63 72 81 90 99 108 117 126 135
144
Menemukan 27
6.
Tulislah sebuah program C++ untuk merealisasikan
pencarian Merge menggunakan rekursi.
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
|
//rekursiPengurutanMerge.cpp
//Mendemonstrasikan pengurutan Merge rekursif.
#include
<iostream>
#include
<vector>
#include
<conio.h>
using namespace std;
class DArray
{
private:
vector<double>(vektor); //vektor double
int jumElemen; //jumlah item data
void
pengurutanMergeRekursif(vector<double>,
int, int);
void merge(vector<double>, int, int, int);
public:
DArray(int maks) : jumElemen(0)
//konstruktor
{
vektor.resize(maks); //ukuran vector
}
void sisip(double nilai) //menempatkan elemen ke dalam array
{
vektor[jumElemen] = nilai; //menyisipkan
jumElemen++; //menginkremen ukuran
}
void tampil() //menampilkan isi array
{
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
cout
<< vektor[j] << " "; //menampilkan
cout
<< endl;
}
void pengurutanMerge() //dipanggil
oleh main()
{
vector<double>(vektorKerja);
vektorKerja.resize(jumElemen);
pengurutanMergeRekursif(vektorKerja, 0, jumElemen-1);
}
}; //akhir kelas DArray
void
DArray::pengurutanMergeRekursif(vector<double> vektorKerja,
int batasBawah, int batasAtas)
{
if(batasBawah == batasAtas)
return;
else
{ //mencari
titik-tengah
int tengah = (batasBawah+batasAtas) /
2;
//mengurutkan
potongan bawah
pengurutanMergeRekursif(vektorKerja, batasBawah, tengah);
//mengurutkan
potongan atas
pengurutanMergeRekursif(vektorKerja, tengah+1, batasAtas);
//menggabungkan
keduanya
merge(vektorKerja, batasBawah, tengah+1, batasAtas);
} //akhir else
} //akhir pengurutanMergeRekursif()
void DArray::merge(vector<double> vektorKerja, int ptrBawah,
int ptrAtas, int batasAtas)
{
int j = 0;
int batasBawah = ptrBawah;
int tengah = ptrAtas-1;
int n = batasAtas-batasBawah+1;
while(ptrBawah <= tengah
&& ptrAtas <= batasAtas)
if( vektor[ptrBawah] <
vektor[ptrAtas] )
vektorKerja[j++] = vektor[ptrBawah++];
else
vektorKerja[j++] = vektor[ptrAtas++];
while(ptrBawah <= tengah)
vektorKerja[j++] = vektor[ptrBawah++];
while(ptrAtas <= batasAtas)
vektorKerja[j++] = vektor[ptrAtas++];
for(j=0; j<n; j++)
vektor[batasBawah+j] = vektorKerja[j];
} //akhir merge()
int main()
{
const int ukuranMaks = 100; //menciptakan array
DArray
arr(ukuranMaks);
arr.sisip(64);
//menyisipkan item-item
arr.sisip(21);
arr.sisip(33);
arr.sisip(70);
arr.sisip(12);
arr.sisip(85);
arr.sisip(44);
arr.sisip(3);
arr.sisip(99);
arr.sisip(0);
arr.sisip(108);
arr.sisip(36);
arr.tampil();
//menampilkan item-item
arr.pengurutanMerge();
//pengurutan-merge atas array
arr.tampil();
//menampilkan item-item kembali
getch();
return 0;
} //akhir main()
|
64 21 33 70 12 85 44 3 99 0 108 36
0 3 12 21 33 36 44 64 70 85 99 108
7.
Tulislah sebuah program C++ untuk merealisasikan
pencarian Quick menggunakan rekursi.
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
|
//rekursiPengurutanQuick.cpp
//Mendemonstrasikan versi sederhana dari pengurutan Quick
#include
<iostream>
#include<vector>
#include<cstdlib>
#include<ctime>
#include<conio.h>
using namespace std;
class ArrayQuick
{
private:
vector<double>(vektor); //vector double
int jumElemen; //jumlah item data
public:
ArrayQuick(int maks) : jumElemen(0)
//konstruktor
{
vektor.resize(maks); //ukuran vector
}
void sisip(double nilai) //menempatkan elemen ke dalam array
{
vektor[jumElemen] = nilai; //menyisipkan
jumElemen++; //menginkremen ukuran
}
void tampil() //menampilkan isi array
{
cout
<< "A= ";
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
cout
<< vektor[j] << " "; //menampilkan
cout
<< endl;
}
void pengurutanQuick() //mengurutkan
array
{
pengurutanQuickRek(0, jumElemen-1);
}
void pengurutanQuickRek(int kiri, int kanan) //pengurutan Quick rekursif
{
if(kanan-kiri <= 0) //jika ukuran
<= 1,
return; // telah terurut
else //ukuran 2 atau lebih besar
{
double pivot = vektor[kanan];
//mempartisi rentang
int partisi = partisiIt(kiri, kanan,
pivot);
pengurutanQuickRek(kiri, partisi-1);
pengurutanQuickRek(partisi+1, kanan);
}
} //akhir pengurutanQuickRek()
int partisiIt(int kiri, int kanan, double pivot)
{
int tandaKiri = kiri-1;
int tandaKanan = kanan;
while(true)
{ //mencari item
lebih besar
while( vektor[++tandaKiri] < pivot
)
; // (tidak
ada operasi)
//mencari
item lebih kecil
while(tandaKanan > 0 &&
vektor[--tandaKanan] > pivot)
; //
(tidak ada operasi)
if(tandaKiri >= tandaKanan)
break; // partisi selesai
else
tukar(tandaKiri, tandaKanan);
} //akhir
while(true)
tukar(tandaKiri,
kanan);
return tandaKiri;
} //akhir partisiIt()
void tukar(int dex1, int dex2)
//menukar dua elemen
{
double temp = vektor[dex1]; //A ke
dalam temp
vektor[dex1] =
vektor[dex2]; //B ke dalam A
vektor[dex2] =
temp; //temp ke dalam B
} //akhir tukar
}; //akhir kelas ArrayQuick
int main()
{
time_t waktuA;
int ukuranMaks = 16; //ukuran array
ArrayQuick
arr(ukuranMaks); //menciptakan array
srand(
static_cast<unsigned>(time(&waktuA)) ); //menanam
tunas acak
for(int j=0; j<ukuranMaks; j++) //mengisi array dengan
{ //angka-angka
acak
double n = rand() % 99;
arr.sisip(n);
}
arr.tampil();
//menampilkan item-item
arr.pengurutanQuick(); //melakukan pengurutanQuick
arr.tampil();
//menampilkan kembali
getch();
return 0;
} //akhir main()
|
A= 95 55 89 40 2 97 69 18 93 3 10 1 9 40 36 67
A= 1 2 3 9 10 18 36 40 40 55 67 69 89 93 95 97
8.
Tulislah sebuah program C++ untuk merealisasikan
pencarian Quick yang lebih baik menggunakan rekursi.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
//rekursiPengurutanQuickBaik.cpp
//Mendemonstrasikan pengurutan Quick dengan partisi
median-tiga
#include
<iostream>
#include
<vector>
#include
<cstdlib>
#include
<ctime>
#include<conio.h>
using namespace std;
class ArrayQuick
{
private:
vector<double>(vektor); //vector double
int jumElemen; //jumlah item data
public:
ArrayQuick(int maks) : jumElemen(0)
//konstruktor
{
vektor.resize(maks); //ukuran vector
}
void sisip(double nilai) //menempatkan elemen ke dalam array
{
vektor[jumElemen] = nilai; //menyisipkan
jumElemen++; //menginkremen ukuran
}
void tampil() //menampilkan isi array
{
cout << "A= ";
for(int j=0; j<jumElemen; j++) //untuk tiap elemen,
cout
<< vektor[j] << " "; //menampilkan
cout
<< endl;
}
void pengurutanQuick() //mengurutkan
array
{
pengurutanQuickRek(0,
jumElemen-1);
}
void pengurutanQuickRek(int kiri, int
kanan)
{
int ukuran = kanan-kiri+1;
if(ukuran <= 3) //pengurutan
manual jika ukuran kecil
pengurutanManual(kiri, kanan);
else //pengurutanQuick jika ukuran
besar
{
double median = median3(kiri, kanan);
int partisi = partisiIt(kiri, kanan,
median);
pengurutanQuickRek(kiri, partisi-1);
pengurutanQuickRek(partisi+1, kanan);
}
} //akhir
pengurutanQuickRek()
double median3(int kiri, int kanan)
{
int tengah = (kiri+kanan)/2;
//mengurutkan kiri & tengah
if( vektor[kiri] > vektor[tengah]
)
tukar(kiri, tengah);
//mengurutkan
kiri & kanan
if( vektor[kiri] > vektor[kanan] )
tukar(kiri, kanan);
//mengurutkan
tengah & kanan
if( vektor[tengah] > vektor[kanan]
)
tukar(tengah, kanan);
tukar(tengah,
kanan-1); //menempatkan pivot di kanan
return vektor[kanan-1];
//menghasilkan nilai median
} //akhir
median3()
void tukar(int dex1, int dex2)
//menukar dua elemen
{
double temp = vektor[dex1]; //A ke
dalam temp
vektor[dex1] = vektor[dex2]; //B ke dalam A
vektor[dex2] = temp; //temp ke dalam B
} //akhir
tukar
int partisiIt(int kiri, int kanan, double pivot)
{
int tandaKiri = kiri-1;
int tandaKanan = kanan;
while(true)
{
//mencari item lebih besar
while( vektor[++tandaKiri] < pivot
)
; //
(tidak ada operasi)
//mencari
item lebih kecil
while(tandaKanan > 0
&& vektor[--tandaKanan] > pivot)
; //
(tidak ada operasi)
if(tandaKiri >= tandaKanan)
break; // partisi selesai
else
tukar(tandaKiri,
tandaKanan);
} //akhir
while(true)
tukar(tandaKiri,
kanan);
return tandaKiri;
} //akhir
partisiIt()
void pengurutanManual(int kiri, int kanan)
{
int ukuran = kanan-kiri+1;
if(ukuran <= 1)
return; //tidak diperlukan pengurutan
if(ukuran == 2)
{
if( vektor[kiri] > vektor[kanan] )
tukar(kiri,
kanan);
return;
}
else
{
if( vektor[kiri] > vektor[kanan-1]
)
tukar(kiri, kanan-1); //kiri, tengah
if( vektor[kiri] > vektor[kanan] )
tukar(kiri, kanan); //kiri, kanan
if( vektor[kanan-1] >
vektor[kanan] )
tukar(kanan-1, kanan); //tengah, kanan
}
}
//akhir pengurutanManual()
}; //akhir kelas ArrayIns
int main()
{
time_t waktuA;
int ukuranMaks = 16; //ukuran array
ArrayQuick
arr(ukuranMaks); //menciptakan array
srand( static_cast<unsigned>(time(&waktuA))
); //tunas acak
for(int j=0;
j<ukuranMaks; j++) //mengisi array dengan
{ //angka-angka
acak
double n = rand() % 99;
arr.sisip(n);
}
arr.tampil();
//menampilkan array
arr.pengurutanQuick();
//melakukan pengurutanQuick
arr.tampil();
//menampilkan array
getch();
return 0;
} //akhir main()
|
A= 37 7 45 51 30 76 27 44 3 9 63 72 13 91 66 4
A= 3 4 13 7 9 27 37 30 44 45 51 63 66 76 72 91
No comments:
Post a Comment