1-misol. Berilgan a massiv elementlarini Insertsion sort usuli yordamisda saralansin. 2-misol

1-mavzu Statik MT Algoritm yozish usullari .Algoritm sinflari.
1-misol.
Berilgan A massiv elementlarini Insertsion sort usuli yordamisda saralansin.




2-misol.
Berilgan bir o`lchovli massiv ichidan qiymati 5 ga teng bo`lgan massiv elementi bor yo`qligini aniqlovchi dastur tuzing. Agar bu qiymat mavjud bo’lsa ekranga ushbu element joylashgan index raqami chiqarilsin . [ chiziqli qidiruv ]

2-Mavzu Rekursiv algoritmlar va ularning funksiyalari

Rekursiv algoritm, bir dastlabki vazifani bajarish uchun o'zini qayta-qayta chaqirib turadi. Buning o'rniga, algoritm bir necha qadamda yoki vazifalarda o'zini qayta ishlatadi. Rekursiv funksiyalar esa rekursiv algoritmlarni yaratish uchun ishlatiladigan dasturiy tillardagi funksiyalardir.
Rekursiv algoritmni yaratish uchun biror vazifani undan kichik bo'lgan bir nechta o'zodan yoki ma'lumotdan foydalanish mumkin. Rekursiv funksiyalarda esa o'zini chaqirish (rekursiya) orqali vazifa yechimini topish mumkin.
Masalan, faktorialni hisoblash uchun rekursiv algoritmni yozish mumkin. Faktorialni hisoblashda, n faktorialini topish uchun n! = n * (n-1)! formula qo'llaniladi. Shunday qilib, faktorialni hisoblash algoritmi rekursiv tarzda yoziladi.
#include

// Rekursiv faktorial hisoblash funksiyasi

unsigned int faktorial(unsigned int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * faktorial(n - 1);
}
}

int main() {

unsigned int n = 5; // Misol uchun 5 faktorialini hisoblaymiz

unsigned int natija = faktorial(n);

std::cout << n << " faktoriali = " << natija << std::endl;

return 0;

}
Misollar
Rekursiv Fibonachchi ketma-ketligi hisoblash funksiyasi tuzilsin

#include

// Rekursiv Fibonachchi ketma-ketligi hisoblash funksiyasi
int fibonachchi(int n) {
if (n <= 1) {
return n;
} else {
return fibonachchi(n - 1) + fibonachchi(n - 2);
}
}

int main() {

int n = 7; // Misol uchun 7-lik Fibonachchi ketma-ketligini hisoblaymiz

std::cout << "Fibonachchi ketma-ketligi: ";

for (int i = 0; i < n; ++i) {
std::cout << fibonachchi(i) << " ";
}
std::cout << std::endl;

return 0;

}

Rekursiv ekub hisoblash funksiyasi hisoblansin
#include

// Rekursiv ekub hisoblash funksiyasi

int ekub(int a, int b) {
if (b == 0) {
return a;
} else {
return ekub(b, a % b);
}
}

int main() {

int number1 = 56;
int number2 = 84;

int result = ekub(number1, number2);

std::cout << "Ekub: " << result << std::endl;

return 0;

}

3-mavzu Binar daraxtlar bilan ishlash
1-misol
Berilgan a va b sonlarining EKUKini topuvchi rekursiv funksiya tuzing.

Daraxtning balandligini aniqlashni o’rganganimizdan keyin uning muvoza-natlanganligini tekshirish mumkin. Binar daraxtning muvozanatlanganligini tekshirish uchun uning har bir tugunini har ikkala qismdaraxti balandliklarini hisoblab, farqlarini tekshirib ko’rish kerak. Agar farq 0 yoki 1 ga teng bo’lsa, bu muvozanatlangan daraxt hisoblanadi. Quyida binar daraxtni muvozanatlanganlikka tekshirishning rekursiv funksiyasini qo’llovchi dastur keltirilgan.

#include
#include
using namespace std;
class node{
public: int info;
node *left;
node *right;
};
int k=0,Flag=1;
int height(node *tree){
int h1,h2;
if (tree==NULL) return (-1);
else {
h1 = height(tree->left);
h2 = height(tree->right);
if (h1>h2) return (1 + h1);
else return (1 + h2);
}
}
void vizual(node *tree,int l)
{ int i;
if(tree!=NULL) {
vizual(tree->right,l+1);
for (i=1; i<=l; i++) cout<<" ";
cout<info<vizual(tree->left,l+1);
}
}
int AVLtree (node *tree){
int t;
if (tree!=NULL){
t = height (tree->left) - height (tree->right);
if ((t<-1) || (t>1)) { Flag = 0; return Flag; }
AVLtree (tree->left); AVLtree (tree->right);
}
}
int GetFlag(){return Flag;}
int main()
{ int n,key,s; node *tree=NULL,*next=NULL;
cout<<"n="; cin>>n; int arr[n];
for(int i=0; inode *p=new node;
node *last=new node;
cin>>s;
p->info=s;
p->left=NULL;
p->right=NULL;
if(i==0){tree=p; next=tree; continue; }
next=tree;
while(1)
{ last=next;
if(p->infoinfo)next=next->left;
else next=next->right;
if(next==NULL)break; }
if(p->infoinfo)last->left=p;
else last->right=p;}
cout<cout<<"\nbinar daraxt:\n";
vizual(tree,0);
AVLtree(tree);
if(GetFlag()) cout<<"ha, muvozanatlangan daraxt"; else cout<<"yo’q, muvozanatlanmagan daraxt";cout<
getch();
2-misol

Yuqorida keltirilgan bir nechta algoritmlarni qo’llab bitta misol ko’rib chiqamiz.
berilgan binar daraxtning balandligini aniqlang va muvozanatlang.

#include

#include
using namespace std;
class node{
public: int info;
node *left;
node *right;
};
int k=0;
int intrave(node *tree){
if (tree!=NULL){int a=NULL, b=NULL;
if (tree->left!=NULL){ a=tree->left->info; }
if (tree->right!=NULL){ b=tree->right->info; }
cout<info<<"--chapida=>"<"<intrave(tree->left);
intrave(tree->right); }
return 0;
}
int height(node *tree){
int h1,h2;
if (tree==NULL) return (-1);
else {
h1 = height(tree->left);
h2 = height(tree->right);
if (h1>h2) return (1 + h1);
else return (1 + h2);
}
}
int create_arr(node *tree,int *arr){
if(!tree) return 0;
else{
create_arr(tree->left,arr);
arr[k++]=tree->info;
create_arr(tree->right,arr);
}
}
node *new_tree(int *arr, int start, int end)
{
if(start>end) return NULL;
else {
int mid=(start+end)/2;
node *tree=new node;
tree->info=arr[mid];
tree->left=new_tree(arr,start,mid-1);
tree->right=new_tree(arr,mid+1,end);
return tree;
}
}
void vizual(node *tree,int l)
{ int i;
if(tree!=NULL) {
vizual(tree->right,l+1);
for (i=1; i<=l; i++) cout<<" ";
cout<info<vizual(tree->left,l+1);
}
}
int main()
{ int n,key,s; node *tree=NULL,*next=NULL;
cout<<"n="; cin>>n; int arr[n];
for(int i=0; inode *p=new node;
node *last=new node;
cin>>s;
p->info=s;
p->left=NULL;
p->right=NULL;
if(i==0){tree=p; next=tree; continue; }
next=tree;
while(1)
{ last=next;
if(p->infoinfo)next=next->left;
else next=next->right;
if(next==NULL)break; }
if(p->infoinfo)last->left=p;
else last->right=p;}
cout<intrave(tree);
cout<<"\nya'ni\n";
vizual(tree,0);
int h=height(tree);
cout<<"balandligi="<create_arr(tree,arr);
for(int i=0;itree=new_tree(arr,0,k-1);
vizual(tree,0);
getch();
}

4-mavzu Qidiruv algoritimlar

1-misol
Massivning toq elementlarini yig’indisi toppish
#include

using namespace std;

int main()
{
int n,s=0;
cin>>n;
int a[n];
for(int i=0;i{cin>>a[i];
if(a[i]<0)
s=s+a[i];

}
cout<

}

2-misol
#include

using namespace std;

int main()
{
int n,s=0;
cin>>n;
int a[n];
for(int i=0;i{cin>>a[i];
if(a[i]<0)
s=s+a[i];

}
cout<

}

5-mavzu Saralash algoritmlari
1-misol
#include
using namespace std;
// Array[] ikkita ichki massivni birlashtiradi.
//Birinchi ichki massiv - Array[l..m]
// Ikkinchi ichki massiv Array[m+1..r]
void merge(int Array[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;
// Vaqtinchalik massivlarni yaratish
int L[n1], R[n2];
// Ma‟lumotlarni vaqtinchalik L[] va R[] massivlariga nusxalash
for (int i = 0; i < n1; i++)
L[i] = Array[l + i];
for (int j = 0; j < n2; j++)
R[j] = Array[m + 1 + j];
// Vaqtinchalik massivlarni yana arr [l..r] ga birlashtirish.
// Birinchi ichki massivning boshlangʻich koʻrsatkichi
int i = 0;
67
// Ikkinchi kichik massivning boshlangʻich koʻrsatkichi
int j = 0;
// Birlashtirilgan ichki massivning dastlabki koʻrsatkichi
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
Array[k] = L[i];
i++;
}
else {
Array[k] = R[j];
j++;
}
k++;
}
// L [] ning qolgan elementlarini nusxalash,
//agar mavjud boʻlsa
while (i < n1) {
Array[k] = L[i];
i++;
k++;
}
// Agar mavjud boʻlsa, R [] ning
//qolgan elementlarini nusxalash
while (j < n2) {
Array[k] = R[j];
j++;
k++;
}
}
// l chap indeks uchun,
//r esa tartiblangan ichki massivning oʻng indeksidir
void mergeSort(int Array[],int l,int r){
68
if(l>=r){
return;//rekursiv ravishda qaytadi
}
int m =l+ (r-l)/2;
mergeSort(Array,l,m);
mergeSort(Array,m+1,r);
merge(Array,l,m,r);
}
// Massivni chop etish funksiyasi
void printArrayay(int A[], int size)
{
for (int i = 0; i < size; i++)
cout << A[i] << " ";
}
int main()
{
int Array[] = { 12, 11, 13, 5, 6, 7 };
int Array_size = sizeof(Array) / sizeof(Array[0]);
cout << "Berilgan massiv \n";
printArrayay(Array, Array_size);
mergeSort(Array, 0, Array_size - 1);
cout << "\n Tartiblangan massiv \n";
printArrayay(Array, Array_size);
return 0;
}



6-Mavzu Xesh jadvallari
Xesh jadvallar (hash tables) ma'lumotlarni saqlashda va ularga qo'lda tezroq murojaat qilishda samarali bo'lgan ma'lumotlar tuzilmasi hisoblanadi. Ular bir nechta ma'lumotlarni tegishli indekslar orqali o'z ichiga oladi va bundan foydalanib ma'lumotlarga tezroq murojaat qilish imkoniyatini beradi.
Xesh jadvallar quyidagi elementlardan iborat:
Kalitlar (Keys): Bu ma'lumotlarning indekslarini aniqlash uchun ishlatiladi. Bu kalitlar xususiyatlar yoki ma'lumotlar bo'lishi mumkin.
Xesh jadvallar yoki hash tables ma'lumotlarni tegishli indekslar orqali saqlash uchun ishlatiladi. Kalitlar (keys) bu jadvallarning asosiy qismidir. Bu kalitlar ma'lumotlarni identifikatsiya qilish uchun ishlatiladi va ularga bog'liq ma'lumotlar (values)ni aniqlash uchun foydalaniladi.
Kalitlar quyidagi xususiyatlarga ega:

1.