递归算法——归并排序，快速排序，二分查找

/* 
 * 待排序的数组，算法输入 
 */  
int arrIntegers[10] = {  
    0, 3, 1, 2, 5, 4, 8, 7, 9, 6  
};  
  
/* 
 * 辅助存储空间 
 */  
int tempIntegers[10];  

递归排序：

从数组中间划分数组为2个子数组，递归调用归并排序，然后合并（排序过程发生在合并时候）2个子数组。辅助存储空间为n。

void merge(int left, int mid, int right)  
{  
    int i=left, j=mid+1, k=0;  
      
    // 选择较小的优先归并到临时数组  
    while(i<=mid && j<=right)  
        if (arrIntegers[i]<arrIntegers[j])  
            tempIntegers[k++]=arrIntegers[i++];  
        else  
            tempIntegers[k++]=arrIntegers[j++];  
  
    // 剩下的元素复制到临时数组  
    while(i<=mid) tempIntegers[k++]=arrIntegers[i++];  
    while(j<=right) tempIntegers[k++]=arrIntegers[j++];  
  
    // 复制临时数组  
    for (int x = 0; x < right-left+1; x ++)  
    {  
        arrIntegers[left+x] = tempIntegers[x];  
    }     
}  
void mergesort(int left, int right)  
{  
    if (left >= right)  
        return ;  
  
        // 从中间划分数组  
    int mid = (left+right)/2;  
        // 递归排序左侧序列  
        mergesort(left, mid);  
        // 递归排序右侧序列  
        mergesort(mid+1,right);  
  
    // 归并  
    merge(left,mid,right);  
}  

快速排序：

　　

这里使用的方式和 快速排序分析里面有差别，这个是交换，那一个是填坑

找到适当的位置划分2个子数组（排序过程发生在寻找分隔位置时候），递归调用快速排序。辅助存储空间为1。

int partion(int left, int right)  
{  
    int i = left, j = right+1;  
    int pivot = arrIntegers[left];  
  
    do   
    {  
        // 移动i  
        do i++; while (arrIntegers[i] < pivot);  
        // 移动j  
        do j--; while (arrIntegers[j] > pivot);  
        // 交换i和j  
        if (i<j)  
        {  
            int temp=arrIntegers[i];  
            arrIntegers[i] = arrIntegers[j];  
            arrIntegers[j] = temp;  
        }  
    } while (i<j);  
  
    // 把pivot交换到j位置  
    {  
        int temp = arrIntegers[j];  
        arrIntegers[j] = arrIntegers[left];  
        arrIntegers[left] = temp;  
    }  
  
    // 返回分隔位置  
    return j;  
}  
  
void quicksort(int left, int right)  
{  
    if (left >= right)  
        return ;  
  
    // 找到划分位置  
    int mid = partion(left, right);  
    // 递归排序左侧子数组  
    quicksort(left, mid);  
    // 递归排序右侧子数组  
    quicksort(mid+1, right);  
}  

二分查找：

如果目标比中间值小，继续在左侧找，否则在右侧找。

int binsearch(int left, int right, int target)  
{  
    if (left>=right)  
        return -1;  
  
    int mid = (left+right)/2;  
    if ( target < arrIntegers[mid] )  
        return binsearch(left, mid-1, target);    
    if ( target > arrIntegers[mid] )  
        return binsearch(mid+1, right, target);  
    else  
        return mid;  
}  

测试：

int main(int argc,char*argv[])  
{  
    //mergesort(0, 9);  
    quicksort(0, 9);  
    for (int i = 0; i < 10; i++)  
    {  
        printf("%d, ", arrIntegers[i]);  
    }  
  
        printf("\n7 is at %d\n", binsearch(0, 9, 7));  
 }