快速判斷在一個數組中，是否存在兩個數字，讓這兩個數字之和等於一個給定的值 X。

以陣列 arr[] = {11, 15, 6, 8, 9, 10} 為例：

當x = 16時， 存在兩個數字的和為16： (6, 10) 
輸出: true

當x = 35時， 存在兩個數字的和為35： (26, 9) 
輸出: true

當x = 45時， 不存在兩個數字的和為45
輸出: false

普通解法

最簡單的方法就是暴力解法，用兩個迴圈將陣列中每兩個元素相加，然後依次判斷是否等於特定值，程式碼如下：

private boolean pairInArray(int[] arr, int length, int pair) {
        for (int i = 0; i < length - 1; i++) {
            for (int j = i + 1; j < length; j++) {
                if (arr[i] + arr[j] == 45) {
                    return true;
                }
            }
        }
        return false;
}
 

由於套用了兩層迴圈，所以這種演算法的時間複雜度為 O(n2)

優化演算法

假如這個陣列是有序的，即升序或者降序排列，那麼只需要不斷比較第一個與最後一個數值和是否等於給定值X，根據大小移動第一個下標或者第二個。由此我們可以先把這個陣列進行排序，然後再進行查詢。排序演算法可以選擇快速排序(可以在其他章節找到對快速排序的介紹)，它能在O(nlogn)的時間複雜度內將元素排列好，程式碼如下：

boolean pairInSortedArray(int arr[],  
                                    int n, int x) 
{ 
     int length = array.length;
        QuickSort.quickSort(array, 0, length-1);
        
        if(array[0] >= x){
            return false;
        }
        int i = 0;
        --length;
        while(i < length){
            if(array[i] + array[length] == x){
                return true;
            }else if(array[i] + array[length] > x){
                --length;
            }else{
                ++i;
            }
        }
        return false;  
}
 

QuickSort.java程式碼如下：

public class QuickSort {
    
    public static int findPrivote(int[] array, int low, int high) {
        int temp = array[low];
        while(low < high){
            while(low < high && array[high] > temp){
                --high;
            }
            array[low] = array[high];
            while(low < high && array[low] < temp){
                ++low;
            }
            array[high] = array[low];
        }
        array[low] = temp;
        return low;
    }
    
    public static void quickSort(int[] array, int low, int high){
        if(low < high){
            int privote = findPrivote(array, low, high);
            quickSort(array, low, privote-1);
            quickSort(array, privote+1, high);
        }
    }
}
 

可以看出，這種演算法的複雜度取決於使用哪一種排序演算法。