Chrono kutubxonasi va uning funksiyalari
![III. BOB CHRONO KUTUBXONASINING AMALIY QO‘LLANILISHI
3.1 A goritmlarni test qilish va samaradorlikni o‘lchash
Algoritmlarning samaradorligini o‘lchashda asosiy parametrlar — vaqt va resurslar
sarfi hisoblanadi. Samaradorlikni o‘lchash uchun, C++ da chrono kutubxonasi
yordamida vaqtni o‘lchash imkoniyatiga egamiz. Vaqt o‘lchovlari algoritmning
ishlash vaqtini baholashda qo‘llaniladi.
Samaradorlikni o‘lchashning umumiy yondashuvi:
Algoritmning boshlanish va tugash vaqtini o‘lchash.
O‘tgan vaqtni hisoblash va samaradorlikni baholash.
Yirik ma'lumotlar to‘plami bilan algoritmni test qilish.
Misol:
Quyidagi misolda, bir nechta raqamlarning yig‘indisini hisoblaydigan oddiy
algoritmning samaradorligi o‘lchanmoqda:
#include <iostream>
#include <chrono>
#include <vector>
int main() {
// 1 dan 10^6 gacha bo'lgan sonlar ro'yxati
std::vector<int> numbers(1000000);
for (int i = 0; i < 1000000; ++i) {
numbers[i] = i + 1;
}
// Algoritmning boshlanish va tugash vaqtlari
auto start = std::chrono::high_resolution_clock::now();
long long sum = 0;
for (int num : numbers) {
sum += num;
20](https://docx.uz/documents/cff846bf-effc-477d-906e-f77462586978/page_19.png?v=1)
![ Ma'lumotlar tuzilmasini yaxshilash: Algoritm samaradorligi ma'lumotlar
tuzilmasiga bog‘liq. Misol uchun, tartiblash algoritmlarini yaxshilashda turli
algoritmlarni (masalan, QuickSort va MergeSort) taqqoslash mumkin.
Memoriyadan samarali foydalanish: Xotira sarfini kamaytirish uchun
dynamic programming yoki greedy yondashuvlarini qo‘llash mumkin.
Parallel ishlash: Dasturda ko‘p vazifali (multithreading) ishlash yordamida
algoritm samaradorligini oshirish mumkin. Bu ko‘p yadroli protsessorlarda
samarali ishlashga yordam beradi.
Misol: Parallel hisoblash
Quyidagi misolda, OpenMP yordamida parallel hisoblash amalga oshirilmoqda:
#include <iostream>
#include <chrono>
#include <vector>
#include <omp.h>
int main() {
// 1 dan 10^6 gacha bo'lgan sonlar ro'yxati
std::vector<int> numbers(1000000);
for (int i = 0; i < 1000000; ++i) {
numbers[i] = i + 1;
}
auto start = std::chrono::high_resolution_clock::now();
long long sum = 0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < numbers.size(); ++i) {
sum += numbers[i];
}
22](https://docx.uz/documents/cff846bf-effc-477d-906e-f77462586978/page_21.png?v=1)
![auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Yig'indi: " << sum << std::endl;
std::cout << "Algoritm bajarilish vaqti (parallel): " << elapsed.count() << "
soniya" << std::endl;
return 0;
}
Bu misolda, OpenMP yordamida ko‘p yadroli hisoblash ishlari parallel tarzda
bajariladi, bu esa vaqtni sezilarli darajada qisqartiradi.
4. Vaqt va samaradorlikni taqqoslash
Algoritmlarni taqqoslashda eng oddiy metod — ularning ishlash vaqtini
taqqoslash. Dastur yoki algoritmni optimallashtirishda vaqtni o‘lchash asosiy
yondashuv bo‘lib, samaradorlikni aniqlash uchun yordam beradi.
Misol: Algoritmlarni taqqoslash
#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>
// Oddiy tartiblash algoritmi (Bubble Sort)
void bubbleSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n-1; ++i) {
for (int j = 0; j < n-i-1; ++j) {
if (arr[j] > arr[j+1]) {
std::swap(arr[j], arr[j+1]);
}
}
23](https://docx.uz/documents/cff846bf-effc-477d-906e-f77462586978/page_22.png?v=1)
![}
}
// Tez tartiblash algoritmi (QuickSort)
void quickSort(std::vector<int>& arr, int low, int high) {
if (low < high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; ++j) {
if (arr[j] < pivot) {
++i;
std::swap(arr[i], arr[j]);
}
}
std::swap(arr[i+1], arr[high]);
quickSort(arr, low, i);
quickSort(arr, i+2, high);
}
}
int main() {
std::vector<int> arr1(100000);
std::vector<int> arr2(100000);
for (int i = 0; i < 100000; ++i) {
arr1[i] = rand() % 100000;
arr2[i] = arr1[i];
}
// Bubble Sort
24](https://docx.uz/documents/cff846bf-effc-477d-906e-f77462586978/page_23.png?v=1)
Chrono kutubxonasi va uning funksiyalari