Ta elementdan iborat bo'lgan ketma-ketlikni O'rniga qo'yish usuli bilan saralaydi

1.O'rniga qo'yish usuli (Insertion Sort) - bu odatda kichik ma'lumotlar to'plamlarini saralash uchun ishlatiladigan sodda va samarali algoritmdir. Quyidagi C++ dasturlash tilida yozilgan kod, berilgan n ta elementdan iborat bo'lgan ketma-ketlikni O'rniga qo'yish usuli bilan saralaydi:
#include

using namespace std;

void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;

// Key elementni o'rniga qo'yish

while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

int main() {

int n;
cout << "Elementlar sonini kiriting: ";
cin >> n;

int arr[n];

cout << "Ketma-ketlik elementlarini kiriting:\n";
for (int i = 0; i < n; i++) {
cin >> arr[i];
}

insertionSort(arr, n);

cout << "Saralanayotgan ketma-ketlik:\n";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;

return 0;

}

Ushbu kodda, insertionSort funksiyasi berilgan arr[] ketma-ketlikni n ta element bilan saralaydi. main funksiyasi esa foydalanuvchidan elementlar sonini va elementlarni o'zi olish, saralash va saralanayotgan ketma-ketlikni chiqarish uchun ishlatiladi.

2.C++ tilida, berilgan ihtiyoriy n ta elementdan iborat bo'lgan ketma-ketlikni tanlash usuli yordamida saralash quyidagicha bo'ladi:

#include
#include

using namespace std;

// Tanlash funksiyasi
bool compare(int a, int b) {
return abs(a) < abs(b);
}

int main() {

int n;
cout << "Ketma-ketlik uzunligini kiriting: ";
cin >> n;

int a[n];

cout << "Elementlarni kiriting: ";
for (int i = 0; i < n; i++) {
cin >> a[i];
}

// Ketma-ketlikni saralash

sort(a, a + n, compare);

// Saralgan ketma-ketlikni chiqarish

cout << "Saralgan ketma-ketlik: ";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;

return 0;

}

Bu dastur foydalanuvchi tomonidan ketma-ketlik uzunligi va undagi elementlar kiritilgandan so'ng, compare funksiyasi yordamida tanlash usuli bilan ketma-ketlikni saralaydi va saralgan ketma-ketlikni chiqaradi. compare funksiyasi, berilgan ikki sonning absolyut qiymatlarini hisoblayadi va ulardan kichigini olib, kichik sonni avval qilishni so'raydi. Bunda, agar ikki sonning absolyut qiymatlari bir xil bo'lsa, ulardan birini avval qilish qaror qabul qilinadi.

3.C++ dasturlash tilida ihtiyoriy n ta elementdan iborat bo'lgan ketma-ketlikni pufakchali usuli bilan saralash quyidagi ko'rinishda amalga oshiriladi:

#include
using namespace std;

void pufakSort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[i]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}

int main() {

int n;
cout << "Ketma-ketlik uzunligini kiriting: ";
cin >> n;
int arr[n];
cout << "Ketma-ketlik elementlarini kiriting: ";
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
pufakSort(arr, n);
cout << "Saralangan ketma-ketlik: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}

Bu dastur,pufakchali usul yordamida ihtiyoriy n ta elementdan iborat bo'lgan ketma-ketlikni saralaydi. Bu usul, iki marta chiqib, har bir elementni boshqa barcha elementlarga nisbatan tekshiradi va ularni saralashga qaror qabul qiladi. Dastur boshida, foydalanuvchi ketma-ketlik uzunligini va kerakli elementlarni kiritadi. Keyin, pufakSort funksiyasi chaqiriladi va ketma-ketlikni pufakchali usuli bilan saralaydi. Natijada saralangan ketma-ketlik konsolga chiqariladi.
4.C++ da berilgan ihtiyoriy n ta elementdan iborat ketma-ketlikni Aralash usuli bilan saralash:
#include
#include

using namespace std;

void shuffle(int arr[], int n) {
srand(time(NULL));
for (int i = n - 1; i > 0; i--) {
int j = rand() % (i + 1);
swap(arr[i], arr[j]);
}
}

int main() {

int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
shuffle(arr, n);
cout << "Shuffled array: ";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

Bu dasturda arr massivida 8 ta element bor. shuffle funktsiyasi arr massivining elementlarini aralash tartibda joylashtiradi. Natijada chiqarilgan aralash tartibli massiv konsolga chiqariladi.
5.Shell usuli yordamida n ta elementdan iborat ketma-ketlikni saralash uchun quyidagi kodni C++ dasturlash tilida ishlatishingiz mumkin:
#include
#include
#include
#include
using namespace std;

int main() {

// n elementli ketma-ketlikni aniqlash
int n;
cout << "Nechta elementdan iborat ketma-ketlik yaratmoqchi bo'lsiz? ";
cin >> n;
int arr[n];

// ketma-ketlikni tasodifiy sonlar bilan to'ldirish

srand(time(0));
for(int i=0; iarr[i] = rand() % 100;
}

// ketma-ketlikni shell usuli bilan saralash

int gap = n / 2;
while(gap > 0) {
for(int i=gap; iint j = i;
while(j >= gap && arr[j-gap] > arr[j]) {
swap(arr[j], arr[j-gap]);
j -= gap;
}
}
gap /= 2;
}

// natijalarni chiqarish

cout << "Shell usuli bilan saralgan ketma-ketlik: ";
for(int i=0; icout << arr[i] << " ";
}
cout << endl;

return 0;

}

Bu kodda, n o'zgaruvchisi yordamida ketma-ketlik uzunligi aniqlanadi va arr nomi berilgan ketma-ketlik yaratiladi. Keyin, srand funksiyasi yordamida ketma-ketlik tasodifiy sonlar bilan to'ldiriladi.
Shell usuli yordamida ketma-ketlik saralanadi. Bu usulda, ketma-ketlikni belgilangan gap orqali bo'lib bo'lmagan qismlarga ajratiladi va har bir qismi belgilangan usul bilan saralash amalga oshiriladi. Gap qiymati avval n/2, keyin 2 ga bo'linib yana 2 ga bo'linib yana chiqariladi, va gap==1 bo'lgunga qadar usul takrorlanadi.
Natijalar for tsikli yordamida ketma-ketlik elementlari chiqariladi.

6.Sizning berilgan ihtiyoriy "n" ta elementlardan iborat ketma-ketlikni piramida usuli bilan saralash uchun C++ kodlari quyidagicha bo'lishi mumkin

#include

using namespace std;

void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])

