算法筆試題之平衡點問題

平衡點問題

  平衡點問題: 一個數組中的元素，若是其前面的部分等於後面的部分，那麼這個點的位序就是平衡點。
  好比列表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）， 歡迎你們關注哦~~