今天简单的总结一下算法中经常用到的排序以及查找(用C语言实现，不全，持续更新)
一、首先是最常见也是最常被问的冒泡排序（原理就是每趟排序相邻两两比较…因为比较好理解，就省略了）
//冒泡排序
-(void)maoPaoPaiXu
{
int i,j,temp;
int a[10]={3,5,1,2,6,5,2,1,3,4};
//输入
/*for(i=0;i<10;i++)
{
scanf ("%d,",&a[i]);
}*/
for(j=0;j<9;j++)
{
for (i=0;i<9-j;i++)
{
if (a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
}
}
printf("冒泡排序的结果:");
for(i=0;i<10;i++)
{
printf("%d ",a[i] );
}
printf("\n");
}
二、选择排序
//选择排序
-(void)selectPaiXu
{
/*
选择排序是排序算法的一种，这里以从小到大排序为例进行讲解。
基本思想及举例说明
选择排序（从小到大）的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。
在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换。
下面，以对 3 2 4 1 进行选择排序说明排序过程，使用min_index 记录当前最小的数所在的位置。
第1轮 排序过程 （寻找第1小的数所在的位置）
3 2 4 1（最初， min_index=1）
3 2 4 1（3 > 2， 所以min_index=2）
3 2 4 1（2 < 4， 所以 min_index=2）
3 2 4 1（2 > 1， 所以 min_index=4， 这时候确定了第1小的数在位置4）
1 2 4 3 （第1轮结果，将3和1交换，也就是位置1和位置4交换）
第2轮 排序过程 （寻找第2小的数所在的位置）
1 2 4 3（第1轮结果， min_index=2，只需要从位置2开始寻找）
1 2 4 3（4 > 2， 所以min_index=2）
1 2 4 3（3 > 2， 所以 min_index=2）
1 2 4 3（第2轮结果，因为min_index位置刚好在第2个位置，无需交换）
第3轮 排序过程 （寻找第3小的数所在的位置）
1 2 4 3（第2轮结果， min_index=3，只需要从位置2开始寻找）
1 2 4 3（4 > 3， 所以min_index=4）
1 2 3 4（第3轮结果，将3和4交换，也就是位置4和位置3交换）
至此，排序完毕。
总结及实现
选择排序对大小为N的无序数组R[N]进行排序，进行N-1轮选择过程。第i轮选取第i小的数，并将其放在第i个位置上。当第N-1次完成时，第N小（也就是最大）的数自然在最后的位置上。
*/
int num[10]={3,5,1,2,6,5,2,1,3,4};
int j;
int index;
int temp;
for (int i=0; i<9; i++)//对n个记录进行n-1趟简单选择排序
{
index=i;
for (j=i+1; j<10; j++)//选出最小值
{
if (num[j]<num[index])
{
index=j;
}
}
if (index!=i)//如果记录位置不是i，则二者交换
{
temp=num[i];
num[i]=num[index];
num[index]=temp;
}
}
printf("选择排序的结果:");
for(int i=0;i<10;i++)
{
printf("%d ",num[i]);
}
printf("\n");
}
三、插入排序
//插入排序
-(void)insertPaiXu
{
/*
插入排序是排序算法的一种，它不改变原有的序列（数组），而是创建一个新的序列，在新序列上进行操作。
这里以从小到大排序为例进行讲解。
基本思想及举例说明
插入排序的基本思想是，将元素逐个添加到已经排序好的数组中去，同时要求，插入的元素必须在正确的位置，这样原来排序好的数组是仍然有序的。
在实际使用中，通常是排序整个无序数组，所以把这个无序数组分为两部分排序好的子数组和待插入的元素。第一轮时，将第一个元素作为排序好的子数组，插入第二个元素；第二轮，将前两个元素作为排序好的数组，插入第三个元素。以此类推，第i轮排序时，在前i个元素的子数组中插入第i+1个元素。直到所有元素都加入排序好数组。
下面，以对 3 2 4 1 进行选择排序说明插入过程，使用j记录元素需要插入的位置。排序目标是使数组从小到大排列。
第1轮
[ 3 ] [ 2 4 1 ] （最初状态，将第1个元素分为排序好的子数组，其余为待插入元素）
[ 3 ] [ 2 4 1 ] （由于3>2，所以待插入位置j=1）
[ 2 3 ] [ 4 1 ] （将2插入到位置j）
第2轮
[ 2 3 ] [ 4 1 ] （第1轮排序结果）
[ 2 3 ] [ 4 1 ] （由于2<4，所以先假定j=2）
[ 2 3 ] [ 4 1 ] （由于3<4，所以j=3）
[ 2 3 4 ] [ 1 ] （由于4刚好在位置3，无需插入）
第3轮
[ 2 3 4 ] [ 1 ] （第2轮排序结果）
[ 2 3 4 ] [ 1 ] （由于1<2，所以j=1）
[1 2 3 4 ] （将1插入位置j，待排序元素为空，排序结束）
算法总结及实现
选择排序对大小为N的无序数组R[N]进行排序，进行N-1轮选择过程。首先将第1个元素作为已经排序好的子数组，然后将剩余的N-1个元素，逐个插入到已经排序好子数组；。因此，在第 i轮排序时，前i个元素总是有序的，将第i+1个元素插入到正确的位置。
*/
int a[10]={3,5,1,2,6,5,2,1,3,4};
for(int i=0; i<10; i++)//进行N-1轮插入过程
{
int j=0;//首先找到元素a[i]需要插入的位置
while( (a[j]<a[i]) && (j<i))
{
j++;
}
//将元素插入到正确的位置
if(i != j)//如果i==j，说明a[i]刚好在正确的位置
{
int temp = a[i];
for(int k = i; k > j; k--)
{
a[k] = a[k-1];
}
a[j] = temp;
}
}
printf("插入排序的结果:");
for(int i=0; i<10; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}或者
-(void)chaRupai
{
int a[10]={3,5,1,2,6,5,2,1,3,4};
int temp;
for (int i=0; i<10; i++)
{
int index=i;
for (int j=0; j<i; j++)
{
if (a[i]<=a[j])
{
index=j;
break;
}
}
if (index!=i)
{
temp=a[index];
a[index]=a[i];
for (int s=i; s>index; s--)
{
a[s]=a[s-1];
}
a[index]=temp;
}
}
for (int s=0; s<10; s++)
{
printf("%d",a[s]);
}
}四、快速排序
//快速排序
-(void)fastPaiXu
{
/*快速排序是对冒泡法排序的一种改进。
快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。
可能仅根据基本思想对快速排序的认识并不深，接下来以对n个无序数列A[0], A[1]…, A[n-1]采用快速排序方法进行升序排列为例进行讲解。
(1)定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。
(2)定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A[0]，以后毎次取值由要划 分序列的起始元素决定。
(3)从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。
(4)如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。
(5)重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A[low……pos-1]和A[pos+1……high]，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。
(6)将划分得到的左右两部分A[low……pos-1]和A[pos+1……high]继续采用以上操作步骤进行划分，直到得到有序序列为止。
*/
}
void sort(int *a, int left, int right)
{
if(left >= right)
{
/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
return ;
}
int i = left;
int j = right;
int key = a[left];
while(i < j)
{//控制在当组内寻找一遍
while(i < j && key <= a[j])
{
/*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/
j--;/*向前寻找*/
}
a[i] = a[j];
/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是a[left]，那么就是给key）*/
while(i < j && key >= a[i])
/*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
{
i++;
}
a[j] = a[i];
}
/*当在当组内找完一遍以后就把中间数key回归*/
a[i] = key;
/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
sort(a, left, i - 1);
/*用同样的方式对分出来的右边的小组进行同上的做法*/
sort(a, i + 1, right);
/*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}五、折半法查找
//折半查找
-(void)binaryChaZhao
{
/*
二分査找也称折半査找，其优点是查找速度快，缺点是要求所要査找的数据必须是有序序列。该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较，如果相等，则表示査找成功，否则将以该位置为基准将所要査找的序列分为左右两部分。接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系，来选择所要査找元素可能存在的那部分序列，对其采用同样的方法进行査找，直至能够确定所要查找的元素是否存在，具体的使用方法可通过下面的代码具体了解。
*/
int ret;
int a[10]={-32, 12, 16, 24, 36, 45, 59, 98};
int key=36;
int low = 0;
int high = 7;
ret=-1;
while(low<=high)
{
int mid = (low + high)/2;
int midVal = a[mid];
if(midVal<key)
{
low = mid + 1;
}
else if(midVal>key)
{
high = mid - 1;
}
else
{
ret= mid;
break;
}
}
if(ret == -1)
{
printf("查找失败 \n");
}
else
{
printf ("查找成功 \n");
}
}
六、各排序方法的时间复杂度
排序法 | 最差时间分析 | 平均时间复杂度 | 稳定度 | 空间复杂度 |
| 冒泡排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 快速排序 | O(n2) | O(n*log2n) | 不稳定 | O(log2n)~O(n) |
| 选择排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 二叉树排序 | O(n2) | O(n*log2n) | 不稳定 | O(n) |
插入排序 | O(n2) | O(n2) | 稳定 | O(1) |
| 堆排序 | O(n*log2n) | O(n*log2n) | 不稳定 | O(1) |
| 希尔排序 | O | O | 不稳定 | O(1) |
1、时间复杂度
（1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
（2）时间复杂度 在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。 按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),…， k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。 2、空间复杂度 与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作: S(n)=O(f(n)) 我们一般所讨论的是除正常占用内存开销外的辅助存储单元规模。讨论方法与时间复杂度类似，不再赘述。
（3）渐进时间复杂度评价算法时间性能 主要用算法时间复杂度的数量级(即算法的渐近时间复杂度)评价一个算法的时间性能。
2、类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)S(n)定义为该算法所耗费的存储空间，它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。
空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，我们称这种算法是“就地/”进行的，是节省存储的算法，如这一节介绍过的几个算法都是如此；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如将在第九章介绍的快速排序和归并排序算法就属于这种情况。
如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(10g2n)；当一个算法的空I司复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。
