二分查找算法,斐波那契数列的递归及非递归。（分析时间复杂度及空间复杂度）

二分查找的非递归与递归实现：

#include<stdio.h>

int binarry_Search(int arr[], int len, int value){ //采用左闭右闭区间方式
int left=0,right=len-1;
int mid;
while(left<=right){
mid=left+((right-left)>>1); //(left+right)/2;
if(value<arr[mid]){
right=mid-1;
}
else if(value>arr[mid]){
left=mid+1;
}
else{
return mid;
}
}
return -1;
}
int binarry_Search2(int arr[], int len, int value){ //采用左闭右开区间方式
int left=0,right=len;
int mid;
while(left<right){
mid=left+((right-left)>>1); //(left+right)/2;
if(value<arr[mid]){
right=mid;
}
else if(value>arr[mid]){
left=mid+1;
}
else{
return mid;
}
}
return -1;
}

//使用非递归的时间复杂度为：O(logN),倒过来分析，比如一个数通过二分查找要找三次找到，那么这个有序数组的个数为2^3=8,则次数 time=logN;
//空间复杂度为：O（1）,创建的临时变量为常数个;

int recur_bin_Search(int arr[],int left,int right,int value){ //使用递归实现二分查找
int mid;
if(left<right){
mid=left+((right-left)>>1);
if(value<arr[mid]){
right=mid;
return recur_bin_Search(arr,left,right,value);
}
else if(value>arr[mid]){
left=mid+1;
return recur_bin_Search(arr,left,right,value);
}
else{
return mid;
}
}
return -1;
}

//递归方式的时间复杂度：函数每次执行的时间复杂度为O（1），执行递归的次数同非递归的二分查找次数，故时间复杂度也是O(logN);
//空间复杂度：O(1);

int main(){
int arr[]={1,3,5,6,7,8};
int len=sizeof(arr)/sizeof(int);
int m=recur_bin_Search(arr,0,len,8);
printf("%d\n",m);
return 0;
}

斐波那契
#include<stdio.h>

int fibona(int n){ //迭代法
int a=0,b=1,m;
if(n<2){
return n;
}
while(n-->1){
m=a+b;
a=b;
b=m;
}
return m;
}
//时间复杂度为：O(N);空间复杂度为：O(1);

int fibona_recur(int n){ //递归
if(n<2){
return n;
}
else{
return fibona_recur(n-1)+fibona_recur(n-2);
}
}
//时间复杂度：O(2^n) 空间复杂度为：O(1);

int fibona_tail_recur(int n,int a,int b){
if(0==n){
return a;
}
else{
fibona_tail_recur(n-1,b,a+b);
}
}
//时间复杂度为：O(N);空间复杂度为：O(1);

int main(){
int i=0;
for(i;i<12;i++){
int m=fibona_tail_recur(i,0,1);
printf("%d ",m);
}
return 0;
}