演算法筆試題之平衡點問題
平衡點問題
平衡點問題: 一個數組中的元素,如果其前面的部分等於後面的部分,那麼這個點的位序就是平衡點。
比如列表numbers = [1, 3, 5, 7, 8, 25, 4, 20],25前面的總和為24,25,後面的總和也是24,那麼25就是這個列表的平衡點。
要求編寫程式,尋找並返回任意一個列表的平衡點。
一般演算法
假設列表的長度為N,N大於等於3。(因為N=1,2的時候問題無意義)
遍歷第二個元素至倒數第二個元素,分別計算該元素的左半部分的和與右半部分的和,如果左半部分的和等於右半部分的和,則返回該元素。
該演算法的優點是想法簡單,實現簡介,但其時間複雜度為
優化演算法
針對上述演算法的缺點,我們在此基礎上做改進,使得運算效率能提升。
首先我們定義兩個變數left_sum和right_sum, 其初始值分別為0和該列表第一個元素以後的所有元素的和。遍歷第二個元素至倒數第二個元素,每一次遍歷,left_sum加上該元素前的一個元素,right_sum減去該元素,如果left_sum等於right_sum,則返回該元素。
該演算法是對上述演算法的一個優化,使得我們不用在每次遍歷元素的時候求取左半部分和右半部分的和,只需要做一次加法和減法即可。具體分析該演算法,我們不難求得該演算法的時間複雜度為,即線性時間複雜度。
接下來我們將會分別給出上述兩種演算法的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), 歡迎大家關注哦~~