关于冒泡排序,快速排序的实现

最新推荐文章于 2024-05-22 00:04:47 发布

白瘦

最新推荐文章于 2024-05-22 00:04:47 发布

阅读量491

点赞数 16

文章标签：算法数据结构 c语言开发语言后端

本文链接：https://blog.csdn.net/2401_82677118/article/details/136691441

版权

1.冒泡排序

冒泡排序是一种简单的排序算法，它可以把一个无序的数组排列成降序或者升序，但是它只能用于一种固定的数据类型，现在我们来看一下它的实现方法，如下所示:

返回类型 void
函数形参 int * p , size_t len
函数实现

#include<stdio.h>
#include<assert.h>

void bubble_sort(int* p, size_t len)
{
    assert(p != NULL);   //判断它是否为空指针
    
	int i = 0;
	for ( i = 0; i < len - 1; i++)   //总共需要进行len - 1轮
	{
		int j = 0;
		for ( j = 0; j < len - 1 - i; j++)  //这是一轮的判断
		{
			if (p[j] > p[j + 1])    //判断升序降序的条件，这是升序，如果想要改成降序，改变判断条件即可。
			{
				int tmp = p[j];
				p[j] = p[j + 1];    //相邻两者之间进行交换
				p[j + 1] = tmp;
			}
		}
	}
}

void print_arr(int* p, size_t len)   //对数组进行遍历打印
{
    assert(p != NULL);
    
	int i = 0;
	for ( i = 0; i < len; i++)  
	{
		printf("%d ", p[i]);
	}
	printf("\n");
}

void test()
{
	int arr[] = {1,4,3,0,7,2,5,8,6,9};
	size_t len = sizeof(arr) / sizeof(arr[0]);  //计算数组的元素个数
	printf("排序之前 ");
	print_arr(arr, len);
	bubble_sort(arr,len);
	printf("排序之后 ");
	print_arr(arr, len);
}

int main()
{
	test();
	return 0;
}

在这里插入图片描述

2.qsort的模拟实现

在上面我们实现了冒泡排序，但是它只能用于固定的一种数据类型，如果想要对其它类型进行排序，则需要改变其形参，所以冒泡排序不太方便，这时候就需要我们的qsort函数，即快速排序，它可以对多种数据类型进行排序且无需改变该函数的形参，如下所示:

返回类型 void
函数形参 void * base ,size_t len ,size_t width , int (*p)(void * p1,void * p2)
模拟实现

#include<stdio.h>
#include<string.h>
#include<assert.h>

typedef struct Stu    //创建结构体类型
{
	char name[30];   //结构体成员变量
	long long  id;
	int  sex;
}stu;  //结构体类型重命名

int compare_stu_name(const void * p1,const void * p2)  // 结构体成员name比较函数
{
	assert(p1 && p2);  
	return strcmp(((stu *)p1)->name,((stu *)p2)->name);
}

int compare_stu_id(const void* p1, const void* p2)    //结构体成员id比较函数
{
	assert(p1 && p2);

	return ((stu*)p1)->id - ((stu*)p2)->id;
}

void swap(char* s1, char* s2, size_t width)        //数值交换函数
{
	int i = 0;
	for ( i = 0; i < width; i++)
	{
		int tmp = *s1;
		*s1 = *s2;
		*s2 = tmp;
		s1++;
		s2++;
	}
}

void my_qsort(void *base,size_t len,size_t width,int(*p)(const void * p1,const void * p2))
{
	assert(base && p);

	int i = 0;
	for ( i = 0; i < len - 1; i++)   //总共进行len - 1轮
	{
		int j = 0;
		for ( j = 0; j < len - 1 -i; j++)    
		{
			if (p((char*)base + j*width, (char*)base + (j + 1)*width) > 0) //调用函数指针p，给它传入两个地址，由于base是void * 类型，不能进行指针地址的计算，要强转成char * 类型，然后通过计算得到首元素的地址和第二个元素的地址，作为实参传给函数指针p.
			{
				swap((char *)base+j*width,(char *)base+(j+1)*width,width); //交换函数，通过地址把数值进行交换
			}
		}
	}
}

void print_stu_name(stu* s, size_t len)  //遍历打印结构体成员变量name
{
	int i = 0;
	for ( i = 0; i < len; i++)
	{
		printf("%s ", s++->name);
	}
	printf("\n");
}

void print_stu_id(stu* s, size_t len) //遍历打印结构体成员变量id
{
	int i = 0;
	for ( i = 0; i < len; i++)
	{
		printf("%lld ", s->id);
		s++;
	}
	printf("\n");
}

void test02()
{
	stu student[] = { {"zhangsan",202101540132,0},{"lisi",202101540137,1},{"wangwu",202101540123,0}};
	int arr[] = {0,3,1,7,6,9,2,5,8,4};
	size_t len = sizeof(student)/sizeof(student[0]);
	size_t len2 = sizeof(arr) / sizeof(arr[0]);
	printf("打印之前: ");
	print_arr(arr, len2);
	//print_stu_id(student, len);  
	//print_stu_name(student, len);
	//my_qsort(student,len,sizeof(student[0]),compare_stu_name); 
	//my_qsort(student,len,sizeof(student[0]),compare_stu_id); 
	my_qsort(arr, len2, sizeof(arr[0]), compare_arr);

	printf("打印之后: ");
	//print_stu_name(student,len);
	//print_stu_id(student, len);
	print_arr(arr, len2);
}

int main()
{
	test02();
	return 0;
}