1. 冒泡排序
冒泡排序通过重复遍历数组，比较相邻元素并交换它们的位置（如果它们的顺序错误），直到没有需要交换的，即数组排序完成。
```c
void bubble_sort(int arr[], int n) {
for (int i = 0; i < n1; i++) {
for (int j = 0; j < ni1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
```
2. 插入排序
插入排序通过将数组的一个元素插入到前面已经排序好的序列中，适合小数据量或部分已排序的数据。
```c
void insertion_sort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j;
arr[j + 1] = key;
```
3. 选择排序
选择排序每次从未排序的部分选择最小（或最大）的元素，放到排序序列的起始位置。
```c
void selection_sort(int arr[], int n) {
for (int i = 0; i < n1; i++) {
int min_idx = i;
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
if (min_idx != i) {
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
```
4. 快速排序
快速排序是一种高效的排序算法，采用分治法策略，选取一个“基准”元素，将数组分为两部分，一部分都比基准小，另一部分都比基准大，然后递归地对这两部分进行快速排序。
```c
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);
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low 1);
for (int j = low; j <= high 1; j++) {
if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
swap(&arr[i + 1], &arr[high]);
return (i + 1);
```
5. 归并排序
归并排序也是分治法的典型应用，将数组分成两半，分别排序后再合并。
```c
void merge(int arr[], int l, int m, int r) {
// ... 实现合并过程
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);
```
这些是排序算法的基本实现。实际应用中，根据数据的特点和排序需求，可能会选择不同的算法，或者对这些基本算法进行优化。例如，对于大数据量，快速排序通常更高效，但小数据量或几乎有序的数据，插入排序或希尔排序可能表现更好。
语音朗读：