最大非负的序列和

第一种方法:设定一个从i开始的计数，然后再以j为起点，k不断变化，算和算法复杂度是o(N*N*N)

第二种是第一种的改进算法复杂度是O(N*N)

第三中是最直接的 。算法复杂度是O(N) 它隐藏着条件。从正数开始，如果和为0就重新开始计算。

第四种方式，递归。时间复杂度是 O(NlogN)

递归算法的时间复杂度怎么计算呢？

参考他的文章，真的很棒。http://blog.csdn.net/budapest/article/details/6367973/

重点说下递归。

说实话我也不太清楚多次递归，一直很困惑，通过输出检测，发现递归函数实际上始终只有一个递归栈的。

?

1	int  arr[7] = {2,-1,3,-4,1,2,-3};

这个数组其实会被不断的运算直到左边=右边

数组的计算过程是   06 的左边  03和4,6

03又被解析成01和23 然后01被分解成00和11

递归真是一个有意思的东西哦。

#include <stdio.h>


int get_max_in_three(int a,int b,int c){
	if(a > b){
		if(a > c){
			return a;
		}else{
			return c;
		}
	}else{
		if( b > c){
			return b;
		}else{
			return c;
		}
	}
}

int bestqueue(int *arr ,int left,int right){
	int i,center;
	int left_max,right_max;
	int left_bord_sum,left_bord_max;
	int right_bord_sum,right_bord_max;

	if(left == right){
		if(arr[left] > 0){
			return arr[left];
		}
		else
		{
			return 0 ;
		}
	}

	center = (left + right)/2;
	left_max = bestqueue(arr,left,center);
	right_max = bestqueue(arr,center+1,right);

	left_bord_sum = left_bord_max = 0;
	for(i=center;i>=left;i--){
		left_bord_sum += arr[i];
		if(left_bord_sum > left_bord_max){
			left_bord_max = left_bord_sum;
		}
	}

	right_bord_sum = right_bord_max = 0;
	for(i=center+1;i<=right;i++){
		right_bord_sum += arr[i];
		if(right_bord_sum > right_bord_max){
			right_bord_max = right_bord_sum;
		}
	}
	return get_max_in_three(left_max,left_bord_max+right_bord_max,right_max);
}

int maxqueue_qute(int arr[],int len){
	int i,j,k,sum,max;
	max = 0;
	for(i=0;i<len;i++){
		for(j=i;j<len;j++){
			sum = 0;
			for(k=i;k<=j;k++){
				sum += arr[k];
			}
			if(sum > max){
				max = sum;
			}
		}
	}
	return max;
}

int maxqueue_qute_more(int arr[],int len){
	int i,j,sum,max;
	max = 0;
	for(i=0;i<len;i++){
		sum = 0;
		for(j=i;j<len;j++){
			sum += arr[j];
			if(sum > max){
				max = sum;
			}
		}
	}
	return max;
}

int maxqueue_qute_fast(int arr[],int len){
	int i,max,sum;
	max = sum = 0;
	for(i=0;i<len;i++){
		sum += arr[i];
		if(sum < 0 ){
			sum = 0;
		}
		if(sum > max){
			max = sum;
		}
	}
	return max;
}


int main(int argc, char const *argv[])
{
	int max;
	int arr[7] = {2,-1,3,-4,1,2,-3};
	printf("%d\n", maxqueue_qute(arr,7));
	printf("%d\n", maxqueue_qute_more(arr,7));
	printf("%d\n", maxqueue_qute_fast(arr,7));
	printf("%d\n", maxqueue_rec(arr,0,6));
	printf("%d\n", bestqueue(arr,0,6));
	printf("end");
	return 0;
}