冒泡排序案列实践+调用函数详解+快速排序

C语言的冒泡排序是一种简单的排序算法，它通过不断比较相邻的两个数，将较大的数往后移，较小的数往前移动，从而将整个数列排序。具体实现过程如下：

1. 从数列的第一个元素开始，依次比较相邻的两个元素，如果第一个元素比第二个元素大，就交换它们的位置。

2. 重复步骤1，直到数列已经排好序（即没有相邻的两个元素需要交换位置为止）。

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换相邻两个数
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() 
{
    int arr[] = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

那用qsort实现冒泡怎么弄呐？

必须得展示一下

#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:6031)
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
int main()
{
	int arr[10] = { 11,2,3,4,45,6,7,8,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
 }

不过不得不说qsort详解太复杂了，最近刚研究大程序里，怎么调用qsort。

int cmp(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), cmp);

 另一种方法，快速排序，用的不熟练，理解不了，就背下来吧，总会记住的

  

#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;  // i 表示小于基准的元素的最右位置

    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 pivotIndex = partition(arr, low, high);  // 获取基准元素的索引
        quickSort(arr, low, pivotIndex - 1);  // 对基准元素左边的子数组进行排序
        quickSort(arr, pivotIndex + 1, high);  // 对基准元素右边的子数组进行排序
    }
}

// 测试快速排序
int main() {
    int arr[] = {8, 3, 1, 7, 9, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("原始数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    quickSort(arr, 0, n - 1);

    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}