C++ da Matritsa determinantini hisoblash dasturini ishlab chiqish
![katta bo’lmagan massivlar uchun oddiy usullar ko’proq samara beradi. Oddiy
usullar uchta asosiy kategoriyaga bo’linadi:
oddiy kiritish usuli bilan navlarga ajratish;
oddiy ajratish usuli bilan navlarga ajratish;
oddiy almashtirish usuli bilan navlarga ajratish.
Oddiy kiritish usuli bilan navlarga ajratish Massiv elementlari avvaldan tayyor
berilgan va dastlabki ketma-ketliklarga bo’linadi. i = 2 dan boshlab, har bir
qadamda dastlabki ketma-ketlikdan i-nchi element chiqarib olinadi hamda
tayyor ketma-ketlikning kerakli o’rniga kiritib qo’yiladi. Keyin i bittaga
ko’payadi va h.k. Kerakli joyni izlash jarayonida, ko’proq o’ngdan bitta
pozisiyadan tanlab olingan elementni uzatish amalga oshiriladi, ya’ni tanlab
olingan element, j: = i-1 dan boshlab, navlarga ajratib bo’lingan qismning
navbatdagi elementi bilan qiyoslanadi. Agar tanlab olingan element a[i] dan
katta bo’lsa, uni navlarga ajratish qismiga qo’shadilar, aks holda a[j] bitta
pozisiyaga suriladi, tanlab olingan elementni esa navlarga ajratilgan ketma-
ketlikning navbatdagi elementi bilan qiyoslaydilar. To’g’ri keladigan joyni
qidirish jarayoni ikkita turlicha shart bilan tugallanadi: agar a[j]>a[i] elementi
topilgan bo’lsa; agar tayyor ketma-ketlikning chap uchiga bo’lsa.
int i, j, x;
for(i = 1; i < n; i++)
{
x = [i]; // kiritib qo‘yishimiz lozim bo‘lgan elementni esda saqlab
qolamiz
j = i - 1;
while(x<a[j]&&j> = 0) //to'g‘ri keladigan joyni qidirish
}
a[j+1] = a[j]; //o‘ngga surish
}
a[j+1] = x; //elementni kiritish
4](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_4.png)
![2.2. C++ da bir o lchamli massiv va uni eʻ ʼ lon qilish
Dast urda ikki asosiy tur ma'lumot strukturalari mavjuddir. Birinchisi statik,
ikkinchisi dinamikdir. Statik deganimizda hotirada egallagan joyi o'zgarmas,
dastur boshida beriladigan strukturalarni nazarda tutamiz. Dinamik ma'lumot
tiplari dastur davomida o'z hajmini, egallagan hotirasini o'zgartirishi mumkin.
Agar struktura bir hil kattalikdagi tiplardan tuzilgan bo'lsa, uning nomi massiv
(array) deyiladi. Massivlar dasturlashda eng ko'p qo'laniladigan ma'lumot
tiplaridir. Bundan tashqari strukturalar bir necha farqli tipdagi o'zgaruvchilardan
tashkil topgan bo'lishi mumkin.
Massivlar hotirada ketma-ket joylashgan, bir tipdagi o'zgaruvchilar guruhidir.
Alohida bir o'zgaruvchini ko'rsatish uchun massiv nomi va kerakli o'zgaruvchi
indeksini yozamiz. C++ dagi massivlardagi elementlar indeksi har doim noldan
boshlanadi.
Bir o`lchovli massivni e`lon qilish quyidagicha bo`ladi: [ elementlar_soni ] =
{ boshlang'ich qiymatlar }; Quyida massivlarni e`lon qilishga bir necha misollar
keltirilgan: 1) float a[5]; 2) int m[6]; 3) bool b[10];
1) a elementlari haqiqiy sonlardan iborat bo`lgan, 5 ta elementdan tashkil
topgan massiv. Indekslari esa 0 dan 4 gacha bo`lgan sonlar float a[5]; Massiv
a[0] a[1] a[2] a[3] a[4] elementilari qiymati 4 -7 15 5.5 3
2) m elementlari butun sonlardan iborat bo`lgan, 6 ta elementdan tashkil topgan
massiv. Indekslari esa 0 dan 5 gacha bo`lgan sonlar. int m[6]; Massiv m[0] m[1]
m[2] m[3] m[4] m[5]
elementlari qiymati 2 -17 6 7 13 -3
3) b elementlari mantiqiy qiymatlardan (true, false ) iborat bo`lgan 10 ta
elementdan tashkil topgan massiv. Indekslari esa 0 dan 9 gacha bo`lgan sonlar.
Massiv elementlariga murojaat qilish oddiy o`zgaruvchilarga murojaat qilishdan
biroz farq qiladi. Massiv elementiga murojaat qilish uning indeksi orqali
bo`ladi. a[1] = 10; a massivining 1 – elementi 10 qiymat o’ zlashtirsin; cin >>
6](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_6.png)
![a[2]; a massivining 2 – elementi kirtilsin; cout << a[3]; a massivining 3 –
elementi ekranga chiqarilsin;
Massivni e'lon qilishda uning elementlariga boshlang'ich qiymat berish mumkin
va buning bir nechta usuli mavjud. 1) O'lchami ko'rsatilgan massivni to'liq
initsializatsiyalash. int k[5] = { 2, 3, 7, 8, 6}; Bu yerda 5 ta elementdan iborat
bo'lgan k massivi e'lon qilingan va massivning barcha elemantlariga
boshlang'ich qiymat berilgan.
2) O'lchami ko'rsatilgan massivni to'liqmas initsializatsiyalash. int k[5] = { 2, 3,
7 }; Bu yerda 5 ta elementdan iborat bo'lgan k massivi e'lon qilingan va
massivning dastlabki 3 ta elemantlariga boshlang'ich qiymat berilgan.
3) O'lchami ko'rsatilmagan massivni to'liq initsializatsiyalash. int k[] = { 2, 3, 7,
8, 6}; Shuni takidlash lozimki, agar massiv o'lchami ko'rsatilmasa, uni to'liq
initsializatsiyalash shart. Bu xolda massiv o'lchami kompilyatsiya jarayonida
massiv elementlari soniga qarab aniqlanadi. Bu yerda massiv o'lchami 5 ga
teng.
4) O'lchami ko'rsatilgan massivning barcha elementlariga boshlang'ich qiymat 0
berish: int k[5] = { 0 }; O'lchami ko'rsatilgan massivning barcha elementlariga
boshlang'ich qiymat 0 berish
int main()
{
int a[10] = { 0 };
//massivning barcha elementlariga 0 qiymat berish
for (int i = 0; i < 10; i++)
cout << "a[" << i << "]=" << a[i] << endl;
system ("pause");
return 0;
}
Bir o'lchamli massiv - agar uning elementiga bir indeks orqali murojaat qilish
mumkin bo`lsa.
7](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_7.png)
![Bir o'lchamli massivni e'lon qilish quyidagicha bo'ladi:
<toifa> <massiv_nomi> [ elementlar_soni ] =
{ boshlang'ich qiymatlar };
Quyida massivlarni e'lon qilishga bir necha misollar keltirilgan:
1) float a[5];
2) int m[6];
3) bool b[10];
Massivni e'lon qilishda uning elementlariga boshlang'ich qiymat berish mumkin
va buning bir nechta usuli mavjud.
1) O'lchami ko'rsatilgan massivni to'liq shakli.
int k[5] = { 2, 3, 7, 8, 6};
Bu yerda 5 ta elementdan iborat bo'lgan k massivi e'lon qilingan va massivning
barcha elemantlariga boshlang'ich qiymat berilgan.
2) O'lchami ko'rsatilgan massivni to'liqmas shakli
int k[5] = { 2, 3, 7 };
Bu yerda 5 ta elementdan iborat bo'lgan k massivi e'lon qilingan va massivning
dastlabki 3 ta elemantlariga boshlang'ich qiymat berilgan.
massiv haqida tushuncha
Muammо yechimi: Algоoritmlarni fizik jismlarni boоshqarish оorqali aniqlash,
Dasturlashda massiv bir xil turdagi elementlarni o'z ichiga olgan eng muhim
ma'lumotlar strukturasidir. U elementlarni ulashgan xotira taqsimotida saqlaydi
2.3. C++ da ko p o lchamli massivlar.ʻ ʻ
Massivlar daraja yoki o'lchovlar soni kabi tushuncha bilan tavsiflanadi.
Massivlar 1, 2, 3 yoki n o’lchamli bo’lishi mumkin. Ko’p o’lchmali massivlarni
2 o’lchamli massivlar misolida ko’rib boramiz Bir o’lchovli massivlarni bitta
gorizontal qator kabi tasavvur qilishimiz mumkin, misol uchun:
int[] nums1 = new int[] { 0, 1, 2, 3, 4};
Vizual ko’rinishda bu massiv:
8](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_8.png)
![Endi esa 2 o’lchamli massivga misol ko’ramiz:
int[,] nums2 = { { 0, 1, 2 }, { 3, 4, 5 } };
Vizual ko’rinishda bu massiv:
Ko’p o’lchamli massivlarni e’lon qilish uchun kvadrat qavs ichiga vergul
qo’yiladi, yani [,] ikki o’lchamli massiv, [,,] uch o’lchamli massiv va hokazo.
int[,] arr2d; // ikki o’lchamli massiv
int[,,] arr3d; // uch o’lchamli massiv
int[,,,] arr4d; // to’rt o’lchamli massiv
int[,,,,] arr5d; // besh o’lchamli massiv
C# 32 o’lchovgacha bo’lgan massivlarni qo’llab quvvatlaydi.
32 o’lchovgacha Karl, 32!
Odatda 1,2 yoki 3 o’lchamli massivlar ko’p ishlatiladi. 2 o’lchamli massivlar
shuningdek matritsa deb ham ataladi. Ko’p o’lchamli massivlarni ham bir
o’lchamli massivlar kabi turli hil yo’l bilan e’lon qilishimiz mumkin:
int[,] nums1;
int[,] nums2 = new int[2, 3];
int[,] nums3 = new int[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums4 = new int[,] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums5 = new[,] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] nums6 = { { 0, 1, 2 }, { 3, 4, 5 } };
Ko’p o’lchamli massivlarning elementlarini massiv elon qilingan paytda:
int[,] nums3 = new int[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } };
kabi aniqlashimiz yoki sikl yordamida elon qilishimiz mumkin:
int[,] myArr = new int[4, 5];
Random rand = new Random();
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 5; j++)
9](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_9.png)
![{
myArr[i, j] = rand.Next(1, 30);
Console.Write("{0}\t", myArr[i, j]);
}
Console.WriteLine();
}
Bu yerda Random sinfidan foydalanildi. Shuningdek massivning har bir
elementini alohidadan aniqlashimiz mumkin:
int[,] nums2 = new int[2, 3];
nums2[0, 0] = 0;
nums2[0, 1] = 1;
nums2[2, 3] = 5;
Ikki o’lchamli massivlarda [2, 3] masivning qatorlar va ustunlar sonini
belgilaydi yani 2 qatorlar soni va 3 ustunlar soni, quyida bunga misol
ko’rishingiz mumkin:
int[,] nums3 = new int[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } };
2 o’lchamli massivga misol : Sinfxonada 3 qator partalar joylashgan, har bir
qatorda 4tadan parta bor, bir partaga 1ta bola o’tiradi, oddiy hisob kitob bilan bu
honada 3*4=12 ta parta borligi va 12ta o’quvchi sig’ishini hisoblay olamiz, endi
masalaga o’tamiz, matematika fanidan imtihonda barcha o’quvchilar 3,4 yoki 5
baholarini olishdi, savol sinfning o’rtacha bahosi necha?
using System;
class Program
{
static void Main(string[] args)
{
//3 qator 4 ustunlik 2 o'lchamli massiv elon qilamiz
int[,] myArr = new int[3, 4];
Random rand = new Random();
10](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_10.png)
![for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
// random yordamida bolalarning baholarini aniqlaymiz
// (3,6) bu oraliqni bildiradi va 3,4,5 sonlarini o'z ichiga oladi
myArr[i, j] = rand.Next(3, 6);
Console.Write("{0}\t", myArr[i, j]);
}
Console.WriteLine();
}
int sum = 0; //sinfning umumiy bahosi
double average = 0.0D; //sinfnig o'rtacha bahosi
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
sum += myArr[i, j];
}
}
average = Convert.ToDouble(sum) / 12;
Console.WriteLine($"Sinfning umumiy bahosi: {sum}");
Console.WriteLine($"Sinfning o'rtacha bahosi: {average}");
}
}
Natija:
5 3 5 4
4 3 5 4
3 3 3 3
11](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_11.png)
![Quyidagi programmada 10 ta butun sondan iborat dinamik massiv yaratish,
unga qiymat berish va o`chirish amallari bajarilgan.
int main()
{
int * pvector;
if ((pvector=(int*)malloc(10*sizeof(int)))==NULL)
{
Cout<<”xotira yetarli emas!!!”;
Return 1;
}
// ajratilgan xotira soxasini to`ldirish
For (int i=0; i<10; i++) *(pvektor+i)=I;
For (int i=0; i<10; i++) cout<<*(pvector+i)<// ajratilgan xotira bo`lagini
qaytarish (o`chirish)
Free(pvector);
Return 0;
}
new operatori yordamida ,massivga hotira ajratishda obyrkt turidan keyin
kvadrat qavs ichida obyektlar soni ko`rsatiladi.
Masalan , butun turdagi 10 ta sondan iborat massivga joy ajratish uchun
pVector=new int[10];
ifodasi yozilishi kerak. Bunga qarama – qarshi ravishda , bu usulda ajratilgan
xotirani bo`shatish uchun
delete [] pVector;
ko`rsatmasini berish kerak bo`ladi;
Ikki o`lchamli dinamik massivni hosil qilish uchun
int **a;
ko`rinishidagi <> ishlatiladi.
14](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_14.png)
![Boshqa massiv satrlari soniga qarab ko`rsatkichlar massiviga dinamik xotiradan
joy ajratish kerak:
A=new int *[m] // bu yerda m massiv satrlar soni
Keyin , xar bir satr uchun takrorlash operatori yordamida xotira ajratish va
ularning boshlang`ich adreslarini a massiv elementlariga joylashtirish zarur
bo`ladi:
For (int i=0; iShuni qayd etish kerakki , dinamik massivning har bir satri
xotiraning turli joylarida joylashishi mumkin.
Ikki o`lchamli massivni o`chirishda oldin massivning har bir elementi (satri),
so`ngra massivning o`zi yo`qotiladi.
For (i=0; i
delete []a;
2.5. Matritsa determinantini hisoblash :
C++ tilida matritsa determinantini hisoblash uchun dastur yozish uchun
quyidagi qadamlarni bajarish kerak:
1. Matritsani kiritish.
2. Determinantni hisoblash uchun rekursiv funksiyani yozish.
3. Minor matritsani olish uchun yordamchi funksiyani yozish.
Quyida `determinant` funksiyasini rekursiv usulda yozish orqali 2x2 yoki undan
katta o'lchamdagi kvadrat matritsalarning determinantini hisoblaydigan dastur
ko'rsatilgan:
#include <iostream>
#include <vector>
15](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_15.png)
![using namespace std;
// Minor matritsasini olish uchun yordamchi funksiya
vector<vector<double>>getMinor(const vector<vector<double>>& mat,
int row, int col) {
int n = mat.size();
vector<vector<double>> minorMat(n - 1, vector<double>(n - 1));
int minor_i = 0, minor_j = 0;
for (int i = 0; i < n; ++i) {
if (i == row) continue;
minor_j = 0;
for (int j = 0; j < n; ++j) {
if (j == col) continue;
minorMat[minor_i][minor_j] = mat[i][j];
++minor_j;
}
++minor_i;
}
return minorMat;
}
// Determinantni hisoblaydigan rekursiv funksiya
double determinant(const vector<vector<double>>& mat)
int n = mat.size();
// Bazaviy holatlar
if (n == 1) return mat[0][0];
if (n == 2) return mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0];
double det = 0.0;
for (int col = 0; col < n; ++col) {
vector<vector<double>> minorMat = getMinor(mat, 0, col);
16](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_16.png)
![det += (col % 2 == 0 ? 1 : -1) * mat[0][col] *
determinant(minorMat);
}
return det;
}
int main() {
int n;
cout << "Matritsa o'lchamini kiriting: ";
cin >> n;
vector<vector<double>> mat(n, vector<double>(n));
cout << "Matritsa elementlarini kiriting (katak bo'yicha):\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> mat[i][j];
}
}
double det = determinant(mat);
cout << "Matritsaning determinanti: " << det << endl;
return 0;
}
Dastur qanday ishlaydi:
1. Kiritish: Foydalanuvchi matritsa o'lchamini va elementlarini kiritadi.
2. Minor matritsani olish: `getMinor` funksiyasi asosiy matritsadan minor
matritsani ajratib oladi.
3. Determinantni hisoblash: `determinant` funksiyasi rekursiv ravishda minor
matritsalar yordamida determinantni hisoblaydi.
4. Natijani chiqarish: Hisoblangan determinant ekranga chiqariladi.
Bu dastur kvadrat matritsalar bilan ishlaydi va ularda determinantni hisoblash
uchun rekursiv usuldan foydalanadi.
17](/data/documents/126b1081-c827-4d1f-a419-482202fb8a9f/page_17.png)
Mavzu: “C++ da Matritsa determinantini hisoblash dasturini ishlab chiqish " Reja I. KIRISH II. Asosiy qism 2.1. C++da matritsa tushunchasi 2.2.C++ da bir o lchamli matritsa va uni e lon qilishʻ ʼ 2.3. C++ da ko p o lchamli matritsa ʻ ʻ 2.4. C++da dinamik matritsalar bilan ishlash 2.5. C++da matritsa determinantini hisoblash III. XULOSA IV. FOYDALANGAN ADABIYOTLAR 1
KIRISH Kurs ishining asosiy maqsadi C++ dasturlash tilidan foydalangan holda matritsa determinantini hisoblaydigan dastur yaratishdir. Matritsa determinanti chiziqli algebra va uning amaliy tadbiqlarida muhim o'rin tutad. Bu jarayonda quyidagi maqsadlarga erishiladi: 1. Chiziqli algebra asoslarini tushunish: Matritsa va determinant tushunchalarini o'rganish. 2. Dasturlash ko'nikmalarini rivojlantirish: C++ tilida murakkab algoritmlarni amalga oshirish. 3. Amaliy dastur yaratish: Matritsa determinantini hisoblaydigan dastur yozish va uni test qilish. Ahamiyati Matritsa determinanti chiziqli algebra, fizika, muhandislik va boshqa ko'plab sohalarda keng qo'llaniladi. Ayniqsa, sistemalarni yechish, matritsa teskari matritsasini topish va vektorlar orasidagi bog'liqlikni aniqlashda determinanti hisoblash muhimdir. Shu sababli, matritsa determinantini hisoblay oladigan dastur yaratish nafaqat nazariy bilimlarni mustahkamlaydi, balki amaliy jihatdan ham foydali bo'ladi 2
2.1. C++da matritsa tushunchasi Matritsa tushunchasi matematika va informatika sohalarida muhim ahamiyatga ega. Quyida matritsa tushunchasi haqida batafsil ma'lumot keltirilga n: Massiv - bir xil ma'lumot turiga ega bo'lib bir nechta o'zgaruvchini har birini alohida e'lon qilish o'rniga. Bir o'zgaruvchiga bir nechta qiymat saqlash uchun ishlatiladi. Matritsa — bu sonlar, o'zgaruvchilar yoki boshqa matematik ifodalar to'plamidan tashkil topgan to'rtburchak shaklidagi jadvaldir. Matritsalar odatda qatorlar va ustunlardan tashkil topadi. C++ dasturlash tilida matritsalarni yaratish va ulardan foydalanish uchun ikki o'lchamli massivlardan foydalanish mumkin.. Matritsalar qo'llanilishi Matritsalar ko'plab sohalarda qo'llaniladi: - Chiziqli algebra: Vektorlar va chiziqli tenglamalar tizimlarini yechish. - Kompyuter grafikasi: Tasvirlarni qayta ishlash va transformatsiya qilish. - Fizika va muhandislik: Harakat tenglamalari va boshqa matematik modellarni ifodalash. - Statistika va iqtisod: Ma'lumotlarni tahlil qilish va modellashtirish. Massivlarni navlarga ajratish. Navlarga ajratish - bu berilgan ko’plab obyektlarni biron-bir belgilangan tartibda qaytadan guruhlash jarayoni. Massivlarning navlarga ajratilishi tez bajarilishiga ko’ra farqlanadi. Navlarga ajratishning n*n ta qiyoslashni talab qilgan oddiy usuli va n*log(n) ta qiyoslashni talab qilgan tez usuli mavjud. Oddiy usullar navlarga ajratish tamoyillarini tushuntirishda qulay hisoblanadi, chunki sodda va kalta algoritmlarga ega. Murakkablashtirilgan usullar kamroq sonli operasiyalarni talab qiladi, biroq operasiyalarning o’zi murakkabroq, shuning uchun uncha 3
katta bo’lmagan massivlar uchun oddiy usullar ko’proq samara beradi. Oddiy usullar uchta asosiy kategoriyaga bo’linadi: oddiy kiritish usuli bilan navlarga ajratish; oddiy ajratish usuli bilan navlarga ajratish; oddiy almashtirish usuli bilan navlarga ajratish. Oddiy kiritish usuli bilan navlarga ajratish Massiv elementlari avvaldan tayyor berilgan va dastlabki ketma-ketliklarga bo’linadi. i = 2 dan boshlab, har bir qadamda dastlabki ketma-ketlikdan i-nchi element chiqarib olinadi hamda tayyor ketma-ketlikning kerakli o’rniga kiritib qo’yiladi. Keyin i bittaga ko’payadi va h.k. Kerakli joyni izlash jarayonida, ko’proq o’ngdan bitta pozisiyadan tanlab olingan elementni uzatish amalga oshiriladi, ya’ni tanlab olingan element, j: = i-1 dan boshlab, navlarga ajratib bo’lingan qismning navbatdagi elementi bilan qiyoslanadi. Agar tanlab olingan element a[i] dan katta bo’lsa, uni navlarga ajratish qismiga qo’shadilar, aks holda a[j] bitta pozisiyaga suriladi, tanlab olingan elementni esa navlarga ajratilgan ketma- ketlikning navbatdagi elementi bilan qiyoslaydilar. To’g’ri keladigan joyni qidirish jarayoni ikkita turlicha shart bilan tugallanadi: agar a[j]>a[i] elementi topilgan bo’lsa; agar tayyor ketma-ketlikning chap uchiga bo’lsa. int i, j, x; for(i = 1; i < n; i++) { x = [i]; // kiritib qo‘yishimiz lozim bo‘lgan elementni esda saqlab qolamiz j = i - 1; while(x<a[j]&&j> = 0) //to'g‘ri keladigan joyni qidirish } a[j+1] = a[j]; //o‘ngga surish } a[j+1] = x; //elementni kiritish 4
} 5