快速查找数组中“和”为X的两个数

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zxm317122667/article/details/83962270

快速判断在一个数组中，是否存在两个数字，让这两个数字之和等于一个给定的值 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);
        }
    }
}

可以看出，这种算法的复杂度取决于使用哪一种排序算法。