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

#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;
}