C语言中qsort函数用法及用冒泡排序实现

#include <stdio.h>
#include <stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
    return *((int*)e1) - *((int*)e2);//默认是升序，将return中e1和e2的位置交换可以使其降序
    //无法对void*类型的指针进行具体操作，因此要将其强制类型转换为int*,使其能够在解引用时访问到4个字节
}
int main()
{
    int i = 0;
    int arr[] = { 7,8,9,4,5,6,1,2,3,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);//计算整型数组中有多少个元素
    qsort(arr, sz, sizeof(int), cmp_int);//sizeof(int)是用来计算int类型的数据所占字节数
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);//输出为1 2 3 4 5 6 7 8 9 10
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int cmp_char(const void* e1, const void* e2)//字符串排序
{
    return strcmp((char*)e1, (char*)e2);//比较字符大小用strcmp
}
int main()
{
    char arr[] = "badecf";
    int i = 0;
    //int sz = sizeof(arr) / sizeof(arr[0]);//sizeof求字符串长度会将\0算进去,也就是实际计算出来的会比数组中的多1。
    int sz = strlen(arr);//strlen是用来计算字符串长度的，且只能用来计算字符串的长度。
    qsort(arr,sz , sizeof(char), cmp_char);
    printf("%s\n", arr);//abcdef
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int cmp_char_strlen(const void* e1, const void* e2)//比较字符串长度
{
    return strlen(*(char**)e1) - strlen(*(char**)e2);//先将e1和e2强制类型转换成为char**类型，再解引用取出数组中字符串的地址，计算字符串长度
}
int main()
{
    //char* arr[] = {"abcdef" "abc","defs" };
    //也可以通过下面的方式来写指针数组，下面的4行和上面的这一行作用一样
    char* arr1 = "abc";
    char* arr2 = "abcd";
    char* arr3 = "abcdef";
    char* arr[] = { arr1,arr2,arr3 };
    int i = 0;
    qsort(arr, 3, sizeof(char*), cmp_char_strlen);
    for (i = 0; i < 3; i++)
    {
        printf("%s\n", arr[i]);//输出结果为 abc  defs  abcdef
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int cmp_float(const void* e1, const void* e2)//浮点型数组排序
{
    //return (int)(*(float*)e1 - *(float*)e2);//可能会出错，如12.002和12.001比较之后再强制类型转换为int类型后，结果为0
    if (*(float*)e1 - *(float*)e2 > 0.000000)
    {
        return 1;//当e1>e2时，返回大于0的数
    }
    if (*(float*)e1 - *(float*)e2 < 0.000000)
    {
        return -1;//当e1<e2时，返回小于0的数
    }
    else
        return 0;//当e1和e2相等时，返回等于0的数
}
int main()
{
    float arr[3] = { 12.01f,12.03f,12.09f };
    int sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    qsort(arr, sz, sizeof(float), cmp_float);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%f  ", arr[i]);//输出结果为12.010000  12.030000  12.090000
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
struct stu
{
    char name[20];
    int age;
};
int cmp_s_age(const void* e1, const void* e2)//比较结构体中int类型
{
    return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_s_name(const void* e1, const void* e2)//比较结构体中char类型的数组
{
    return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
int main()
{
    struct stu s[] = { {"zhangsan",21} ,{"lisi",20},{"wangwu",52}};
    int i = 0;
    int sz = sizeof(s) / sizeof(s[0]);
    for (i = 0; i < sz; i++)
    {
        printf("%s %d\n", s[i].name, s[i].age);
    }
    qsort(s, sz, sizeof(struct stu), cmp_s_age);//比较年龄，即比较int类型
    //qsort(s, sz, sizeof(struct stu), cmp_s_name);//比较姓名，即比较char类型的数组
    printf("\n");
    for (i = 0; i < sz; i++)
    {
        printf("%s %d\n", s[i].name, s[i].age);//输出为年龄按照升序排列，如果比较姓名，则按照姓名的首字符的ASCII值按照升序排列
    }
    return 0;
}

//用冒泡排序对整型数组进行排序
#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    int arr[] = { 7,8,9,4,5,6,1,2,3,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz-1; i++)//总共循环sz-1次
    {
        int flag = 1;//标记，假设数组是有序的
        for (j = 0; j < sz - 1 - i; j++)//第一个元素需要和剩余的sz-1个元素比较，第二个元素需要和sz-1-1个元素比较……所以每次循环需要比较的次数为sz-1-i
        {
            if (arr[j] < arr[j + 1])//从大到小排列
            {
                int tmp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = tmp;
                flag = 0;//倘若发生交换说明数组是无序的
            }
        }
        if(flag == 1)
        {
            break;//如果没发生一次交换说明数组已经是符合要求的有序数组
        }
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);//输出结果为 10 9 8 7 6 5 4 3 2 1
    }
    return 0;
}

#include <stdio.h>
struct stu
{
	char name[20];
	int age;
};
int cmp_s_age(const void* e1, const void* e2)//比较结构体中整型
{
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_s_name(const void* e1, const void* e2)//比较结构体中整型
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)//一个字节一个字节的交换
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void qsort_bubble(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 - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
				//强制转换成char*类型的指针，进行交换时一个字节一个字节的交换，+width，向后走对应的字节
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width,width);//满足条件进行交换
			}
		}
	}
}
int main()
{
	struct stu s[] = { {"zhangsan",21} ,{"lisi",20},{"wangwu",52}};
	int i = 0;
	int sz = sizeof(s) / sizeof(s[0]);
	//printf("%d", sz);
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	qsort_bubble(s, sz, sizeof(struct stu), cmp_s_age);//比较年龄，即比较int类型
	//qsort_bubble(s, sz, sizeof(struct stu), cmp_s_name);//比较姓名，即比较char类型的数组
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", s[i].name, s[i].age);
	}
	return 0;
}