二分查找和二分排序

二分查找又称折半查找

凭借一句话获得图灵奖的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;
    }
}

你可能感兴趣的:(LeetCode,&,Algorithm)