void test(const char* str)
{
  printf("%s\n", str);
}
int main()
{
  //函数指针pfun
  void (*pfun)(const char*) = test;
  //函数指针的数组pfunArr
  void (*pfunArr[5])(const char* str);
  pfunArr[0] = test;
  //指向函数指针数组pfunArr的指针ppfunArr
  void (*(*ppfunArr)[5])(const char*) = &pfunArr;
  //(*ppfunArr)  ppfunArr与*先结合，说明这是一个指针，剩下void (*[5])(const char*)  实际上是 void (*)(const char*) [5]函数指针数组
  //所以 void(*(ppfunArr)[5])(const char*) 这是个指向函数指针数组的指针
  return 0;

#include<stdio.h>
int sub(int x, int y) {
  return  x - y;
}
int add(int x, int y) {
  return x + y;
}
int mul(int x, int y) {
  return x * y;
}
int div(int x, int y) {
  return x / y;
}
void coul(int(*pa)(int, int)) {
  int x, y;
  scanf("%d %d", &x, &y);
  int len=pa(x, y);
  printf("%d\n", len);
}
int main()
{ //函数指针 pa
  int(*pa)(int, int) = add;
  //函数指针数组
  int(*ppa[10])(int, int) = { add,sub,mul,div };
  //ppa[10]  ppa 先于[]相结合 说明这个是个数组 剩下元素为 int(*)(int,int)说明存放的是函数指针类型
  //所以这就是可以存放十个以两个形参为int类型，返回类型为int的，函数指针数组，ppa(数组名)
  //对于函数指针数组的应用
  int x, y;
  int input = 1;
  int ret = 0;
  do {
    printf("*************************\n");
    printf(" 1:add       2:sub \n");
    printf(" 3:mul       4:div \n");
    printf("*************************\n");
    printf("请选择：");
    scanf("%d", &input);
    switch (input) {
    case 1:
      coul(add);  //使用回调函数，使得main函数与要实现的add或者sub等函数建立起来桥梁
      break;
    case 2:
      coul(sub);
      break;
    case 3:
      coul(mul);
      break;
    case 4:
      coul(div);
      break;
    case 0:
      printf("退出程序\n");
      break;
    default:
      printf("选择错误\n");
      break;
    }
  } while (input);
  return 0;
}

#include<stdio.h>
#include<search.h>
int compare(const void* e1, const void* e2) {
  //使用 const是防止修改e1，e2的指针指向的地址，void*（无符号指针）表示函数的普适性
  //    可以接收所有类型的指针。
  return *(int*)e2 - *(int*)e1;
  //(int*)是因为是对void*类型进行强制转换，然后*解引用，比较e1 和 e2 的大小
}
int main()
{
  int arr[] = { 1,2,31,45,55,6,7,8,9,10,0 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  qsort(arr, sz, sizeof(arr[0]), compare);
  for (int i = 0; i < sz; i++) {
    printf("%d ", arr[i]);
  }
  return 0;
}

//使用回调函数，模拟实现qsort（采用冒泡的方式）
//比较函数
int compare(const void* e1, const void* e2) {
  return *(int*)e1 - *(int*)e2;
}
//交换函数
void swap(void* e1, void* e2, int width) {
  for (int i = 0; i < width; i++) {
    //一个元素 width个字节，自然是width次转换
    char tmp = (*((char*)e1 + i));
    (*((char*)e1 + i)) = (*((char*)e2 + i));
    (*((char*)e2 + i)) = tmp;
  }
}
//使用冒泡排序的方式模拟实现qsort函数
void buffer_qsort(void* base, size_t num, size_t width, int (*compare)(const void* e1, const void* e2)) {
  for (int i = 0; i < num-1; i++) {
    for (int j = 0; j < num - 1 - i; j++) {
      //冒泡排序基本的循环是不用变的，只需要改变交换的方式
      if (compare((char*)base + j * width, (char*)base + (j + 1) * width) > 0) {
        //传递数据的适合因为不知道传参的是什么类型，所以就是用表示一个字节的char*进行强制类型转换
        //（char*）base  取的是数组的首元素的第一个字节，然后加上j*width，相当于跳过该类型的元素，找到下一个元素
        //进行compare函数比较
        //swap函数进行交换
        swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
      //除了传递每一个元素(char*)base + j * width 也要传递一个数组元素字节为多少 width
        //我们的交换原理就是创建一个临时变量 width次循环交换 
      }
    }
  }
}
int main()
{
  int arr[] = { 11,2,3,4,45,62,7,8,8,9 };
  int sz = sizeof(arr) / sizeof(arr[1]);
  buffer_qsort(arr, sz, sizeof(arr[1]), compare);
  for (int i = 0; i < sz; i++) {
    printf("%d ", arr[i]);
  }
  return 0;
}

void quick_sort(int* arr, int l, int r) {
  if (l >= r) {
    return;
  }
  int k = arr[l];
  int i = l - 1;
  int j = r + 1;
  while (i < j) {
    do {
      i++;
    } while (arr[i] < k);
    do{
      j--;
    } while (arr[j] > k);
    if (i < j) {
      int tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
    }
  }
  quick_sort(arr, l, j);
  quick_sort(arr, j + 1, r);
}
int main()
{
  int arr[] = { 1,25,3,4,5,6,7,8,9,10 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  quick_sort(arr, 0, sz-1);
  for (int i = 0; i < sz; i++) {
    printf("%d ", arr[i]);
  }
  return 0;
}