二分查找递归非递归算法对比

#include <iostream>

#include <ctime>//时间函数

#include <windows.h>系统函数

#include <fstream>

#include <cstdlib>

#include <iomanip>//声明 “流操作符”的头文件

using namespace std;

/*************非递归二分搜索****************/

class Solution

{

       public:

       intbinarySearch(const int A[], int X, int N)//二分查找函数

       {

              intstart = 0, end = 0, mid;

              end= N;

              while(start <= end)

              {

                     mid= start + (end-start)/2;

                     if(X > A[mid])

                     {

                            start= mid+1;

                            continue;

                     }

     else if (X < A[mid])

                     {

                            end= mid-1;

                            continue;

                      }

     else

              {

                            returnmid;

              }

       }

                     return-1;

    }

};

 

/**********递归二分搜索****************/

int BinSearch(int Array[], int low, inthigh, int key)

{

       if(low <= high)

       {

              intmid = (low + high) / 2;

              if(key == Array[mid])

                     returnmid;

              elseif (key<Array[mid])

                     returnBinSearch(Array, low, mid - 1, key);//进行递归

              elseif (key>Array[mid])

                     returnBinSearch(Array, mid + 1, high, key);

       }

       else

              return-1;

}

 

 

 

int main(int argc, const char * argv[])//

{

       intret;

       intneed[10000];

 

       for(inti=0;i<10000;i++)//1到10000存进数组

       {

              need[i]=i;

       }

 

 

       clock_tstart1,finish1;

       longdouble totaltime1;

       start1=clock();

       intsz=sizeof(need)/sizeof(need[0])-1;//求sz的长度

      

       finish1=clock();//结束时间

      

 

 

 

 

       inttarget=0;

       cout<<"请输入查找数字："<<endl;

       cin>>target;

 

 

       clock_tstart2,finish2;

       longdouble totaltime2;

       start2=clock();

       for(inti=0;i<100000000;i++)//让函数执行这么多次算总时间

       {

              Solutionc;

              ret=c.binarySearch(need,target,sz);

      

       }

       finish2=clock();

       totaltime2=(double)(finish2-start2)/CLOCKS_PER_SEC;

       cout<<"\n非递归二分搜索查找时间为："<<totaltime2<<"秒！"<<endl;

 

 

       clock_tstart3,finish3;

       longdouble totaltime3;

      

start3=clock();

       for(int i = 0; i < 100000000; i++)

              {

                     intsit = BinSearch(need, 0, sz, target);

              }

 

       finish3=clock();

       totaltime3=(double)(finish3-start3)/CLOCKS_PER_SEC;

       cout<<"\n递归二分搜索查找时间为："<<totaltime3<<"秒！"<<endl;

 

 

       cout<<"目标数："<<target<<endl;

       if(ret==-1)

       cout<<"找不到"<<endl;

       else

       cout<<"找到了，坐标为："<<ret<<endl;

       system("pause");

       return0;

}

 

运行结果：

 

结果分析：

这次的算法虽然没有在大量的数字中进行查找，但是让这个查找函数循环了非常多次，来计算总时间，将两个算法搜索时间放大化，这样也可以对比出算法的优劣，由结果得，递归的时间是要小于朴素算法的时间的下面比较它们在其他方面的不同：

递归结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，而且写起来简单递归相比非递归的区别是递归算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多另一个是调用接口的开销，函数调用本身是有开销的。还有是堆栈内存比较小递归调用层次深，复杂时可以采用递归，但是容易引起堆栈溢出错误。非递归没有这个问题。