十归并排序有用的算法和二进制搜索的基础

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是採用分治法（Divide and Conquer）的一个很典型的应用。

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和。该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比較两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 反复步骤3直到某一指针达到序列尾

5. 将还有一序列剩下的全部元素直接拷贝到合并序列尾



用分治策略解决这个问题分为三步：分解、解决、合并。

也即：将原问题划分成n个规模较小而结构与原问题相似的子问题；
递归地解决这些子问题。然后再合并其结果，得到原问题的解。此处n=2。每次都把原问题划分为两个子问题。

归并排序的伪代码(来自算法导论)

合并排序伪代码(使用哨兵)：
merge(A,p,q,r)://合并算法，[p,q],[q+1,r]
n1 <—— q-p+1
n2 <—— r-q
create array L[0,n1] and R[0,n2]
for i <—— 0 to n1-1
do L[i] <—— A[p+i]
for j <—— 0 to n2-1
do R[j] <—— A[q+j+1]
L[n1] <—— +∞
R[n2] <—— +∞
i <—— 0
j <—— 0
for k i <—— p to r
do if L[i]<=R[j]
then A[k]  <—— L[i]
i <—— i+1
else A[k] <—— R[j]
j <—— j+1

//通过调用merge完毕排序：
merge_sort(A,p,r)：
if p<r
then q <—— [(p+r)/2] //向下取整
merge_sort(A,p,q) //分治
merge_sort(A,q+1,r)
merge(A,p,q,r)    //合并结果

归并排序实现

#include <stdio.h>
#include <stdlib.h>
#define MAX_INT  ~(1<<31)//最大整数
//arr[p,q]  arr[q+1,r]
void merge(int *arr,int p,int q,int r)
{
if(arr==NULL)
return;
int n1=q-p+1;
int n2=r-q;
int *L=(int*)malloc((n1+1)*sizeof(int));//申请新空间用于暂时存储元素
int *R=(int*)malloc((n2+1)*sizeof(int));
int i,j;//这里直接申请一个r-p+1长度的数组，在暂时数组中排序后拷贝回原数组
for(i=0;i<n1;++i)
L[i]=arr[p+i];
for(j=0;j<n2;++j)
R[j]=arr[q+j+1];
//哨兵元素赋值
L[n1]=MAX_INT;
R[n2]=MAX_INT;
int k;
i=0,j=0;
for(k=p;k<=r;++k){
if(L[i]<=R[j])
arr[k]=L[i++];
else
arr[k]=R[j++];
}//最后可能有一个数组有元素剩余，这里使用一个哨兵(MAX_INT)能够在一次循环中完毕所有复制
free(L);
free(R);
}
void merge_sort(int *arr,int p,int r)
{
if(p<r){
int q=(r+p)/2;
merge_sort(arr,p,q);//分治
merge_sort(arr,q+1,r);
merge(arr,p,q,r);//合并结果
}

}
int main()
{
int arr[8]={32,3,4,5,6,7,9,106};
merge_sort(arr,0,7);
for (int i=0;i<8;i++)
printf("%d ",arr[i]);
system("pause");
}

二分查找算法

二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素開始，假设中间元素正好是要查找的元素。则搜素过程结束；假设某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，并且跟開始一样从中间元素開始比較。假设在某一步骤数组为空，则代表找不到。

这样的搜索算法每一次比較都使搜索范围缩小一半。

折半搜索每次把搜索区域降低一半，时间复杂度为Ο(logn)
。

二分查找能够解决（预排序数组的查找）问题：仅仅要数组中包括T（即要查找的值），那么通过不断缩小包括T的范围，终于就能够找到它。其算法流程例如以下：

1、一開始，范围覆盖整个数组。

2、将数组的中间项与T进行比較，假设T比数组的中间项要小，则到数组的前半部分继续查找，反之，则到数组的后半部分继续查找。

3、如此，每次查找能够排除一半元素。范围缩小一半。就这样重复比較，重复缩小范围，终于就会在数组中找到T，或者确定原以为T所在的范围实际为空。

对于包括N个元素的表，整个查找过程大约要经过log(2)N次比較。

//首先要把握以下几个要点：
//right = n-1 => while(left <= right) => right = middle-1;
//right = n   => while(left <  right) => right = middle;
//middle的计算不能写在while循环外，否则无法得到更新。

int BinarySearch(int array[], int n, int value)
{
int left = 0;
int right = n - 1;
//假设这里是int right = n 的话，那么以下有两处地方须要改动，以保证一一相应：
//1、以下循环的条件则是while(left < right)
//2、循环内当 array[middle] > value 的时候，right = mid

while (left <= right)  //循环条件，适时而变
{
int middle = left + ((right - left) >> 1);  /*防止溢出。移位也更高效。

同一时候。每次循环都须要更新。mid = left + (right-left)/2这样写能够有效避免right + left 溢出。假设写成mid = (left + right)/2可能存在溢出*/

if (array[middle] > value)
{
right = middle - 1;  //right赋值，适时而变
}
else if(array[middle] < value)
{
left = middle + 1;
}
else
return middle;
//可能会有读者觉得刚開始时就要推断相等。但毕竟数组中不相等的情况很多其它
//假设每次循环都推断一下是否相等，将耗费时间
}
return -1;
}

以上就是本次介绍的归并排序和二分查找。