largest = left;

if (right < n && arr[right] > arr[largest])

largest = right;

if (largest != i) {

swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}

void buildHeap(int arr[], int n) {

int startIdx = (n / 2) - 1;

for (int i = startIdx; i >= 0; i--) {

heapify(arr, n, i);
}
}

void heapSort(int arr[], int n) {

buildHeap(arr, n);

for (int i = n - 1; i >= 0; i--) {

swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}

int main() {

int n;
cout << "Enter the size of array: ";
cin >> n;
int arr[n];
cout << "Enter the elements of the array: ";
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
heapSort(arr, n);
cout << "Sorted array: ";
for (int i = 0; i < n; ++i) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}

Bu kod "heapify" funksiyasi yordamida bir piramida usulida ketma-ketlikni saralaydi. "heapify" funksiyasi, piramida ustida berilgan indeksning boshqa indekslardan katta bo'lgan elementlarni topadi va ularni almashtirish yordamida piramida strukturasi saqlanadi. "buildHeap" funksiyasi, berilgan ketma-ketlikni piramida usulida saralash uchun piramida strukturasi yaratadi. "heapSort" funksiyasi, piramida ustida berilgan elementlarni saralashni aniqlovchi asosiy funksiyadir.
7.Berilgan ihtiyoriy n ta elementdan iborat bo'lgan ketma-ketlikni tez tartiblash usuli, C++ dasturlash tili bilan quyidagicha yozilishi mumkin:
#include
#include
using namespace std;

int main() {

int n;
cout << "Ketma-ketlik uzunligini kiriting: ";
cin >> n;

int a[n];

cout << "Ketma-ketlik elementlarini kiriting: ";
for (int i = 0; i < n; i++) {
cin >> a[i];
}

sort(a, a + n);

cout << "Tartiblangan ketma-ketlik: ";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;

return 0;

}

Bu dastur foydalanuvchidan ketma-ketlik uzunligini va elementlarini kiritishni so'raydi, keyin sort() funktsiyasi yordamida ketma-ketlikni tartiblaydi va natijada tartiblangan ketma-ketlikni chiqaradi. sort() funktsiyasi, C++ standart kutubidan olingan bir funksiya bo'lib, berilgan massivni tartiblab beradi. Biz uchun bu muhim, chunki bu funksiya bir nechta elementdan iborat ketma-ketliklarni saralashda juda samarali.
8.C++ da berilgan ihtiyoriy n ta elementdan iborat ketma-ketlikni Birlashtirish usuli bilan saralash:
#include

using namespace std;

void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l+(r-l)/2;
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}

int main() {

int arr[] = {8, 3, 5, 1, 4, 2, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
mergeSort(arr, 0, n - 1);
cout << "Sorted array: ";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}

Bu dasturda arr massivi 8 ta elementdan iborat. mergeSort funktsiyasi rekursiv ravishda arr massivini saralaydi. Massiv bo'laklarga bo'linadi va har bir bo'lak alohida saralanadi. Saralangan bo'laklar merge funktsiyasi yordamida birlashtiriladi. Natijada to'liq saralangan massiv hosil bo'ladi. Saralangan massiv konsolga chiqariladi.