常见的排序算法有哪些

常见的排序算法包括：

1. 冒泡排序（Bubble Sort）
2. 选择排序（Selection Sort）
3. 插入排序（Insertion Sort）
4. 希尔排序（Shell Sort）
5. 归并排序（Merge Sort）
6. 快速排序（Quick Sort）
7. 堆排序（Heap Sort）
8. 计数排序（Counting Sort）
9. 桶排序（Bucket Sort）
10. 基数排序（Radix Sort）

这些算法在不同的场景下有不同的性能表现，选择合适的排序算法可以提高程序的效率。

相关问题

常见排序算法有哪些并给出C语言代码

常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

以下是这些排序算法的C语言代码实现：

1. 冒泡排序

void bubble_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

2. 选择排序

void selection_sort(int arr[], int len) {
    int i, j, minIndex, temp;
    for (i = 0; i < len - 1; i++) {
        minIndex = i;
        for (j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3. 插入排序

void insertion_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 1; i < len; i++) {
        temp = arr[i];
        for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = temp;
    }
}

4. 快速排序

void quick_sort(int arr[], int left, int right) {
    int i, j, pivot, temp;
    if (left < right) {
        i = left;
        j = right;
        pivot = arr[left];
        while (i < j) {
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            while (i < j && arr[i] < pivot) {
                i++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        arr[i] = pivot;
        quick_sort(arr, left, i - 1);
        quick_sort(arr, i + 1, right);
    }
}

5. 归并排序

void merge(int arr[], int left, int mid, int right, int temp[]) {
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    for (i = 0; i < k; i++) {
        arr[left + i] = temp[i];
    }
}

void merge_sort(int arr[], int left, int right, int temp[]) {
    if (left < right) {
        int mid = (left + right) / 2;
        merge_sort(arr, left, mid, temp);
        merge_sort(arr, mid + 1, right, temp);
        merge(arr, left, mid, right, temp);
    }
}

void sort(int arr[], int len) {
    int *temp = (int *)malloc(sizeof(int) * len);
    merge_sort(arr, 0, len - 1, temp);
    free(temp);
}

有哪些常见的排序算法？

常见的排序算法有以下几种：
1. 冒泡排序：通过相邻元素的比较和交换来进行排序，每一轮将最大的元素冒泡到最后。
2. 插入排序：将待排序的元素逐个插入到已排序序列中的合适位置，直到全部元素都插入完毕。
3. 选择排序：每次从待排序序列中选择最小（或最大）的元素放到已排序序列的末尾。
4. 快速排序：通过一趟排序将待排序序列分割成独立的两部分，其中一部分的所有元素都比另一部分小，然后对这两部分继续进行快速排序。
5. 归并排序：将待排序序列不断地分割成两个子序列，直到每个子序列只有一个元素，然后将这些子序列合并成一个有序序列。
6. 堆排序：利用堆这种数据结构进行排序，通过构建最大堆或最小堆来实现排序。
7. 希尔排序：将待排序序列按照一定的增量分组，对每组进行插入排序，然后逐渐缩小增量直至为1，最后进行一次插入排序。
8. 计数排序：统计待排序序列中每个元素出现的次数，然后根据统计结果将元素放回原序列中的正确位置。
9. 桶排序：将待排序序列划分为若干个桶，每个桶内部进行排序，然后按照桶的顺序依次输出所有元素。
10. 基数排序：将待排序序列按照低位到高位的顺序依次进行排序，每一位使用稳定的排序算法。