二分查找和二分排序

二分查找又称折半查找

凭借一句话获得图灵奖的Pascal之父——Nicklaus Wirth（一个很牛逼的人）
让他获得图灵奖的这句话就是他提出的著名公式：
“算法+数据结构=程序”。
这个公式对计算机科学的影响程度足以类似物理学中爱因斯坦的“E=MC^2”——一个公式展示出了程序的本质。

，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难

算法要求
1. 必须采用顺序存储结构
2. 必须按关键字大小有序排列。
算法分析

时间复杂度可以表示O()=O(logn)
它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务

#include 

using namespace std;
//选择排序
void SelectSort(int a[],int n)
{
    for(int i=0; i//外层循环
    {
        int min=a[i];//每次循环把a[i]假设当前最小的数
        int index=i;//相当一个索引，始终指向最小的
        for(int j=i+1; j//内层循环，从剩下的数中找有没有更小的
        {
            if(a[j]//跟新索引
            }
        }
        int temp=a[index];//交换
        a[index]=a[i];
        a[i]=temp;
    }
    for(int i=0; icout<" ";
    }
}

//非递归二分查找
int BinarySearch(int s[],int x,int n)
{
     //如果传入的数组为空或者数组长度<=0那么就返回-1。防御性编程
    if(s==NULL||n<0)
    {
        return -1;
    }
    int low=0;
    int high=n-1;
    while (low<=high)
    {
        int middle=(low+high)/2;
        if(x==s[middle])
        {
            return middle;
        }
        else if(x>s[middle])
        {
            low=middle+1;
        }
        else
        {
            high=middle-1;
        }
    }
     return -1;
}

//-------------
while(x<=y) {
        m = x + (y-x)/2; //2
        if(data[m] == v) return m; //3
        else if(data[m] > v) y = m-1; //4
        else x = m+1; //5
    }

补充：x2，写成x+(y-x)/2是防止xy都很大的情况下x+y越界。这样的话应对二分查找应该够了

//------------------

//递归的二分查找
int nBinarySearch(int s[],int x,int low,int high)
{
    if(low>high)return -1;
    int middle=(low+high)/2;
    if(x==s[middle])return middle;
    else if(x>s[middle])
    {
        return nBinarySearch(s,x,middle+1,high);
    }else
    {
        return nBinarySearch(s,x,low,middle-1);

    }
}

int main()
{
    int s[11]= {6,15,12,22,18,28,25,60,58,46,35};
    int n=sizeof(s)/sizeof(int);
    cout<cout<<"index:"<12,0,n-1);
    cout<cout<<"index:"<12,0,n-1);
    return 0;
}

二分排序（折半插入排序）

二分排序就是折半插入排序，当直接插入排序进行到某一趟时，对于前面记录已经按关键字有序，此时不用直接插入排序的方法，而用折半二分查找，找出下一个元素应插入的位置，然后插入，这种方法就是折半插入排序，这种方法中比较次数，由于采用折半查而减少，为O（nlogn），但是元素交换的次数仍为O(n2)，二分排序算法是稳定的。

#include 

using namespace std;

void binary_sort(int a[],int n);
int main()
{
    int a[]= {3,41,369,1,2,4,5,9};
    int n=8;
    binary_sort(a,n);
    for(int i=0; icout<" ";
    }
    return 0;
}

void binary_sort(int a[],int n)
{
    int low ,high, mid;
    int tem;
    for(int i=1; i0;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(a[mid]>tem)
            {
                high=mid-1;
            }
            else
            {
                low=mid+1;
            }
        }
        for(int j=i-1; j>high; j--)
        {
            a[j+1]=a[j];
        }
        a[high+1]=tem;
    }
}