[Sort-Quick Sort]

2024-07-12

Velox Sort est efficax algorithmus voluptua fundatur in dividendo et consilio capiendo. In media notione algorithmus huius sortis est Probatio elementi eligere, aciem in duas partes divide, ut elementum sinistrum minus quam vel aequale velit elementum, ac dextra elementum maius vel. aequale elementum Probationis, et deinde recursive ad duas partes velox genus applica.

Algorithmus gradus;

Basi elementum eligere : Eligite elementum e ordine versorium. Solet elementum elementum primis, elementum elementum postremus vel temere, eget lectus ut ex.
Partitio : Ordinare ordinem ut elementa minora quam basi elementi sint a parte sinistra basis elementi, et elementa maiora quam basi elementum sunt a dextra parte. In id ipsum tempus, elementum turpis at, fringilla quam.
recursive Sorting: Celeriter subarray in dextra parte sinistra et elementum referentis recursively.

Gradus exsequendi:

Sequens est codicem ad effectum deducendi in C lingua:

#include <stdio.h>

// 函数：交换数组中两个元素的值
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 函数：将数组分区，并返回基准元素的位置（索引）
int partition(int arr[], int low, int high) {
    int pivot = arr[high];  // 选择最后一个元素作为基准
    int i = low - 1;  // 初始化分区索引，比基准元素小的元素会放在左边

    for (int j = low; j < high; j++) {
        // 如果当前元素小于或等于基准元素，则将它交换到分区的左边
        if (arr[j] <= pivot) {
            i++;  // 移动分区索引
            swap(&arr[i], &arr[j]);
        }
    }

    // 最后将基准元素交换到正确的位置
    swap(&arr[i + 1], &arr[high]);
    return i + 1;  // 返回基准元素的位置
}

// 函数：实现快速排序
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        // 对数组进行分区
        int pi = partition(arr, low, high);

        // 对基准元素左边和右边的子数组进行递归排序
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// 函数：打印数组元素
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("n");
}

// 主函数：测试快速排序的实现
int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("原始数组: n");
    printArray(arr, n);

    quickSort(arr, 0, n - 1);

    printf("排序后的数组: n");
    printArray(arr, n);
    return 0;
}
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

Codicis analysis:

VERTO munus: Ordinate permutare solebant duo elementa.
maceriæ solvens munus: Elementum ultimum in basi ordinate elige, aciem in duas partes divide, et extremum positio indice basi elementi redde.
quickSort munus : recursiva algorithmus ad faciliorem deducendi modum. In unaquaque recursu, primum munus partitio ordinatur ad partitionem, et deinde ad duas partes divisas recursive disponitur.
printArray munus: Ordinata imprimendi elementa ad usum facilis inspiciendi voluptua consequitur.
principalis munusTest exsecutionem celeris generis et imprimendi aciem ante et post sorting.

temporis complexionem;

Tempus multiplicitas celeris modi maxime pendet ex tempore multiplicitas partitionis operationis et numerus recursivorum. Tempus multiplicitas celeritatis velocitatis est O (n^2) in casu gravissimo, sed O (n log n) in casu mediocris, quod efficiens algorithmum sortitur.

Summatim:

Velox genus efficiens sortitur genus per divisionem et consilium et partitionem operationum superans. Nullum spatium repositionis additicium requirit (nisi ACERVUS spatium recursivum vocat) et bonum habet sub mediocris adiunctis effectum. Unde velox genus est unum e algorithms communibus adhibitis in applicationibus practicis, praesertim apta ad negotia magnarum notitiarum digerendarum.

Technology sharing