平衡点问题
平衡点问题: 一个数组中的元素，如果其前面的部分等于后面的部分，那么这个点的位序就是平衡点。
比如列表numbers = [1, 3, 5, 7, 8, 25, 4, 20]，25前面的总和为24，25，后面的总和也是24，那么25就是这个列表的平衡点。
要求编写程序，寻找并返回任意一个列表的平衡点。
一般算法
假设列表的长度为N，N大于等于3。（因为N=1,2的时候问题无意义）
遍历第二个元素至倒数第二个元素，分别计算该元素的左半部分的和与右半部分的和，如果左半部分的和等于右半部分的和，则返回该元素。
该算法的优点是想法简单，实现简介，但其时间复杂度为O(n^{2}), 效率并不高。
优化算法
针对上述算法的缺点，我们在此基础上做改进，使得运算效率能提升。
首先我们定义两个变量left_sum和right_sum， 其初始值分别为0和该列表第一个元素以后的所有元素的和。遍历第二个元素至倒数第二个元素，每一次遍历，left_sum加上该元素前的一个元素，right_sum减去该元素，如果left_sum等于right_sum，则返回该元素。
该算法是对上述算法的一个优化，使得我们不用在每次遍历元素的时候求取左半部分和右半部分的和，只需要做一次加法和减法即可。具体分析该算法，我们不难求得该算法的时间复杂度为O(n)，即线性时间复杂度。
接下来我们将会分别给出上述两种算法的Python代码和Java代码，做一些比较。
Python代码
我们取测试的列表为[-1, 1]*50000+[1,3,5,7,8,25,4,20],该列表共100008个元素。
完整的Python代码如下：
"""
balance point problem
"""
import time
# 优化算法
def balance_point(a):
# 初始值
left_sum, right_sum = (0, sum(a[1:]))
#下标为1, 2, 3, ..., len(a)-2时的情形
for i in range(1, len(a)-1):
left_sum += a[i-1]
right_sum -= a[i]
if left_sum == right_sum:
return i
return -1
# 一般算法
def balance_point2(a):
# 遍历第2个至倒数第2个元素，分别计算其左半部分和右半部分的和
# 如果其左半部分和右半部分的和，则返回该下标
for i in range(1, len(a)-1):
left_sum = sum(a[:i]) # 左半部分的和
right_sum = sum(a[i+1:]) # 右半部分的和
if left_sum == right_sum:
return i
return -1
# 测试两种不同算法的消耗时间
t1 = time.time()
# 列表a,一共有100008项
a = [1,-1]*50000+[1,3,5,7,8,25,4,20]
index = balance_point(a)
t2 = time.time()
if(index != -1):
print("优化算法耗时：%.2f s, index: %d, number: %d."%(t2-t1, index, a[index]))
a = [1,-1]*50000+[1,3,5,7,8,25,4,20]
index = balance_point2(a)
t3 = time.time()
if(index != -1):
print("一般算法耗时：%.2f s, index: %d, number: %d."%(t3-t2, index, a[index]))
输出结果如下：
优化算法耗时：0.02 s, index: 100005, number: 25.
一般算法耗时：105.46 s, index: 100005, number: 25.
Java代码
完整的Java代码如下：
package Problems;
import java.util.ArrayList;
import java.util.Date;
// 平衡点问题(balance point problem)
public class Balance_Point {
public static void main(String[] args){
// 创建测试数组a
ArrayList<Integer> a = new ArrayList<>();
for(int i=0; i<50000; i++) {
a.add(1); a.add(-1);
}
int[] b = {1,3,5,7,8,25,4,20};
for(int i: b) {a.add(i);}
// 测试两种不同算法的消耗时间
Date t1 = new Date(); // 开始时间
int index = balance_point(a);
Date t2 = new Date(); // 一般算法结束时间
Long cost_time1 = t2.getTime()-t1.getTime();
if(index != -1)
System.out.println(String.format("一般算法：%d -> %d, 耗时：%.2fs.", index, a.get(index), cost_time1*1.0/1000));
Date t3 = new Date(); // 开始时间
int index_opt = balance_point_opt(a);
Date t4 = new Date(); // 优化算法结束时间
Long cost_time2 = t4.getTime()-t3.getTime();
if(index != -1)
System.out.println(String.format("优化算法：%d -> %d, 耗时：%.2fs.", index_opt, a.get(index_opt), cost_time2*1.0/1000));
}
// 一般算法
public static int balance_point(ArrayList<Integer> a){
/* 遍历第2个至倒数第2个元素，分别计算左半部分和右半部分的和
* 如果左半部分和右半部分的和，则返回该下标
*/
for(int i=1; i<a.size()-1;i++){
int left_sum = 0; // 左半部分的和
for(int j=0; j<i; j++)
left_sum += a.get(j);
int right_sum = 0; // 右半部分的和
for(int k=i+1; k<a.size(); k++)
right_sum += a.get(k);
if(left_sum == right_sum)
return i;
}
return -1;
}
// 优化算法
public static int balance_point_opt(ArrayList<Integer> a){
int left_sum = 0;
int right_sum = 0;
for(int i=1; i<a.size();i++)
right_sum += a.get(i);
// 下标为1,2,3,...,a.length-2时的情形
for(int i=1; i<a.size()-1;i++){
left_sum += a.get(i-1);
right_sum -= a.get(i);
if(left_sum == right_sum)
return i;
}
return -1;
}
}
运行该Java程序，得到的输出如下：
一般算法：100005 -> 25, 耗时：9.14s.
优化算法：100005 -> 25, 耗时：0.02s.
从中我们也可以发现，同样的程序，Java的运行时间要远远比Python来得快。
本次分享到此结束，如果任何问题，欢迎交流~~
注意：本人现已开通两个微信公众号： 因为Python（微信号为：python_math）以及轻松学会Python爬虫（微信号为：easy_web_scrape）， 欢迎大家关注哦~~
