C语言冒泡排序，选择排序，插入排序，快速排序，归并排序，输出比较的次数和交换的次数

冒泡排序：比较次数为n(n-1)/2，交换次数为n(n-1)/2；选择排序：比较次数为n(n-1)/2，交换次数为n-1；插入排序：比较次数为n(n-1)/2，交换次数为n(n-1)/2；快速排序：比较次数不确定，最坏情况为n2，最好情况为nlogn，交换次数不确定，最坏情况为n2，最好情况为nlogn；归并排序：比较次数为nlogn，交换次数也为nlogn。

相关问题

用C语言写出一组随机数的 冒泡排序，选择排序，插入排序，快速排序，归并排序，输出比较的次数和交换的次数

冒泡排序：
int n, a[maxsize], i, j, temp;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
// 输出比较次数和交换次数：
printf("比较次数：%d \n", n * (n - 1) / 2);
printf("交换次数：%d \n", n - 1);选择排序：
int n, a[maxsize], i, j, min, temp;
for (i = 0; i < n - 1; i++) {
min = i;
for (j = i + 1; j < n; j++)
if (a[j] < a[min])
min = j;
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
// 输出比较次数和交换次数：
printf("比较次数：%d \n", n * (n - 1) / 2);
printf("交换次数：%d \n", n - 1);插入排序：
int n, a[maxsize], i, j, temp;
for (i = 1; i < n; i++) {
temp = a[i];
for (j = i - 1; j >= 0 && a[j] > temp; j--)
a[j + 1] = a[j];
a[j + 1] = temp;
}
// 输出比较次数和交换次数：
printf("比较次数：%d \n", n * (n - 1) / 2);
printf("交换次数：%d \n", n - 1);快速排序：
int n, a[maxsize], i, j, temp;
void quickSort(int *a, int left, int right) {
int i = left, j = right;
int temp;
int pivot = a[(left + right) / 2];

while (i <= j) {
while (a[i] < pivot) i++;
while (a[j] > pivot) j--;
if (i <= j) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
j--;
}
}
if (left < j) quickSort(a, left, j);
if (i < right) quickSort(a, i, right);
}
quickSort(a, 0, n - 1);// 输出比较次数和交换次数：
printf("比较次数：%d \n", n * (n - 1) / 2);
printf("交换次数：%d \n", n - 1);归并排序：
void mergeSort(int *a, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(a, left, mid);
mergeSort(a, mid + 1, right);
merge(a, left, mid, right);
}
}
void merge(int *a, int left, int mid, int right) {
int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = a[left + i];
for (j = 0; j < n2; j++)
R[j] = a[mid + 1+ j];
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
a[k] = L[i];
i++;
}
else
{
a[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
a[k] = L[i];
i++;
k++;
}
while (j < n2)
{
a[k] = R[j];
j++;
k++;
}
}
// 输出比较次数和交换次数：
printf("比较次数：%d \n", n * (n - 1) / 2);
printf("交换次数：%d \n", n - 1);

用C语言设计一个完整的代码实现直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序、堆排序

好的，以下是完整的 C 语言代码实现七种排序算法：

#include <stdio.h>

// 交换两个数
void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

// 直接插入排序
void insertionSort(int arr[], int n) {
    int i, key, j;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j = j-1;
        }
        arr[j+1] = key;
    }
}

// 希尔排序
void shellSort(int arr[], int n) {
    for (int gap = n/2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i += 1) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
                arr[j] = arr[j - gap];
            arr[j] = temp;
        }
    }
}

// 冒泡排序
void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n-1; i++)
        for (j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1])
                swap(&arr[j], &arr[j+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);
    }
}

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);
}

// 选择排序
void selectionSort(int arr[], int n) {
    int i, j, min_idx;
    for (i = 0; i < n-1; i++) {
        min_idx = i;
        for (j = i+1; j < n; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;
        swap(&arr[min_idx], &arr[i]);
    }
}

// 归并排序
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);
    }
}

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 heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
    for (int i=n-1; i>=0; i--) {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;
    if (l < n && arr[l] > arr[largest])
        largest = l;
    if (r < n && arr[r] > arr[largest])
        largest = r;
    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest);
    }
}

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

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr)/sizeof(arr[0]);

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

    // 直接插入排序
    insertionSort(arr, n);
    printf("直接插入排序后的数组：\n");
    printArray(arr, n);

    // 希尔排序
    shellSort(arr, n);
    printf("希尔排序后的数组：\n");
    printArray(arr, n);

    // 冒泡排序
    bubbleSort(arr, n);
    printf("冒泡排序后的数组：\n");
    printArray(arr, n);

    // 快速排序
    quickSort(arr, 0, n-1);
    printf("快速排序后的数组：\n");
    printArray(arr, n);

    // 选择排序
    selectionSort(arr, n);
    printf("选择排序后的数组：\n");
    printArray(arr, n);

    // 归并排序
    mergeSort(arr, 0, n-1);
    printf("归并排序后的数组：\n");
    printArray(arr, n);

    // 堆排序
    heapSort(arr, n);
    printf("堆排序后的数组：\n");
    printArray(arr, n);

    return 0;
}

以上就是完整的 C 语言代码实现七种排序算法，希望对您有所帮助。