总言
各种排序、查找的技巧收集汇总。
会慢慢学习和补充。
线性查找（顺序查找）
简单含义： 在一组数据中，按顺序查找到某一特定的值。例如：给定一组数组，在数组中查找元素k。
思路分析：
1、按顺序遍历数组元素，直到找到目标元素后，结束查找。
2、若遍历数组所有元素后无目标元素，则结束查找。
代码如下：
#define N 5
#define NOFIND -1
int seq(int const* arr, int n, int aim)
{
int i=0;
while (1)
{
if (*(arr + i) == aim)
return i;//若数组中存在该元素
if (i == n)
return NOFIND;//若遍历数组后无该元素
i++;
}
}
int main(void)
{
//准备工作
int arr[N] = { 0 };
int i;
for (i = 0; i < N; i++)
scanf("%d", &arr[i]);
//目标元素
int aim;
scanf("%d", &aim);
//顺序查找
int feback = seq(arr, N, aim);
//判断是否存在目标元素
if (feback == -1)
printf("查找失败\n");
else printf("%d是数组中第%d个元素\n", aim, feback + 1);
return 0;
}
但上述代码有缺陷，若数组前后出现相同元素，则只记录第一次查找的结果。
关于seq函数中使用for循环的情况：
int seq(int const* arr, int n, int aim)
{
int i = 0;
for (i = 0; i < n; i++)
if (*(arr + i) == aim)
return i;//若数组中存在该元素
return NOFIND;//遍历数组后无该元素
}
哨兵查找
在数组尾部插入所需要查找的目标元素（即哨兵），循环将在数组遇到目标元素时停止（无非哨兵与数组内部元素），此时可通过判断停止位置来确认数组中是否有该元素。
代码如下：
#define N 5
#define NOFIND -1
int seq(int arr[], int n, int aim)
{
int i=0;
while (1)
{
if (arr[i] == aim)
break;//break跳出循环，非跳出if语句
i++;
}
//要注意此处用于判断的n值，目的是为了区分是否为哨兵
return (i < n) ? i : NOFIND;
}
int main(void)
{
//准备工作
int arr[N+1] = { 0 };
int i;
for (i = 0; i < N; i++)
scanf("%d", &arr[i]);
//目标元素
int aim;
scanf("%d", &aim);
//哨兵查找
arr[N] = aim;//插入哨兵，也可在seq函数中写此代码
int feback;
if ((feback = seq(arr, N , aim)) == NOFIND)
printf("查找失败\n");
else printf("%d是数组中第%d个元素\n", aim, feback + 1);
return 0;
}
需要注意的代码点：
关于实际参数输入值为什么是N而非N+1的探索：
if ((feback = seq(arr, N , aim)) == NOFIND)
......
int seq(int arr[], int n, int aim)
{
......
return (i < n) ? i : NOFIND;
}
数组总元素N+1（对应数组下标为0 ~ N），实际输入数组元素为N（对应数组元素下标为0 ~ N-1）。
哨兵所在位置为数组末端，即arr[N]，第N+1个元素。seq函数中return使用三元运算符的目的是，根据i的位置，区分最终找到的目标元素是实际输入的元素，还是我们插入的哨兵。故需要以哨兵所在的位置为分界线。
局部变量i作用于数组下标访问操作符中，arr[i]的含义是从数组首元素arr开始，往后找i个元素，即访问第arr+i个元素。三元运算符是以变量i进行判断的，此处关键看循环结束后，i的值在哪？
如果最终查找结果为实际输入元素，则很容易判断，倘若为边界元素（最终查找结果为哨兵时），则是一个困惑点。需要明确的是，若是后者，此时变量i已经累加到了N，故判断时应该以N（哨兵在数组元素的下标值）进行判断，而非以N+1（哨兵在数组中的位数值）进行判断（此处i的判断值随循环条件的改变而改变）。
二分查找
数组遍历的一种方式
冒泡排序
常规方法
void bubble(int* arr,int sz)
{
int j;
for (j = 0; j < sz-1; j++)
{//此处sz-1因为总趟数比元素个数始终少一次。
int i ;
for (i = 0; i < sz-1-j; i++)
{//此处sz-1是因为根据元素下标进行比较。
//之后每一趟中，对于先前已经排列好的元素，可以不再进行比较
//因此sz-1-j
//每次从零开始是因为排序后后续元素往前挪。
if (arr[i] > arr[i + 1])
{
int tmp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = tmp;
}
}
}
}
int main(void)
{
int i = 0;
int arr[10] = {0};
printf("输入10个元素：");
for (i = 0; i < 10; i++)
{
scanf("%d", &arr[i]);
}
int sz = sizeof(arr) / sizeof(arr[0]);
bubble(arr, sz);
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
基于qsort实现的冒泡排序
预备知识：qsort函数的使用
基本知识：
qsort对整型数组、结构体数组的使用举例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//--------------------
//qsort作用于整型数组
int cmp_test11(void* e1, void* e2)
{
return (*(int *)e1 - *(int *)e2);
}
int cmp_test12(void* e1, void* e2)
{
return -(*(int*)e1 - *(int*)e2);
}
void printt(int* p, int sz)
{
int i;
for (i = 0; i < sz; i++)
printf("%d", p[i]);
putchar('\n');
}
void test1()
{
int arr[10] = { 2,4,1,7,3,8,9.6,5,0 };
int sz = sizeof(arr) / sizeof(arr[1]);
qsort(arr, sz, sizeof(arr[1]), cmp_test11);
printt(arr, sz);
qsort(arr, sz, sizeof(arr[1]), cmp_test12);
printt(arr, sz);
}
//--------------------
//--------------------
typedef struct stu
{
char name[20];
int age;
double score;
}stu;
int cmp_test21(void* e1, void* e2)
{
return strcmp(((stu*)e1)->name, ((stu*)e2)->name);
}
int cmp_test22(void* e1, void* e2)
{
return ((stu*)e1)->age - ((stu*)e2)->age;
}
void test2()
{
stu arr2[3] = { {"张三",19,88.8},{"李四",20,95.6},{"王五",21,90.7} };
int sz = sizeof(arr2) / sizeof(arr2[0]);
int i = 0;
qsort(arr2, sz, sizeof(arr2[0]), cmp_test21);
for (i = 0; i < sz; i++)
{
printf("%-12s %-3d %-5.2lf\n", arr2[i].name, arr2[i].age, arr2[i].score);
}
qsort(arr2, sz, sizeof(arr2[0]), cmp_test22);
for (i = 0; i < sz; i++)
{
printf("%-12s %-3d %-5.2lf\n", arr2[i].name, arr2[i].age, arr2[i].score);
}
}
//--------------------
//--------------------
int main(void)
{
test1();
putchar('\n');
test2();
return 0;
}
//--------------------
输出结果：
仿照qsort实现任意类型数据比较的冒泡排序
//--------------------
//冒泡排序
void swop(char* num1, char* num2, int len)
{
int i;
for (i = 0; i < len; i++)
{
char tmp = *num1;
*num1 = *num2;
*num2 = tmp;
num1++;
num2++;
}
}
void bobblesort(void* base, int sz, int len, int (*cmpsort)(const void* e1, const void* e2))
{//此处bobblesort的形参是参考qsort得来的：需要排序的数组，需要排序的元素数量，每个元素大小，函数指针
int i;
for (i = 0; i < sz - 1; i++)//决定冒泡排序的趟数
{
int j;
for (j = 0; j < sz - 1 -i; j++)//决定一趟冒泡排序需要比较多少个元素
{
//比较数组元素，为实现任意类型数组的排序，需要自己实现比较函数，根据比较函数的返回值，>0、<0、=0来判断
//if (arr[i] > arr[i + 1])----普通版本中if语句条件判断的写法
//此处要比较两元素大小，直接base+len不可行（类型不同，base为void*），故可强制转换类型为char *
//base一开始指向数组首元素地址，(char *)base+len（指所排序类型的宽度）得到的是下一个元素的地址
//(char *)base+len*j，能找到第j个元素的地址。
if (cmpsort((char*)base + j * len, (char*)base + (j + 1) * len) > 0)
{
swop((char*)base + j * len, (char*)base + (j + 1) * len, len);
//交换满足条件的元素，以达到排序的目的。（故此处输入的元素写法和if语句条件判断同）
}
}
}
}
//--------------------
//--------------------
//对整型数组
int cmp_test3(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void test3(void)
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[1]);
bobblesort(arr, sz, sizeof(arr[1]), cmp_test3);
int i;
for (i = 0; i < sz; i++)
printf("%d ", arr[i]);
}
//--------------------
//--------------------
//对结构体数组
#include<string.h>
struct stu
{
char name[20];
int age;
double score;
};
int cmp_test4(const void* e1, const void* e2)
{
return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
void test4(void)
{
struct stu arr[3] = { {"张三",19,88.2},{"李四",23,90.3},{"王五",21,92.4} };
int sz = sizeof(arr) / sizeof(arr[1]);
//以姓名排序
bobblesort(arr, sz, sizeof(arr[1]), cmp_test4);
int i;
for (i = 0; i < sz; i++)
printf("%s ", arr[i].name);
putchar('\n');
}
//--------------------
//--------------------
#include<stdio.h>
int main(void)
{
test3();
putchar('\n');
test4();
return 0;
}
//--------------------
2378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
