在LeedCode中有一個兩數之和的練習，那是無序的陣列。現在，對其進行深一步討論，加入該陣列是有序的，這裡僅僅以升序做為例子。 找出一對索引，並返回。 分為兩種情況：

1. 找出一組索引就直接返回。
2. 找出所有符合條件的索引，返回。

import java.util.ArrayList;
import java.util.List;

/**
 * 問題描述(初級版1.0：只需找出一組，不分先後。)：
 * 一個有序的整型陣列（比如：升序。），給定一個數，求出陣列中是否存在倆數之和等於這個數。
 * 如果存在，返回這倆數的索引（用長度為2的陣列儲存）。
 * 不存在時，返回null。
 * 比如：{1,2,4,8}
 * 傳入的target=6
 * 返回值{1,2}
 * 
 * 問題描述(升級版2.0：找出所有的2個數。)：
 * 
 * 注意：
 * 實現中使用的都是升序陣列。
 * @author
 
 Feng
 * 2018年9月13日下午3:14:22
 */
public class Array3 {

    /**
     * 找出陣列中兩個數之和為target的數在陣列中的位置。
     * 任意找出一組，返回其下標。
     * @param arr
     * @param target
     * @return
     */
    public static int[] twoNumSum(int[] arr, int target) {
        int[] results = new int[2];

        final int length = arr.length;
        System.out.println("陣列的length = "
 
 + length);
        for(int i = 0, j = length - 1; i < length;) {
            if(target > arr[i] + arr[j] && i != j) {
                i ++;
                continue;
            }

            if(target < arr[i] + arr[j] && i != j) {
                j --;
                continue
 
;
            }
            results[0] = i;
            results[1] = j;
            break;
        }

        return results;
    }

    /**
     * 2.0版本：找出所有的符合上述條件的2個數的索引。
     * @param arr
     * @param target
     * @return 使用集合儲存，泛型型別是陣列型別。
     */
    public static List<Integer[]> listTwoSum(int[] arr, int target){
        // 過濾異常情況。
        if(arr == null || arr.length < 2) {
            throw new IllegalArgumentException("Array is exception");
        }
        // 陣列中的數小於最小的2個數之和，或者大於最大的2個數之和，直接丟擲異常。
        if(target <= arr[0] + arr[1] || target > arr[arr.length - 1] + arr[arr.length - 2]) {
            throw new IllegalArgumentException("target is exception");
        }

        Integer[] result = null;// 存放結果
        List<Integer[]> list = new ArrayList<>();// 存放結果集

        /* i表示陣列從前至後的移動，j表示從最後一個元素往前移動。
         * 迴圈結束條件是，當移動到同一個數的位置結束。即arr[i] = arr[j]時。
         */ 
        for(int i = 0, j = arr.length  - 1; i != j;) {
            if(target > arr[i] + arr[j]) {
                i ++;
                continue;
            }

            if(target < arr[i] + arr[j]) {
                j --;
                continue;
            }

            // 建立陣列，儲存索引值，新增到集合中。
            result = new Integer[2];
            result[0] = i;
            result[1] = j;
            list.add(result);

            i ++;// 更新，左邊的數往右移。
            j --;// 更新，右邊的數往左移。
        }

        return list;
    }

    // 列印整型集合，其實列印的是集合中數組裡面的元素。
    public static void printList(List<Integer[]> list) {
        for(int i = 0; i < list.size(); i ++) {
            Integer[] res = list.get(i);
            System.out.println("第" + (i+1) + "組索引：【" + res[0] + "," + res[1] + "】");
        }
    }

    // 測試
    public static void main(String[] args) {
        int[] arr = {1,3,4,5,7,9,10};
        int[] res = twoNumSum(arr, 14);
        // 找不到時，打印出的是[0,0]
        System.out.println(res[0] + "," + res[1]);

        // 找出所有的2個數。
        List<Integer[]> list = listTwoSum(arr, 14);
        printList(list);

    }
}