冒泡排序终极版(模拟qsort)

简介: 冒泡排序终极版(模拟qsort)

普通版冒泡排序

冒泡排序想必大家都很了解了吧,冒泡排序的算法思想就是两两比大小,一轮一轮比,每比完一轮排出一个数字的顺序,那就让我们先来看一个普通的冒泡排序代码>

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    int j = 0;
    for (j = 0; j < sz - i - 1; j++)
    {
      if (arr[j] > arr[j + 1])
      {
        int tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
      }
    }
  }
}
int main()
{
  int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  int i = 0;
  bubble_sort(arr, sz);
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


先看代码效果>

0ac0be6bc2484c518df799cbb0292ffe.png


可以看到数组中的内容变成了由小到大的顺序,那如何让数组成为由大到小的顺序呢?很简单我们只需要把if (arr[j] > arr[j + 1])中的改成,我们来看看效果>

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
  int i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    int j = 0;
    for (j = 0; j < sz - i - 1; j++)
    {
      if (arr[j] < arr[j + 1])
      {
        int tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
      }
    }
  }
}
int main()
{
  int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  int i = 0;
  bubble_sort(arr, sz);
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


6e267436d5464ce592c8af78826aef93.png


这样就达到了我们最终的效果了。

但是我们发现,普通的冒泡排序只能对整型的数据进行排序而其它类型的则无法排序,这就不得不动动我们的发财的小脑袋,其实C语言库函数中有一个qsort函数,这里我们先学习一下qsort函数的使用方法:我们可以打开我们的MSDN这款软件。


qosrt函数

打开MSDN搜索qsort我们可以看到函数的定义:


ad226db4524d47bdb4eb2defaf22b201.png

733aef1c475146139e63ea608988f389.png


有道翻译>

b185ae9d4551416bbe675856ef6c7ccb.png


我们可以看到qsort函数参数分别是数组地址、数组元素个数、数组元素大小(字节)、一个比较函数,返回值为void.,其内部实现了一个快速排序算法,对一个num元素进行排序,每个元素都是width字节,参数base是一个指针,指向要排序数组的首元素地址,qsort用已经排序的元素覆盖这个数组,compare是一个函数指针,再使用的同时我们要自己书写比较函数int_cmp。


我们来代码演示一下>


int int_cmp(const void* p1, const void* p2)
{
  return (*(int*)p1 - *(int*)p2);
}
int main()
{
  int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
  int i = 0;
  qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
  for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
  return 0;
}


看效果>

47479d35eb9c45d5a69e1a22dff1f0a7.png


如果需要由大到小排序的话只需将int_cmp函数中的p1p2互换就可以啦。


终极版冒泡排序

学完了qsort函数,我们可以模仿qosrt函数来改装我们的冒泡排序>


我们可以将我们的冒泡排序函数也改为四个参数:


void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void*, const void*))


比较函数部分>

int cmp_int(const void* e1, const void* e2)
{
  return *(int*)e1 - *(int*)e2;
}
int cmp_by_name(const void* e1, const void* e2)
{
  return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_by_age(const void* e1, const void* e2)
{
  return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

分别为int、结构体字符型、结构体整型。

冒泡排序函数>

void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void*, const void*))
{
  size_t i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    size_t j = 0;
    for (j = 0; j < sz - 1 - i; j++)
    {
      if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
      {
        Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
      }
    }
  }
}


 Swap函数>

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


Swap函数的功能是将元素以一个字节的大小进行交换交换width次。

这样我们就可以写出可以排序任意类型元素的冒泡排序了

终极版冒泡排序整体测试代码

struct Stu
{
  char name[20];
  int age;
};
int cmp_int(const void* e1, const void* e2)
{
  return *(int*)e1 - *(int*)e2;
}
int cmp_by_name(const void* e1, const void* e2)
{
  return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_by_age(const void* e1, const void* e2)
{
  return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
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 bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void*, const void*))
{
  size_t i = 0;
  for (i = 0; i < sz - 1; i++)
  {
    size_t j = 0;
    for (j = 0; j < sz - 1 - i; j++)
    {
      if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
      {
        Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
      }
    }
  }
}
void test1()
{
  int arr[10] = { 2,5,9,1,3,6,4,7,8,0 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
}
void test2()
{
  struct Stu a[3] = { {"zhangsan",18},{"lisi",15},{"wangwu",25} };
  int sz = sizeof(a) / sizeof(a[0]);
  bubble_sort(a, sz, sizeof(a[0]), cmp_by_name);
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%s ", a[i].name);
  }
  printf("\n");
}
void test3()
{
  struct Stu a[3] = { {"zhangsan",18},{"lisi",15},{"wangwu",25} };
  int sz = sizeof(a) / sizeof(a[0]);
  bubble_sort(a, sz, sizeof(a[0]), cmp_by_age);
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", a[i].age);
  }
  printf("\n");
}
int main()
{
  test1();
  test2();
  test3();
  return 0;
}

运行结果>

62650603f63543f7894a1652042e71cb.png



相关文章
|
18小时前
用冒泡排序的思想模拟实现Qsort
用冒泡排序的思想模拟实现Qsort
用冒泡排序的思想模拟实现Qsort
|
2天前
|
搜索推荐 C语言
冒泡排序模拟实现qsort()函数
冒泡排序模拟实现qsort()函数
19 0
|
2天前
冒泡排序的快速排序——qsort函数的模拟实现
冒泡排序的快速排序——qsort函数的模拟实现
10 1
|
2天前
|
算法 C语言
用冒泡排序模拟C语言中的内置快排函数qsort!
用冒泡排序模拟C语言中的内置快排函数qsort!
|
2天前
|
C语言
C语言第三十七弹--使用冒泡排序模拟实现sort
C语言第三十七弹--使用冒泡排序模拟实现sort
|
6月前
【冒泡排序】模仿qsort的功能实现一个通用的冒泡排序
【冒泡排序】模仿qsort的功能实现一个通用的冒泡排序
55 0
|
5月前
|
程序员
qsort函数的模拟实现
qsort函数的模拟实现
28 1
|
7月前
qsort函数详细讲解以及利用冒泡排序模拟实现qsort函数
qsort函数详细讲解以及利用冒泡排序模拟实现qsort函数
41 0
|
10月前
|
C语言 数据库管理
还在使用冒泡排序遍历数组?No No No 库函数qsort帮你搞定所有排序还不快学起来!
还在使用冒泡排序遍历数组?No No No 库函数qsort帮你搞定所有排序还不快学起来!
52 1
|
10月前
|
算法 搜索推荐
图解:冒泡排序升级之【鸡尾酒排序】
鸡尾酒排序,是冒泡排序算法的一种升级。冒泡排序的每个元素都可以像气泡一样,根据自身大小,一点点的向着数组的某侧移动。算法每一轮都是从左到右来比较元素,进行**单向**的位置交换的。而鸡尾酒排序是在此基础上元素比较和交换过程变成了**双向**的。固[鸡尾酒]排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序, 是冒泡排序的一种变形。
86 0
图解:冒泡排序升级之【鸡尾酒排序】