使用子集 - 成对差异（数组）答案

【问题标题】：Working with Subsets - Difference in pairs (array)使用子集 - 成对差异（数组）
【发布时间】：2017-03-06 00:41:56
【问题描述】：

我正在尝试编写一个程序，该程序接受一个数组，通过quickSort有效地对数组进行排序，然后对于排序后的数组中的每一对，通过整数参数（通过方法中的参数）传递指定的差异，它输出对基于指定的差异。该方法有效地返回一个具有不同整数对的 ArrayList。例如。假设我有一个类似 {16、12、7、8、4、13、9、20} 的数组。该方法将对它进行排序，然后如果传递的整数是 4，它将返回的对是

(4,8) (8,12) (9,13) (12,16) (16,20)

但由于某种原因，我的代码没有这样做，我收到了运行时错误：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
at java.util.Arrays.copyOf(Arrays.java:3210) 
at java.util.Arrays.copyOf(Arrays.java:3181) 
at java.util.ArrayList.grow(ArrayList.java:261) 
at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235) 
at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227) 
at java.util.ArrayList.add(ArrayList.java:458) 
at DifferencePairs.findPairs(DifferencePairs.java:20) 
at DifferencePairs.main(DifferencePairs.java:72)

这是我的代码，以及我所做的：

import java.util.ArrayList;

public class DifferencePairs {
    public static ArrayList<Pair> findPairs(int[] array, int diff) {
        /*
         * sort the array. This takes O(n log n) (quicksort)
Then for each x in array A, use binary search to look for difference in elements. This will take O(logn).
So, overall search is  O(n log n)
         */
        sort(array);
        int i = 0;
        int j = 1;
        int sizeOfArray = array.length;

        ArrayList<Pair> differencePairs = new ArrayList <Pair>();
        while (i < sizeOfArray && j < sizeOfArray) {
            if (i != j && (array[j] - array[i] == diff)) {

                Pair newPair = new Pair(array[j], array[i]);
                differencePairs.add(newPair);
            } else if (array[j] - array[i] < diff) {
                j++;
            } else if (array[j] - array[i] > diff){
                i++;

            }
        } return differencePairs;             
    }


    public static void sort(int[] arr)
    {
        quickSort(arr, 0, arr.length - 1);
    }
    /** Quick sort function **/
    public static void quickSort(int arr[], int low, int high) 
    {
        int i = low, j = high;
        int temp;
        int pivot = arr[(low + high) / 2];

        /** partition **/
        while (i <= j) 
        {
            while (arr[i] < pivot)
                i++;
            while (arr[j] > pivot)
                j--;
            if (i <= j) 
            {
                /** swap **/
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;

                i++;
                j--;
            }
        }

        /** recursively sort lower half **/
        if (low < j)
            quickSort(arr, low, j);
        /** recursively sort upper half **/
        if (i < high)
            quickSort(arr, i, high);
    }

    public static void main(String[] args) {
         int[] myArray = {16, 12, 7, 8, 4, 13, 9, 20};
         ArrayList<Pair> pairs = findPairs(myArray, 4);
         for (Pair pair: pairs) {
             System.out.println(pair.toString());
         }
    }               
}

如果您想知道的话，下一个类是 Pair 类。请告诉我哪里出错了。谢谢！

public class Pair {

    private int first;
    private int last;

    public Pair(int first, int last)
    {
        this.first = first;
        this.last= last;

    }
    public int getFirst() {
        return first;
    }

    public void setFirst(int first) {
        this.first = first;
    }

    public int getLast() {
        return last;
    }

    public void setLast(int last) {
        this.last = last;
    }

    public String toString()
    {
        return "(" + this.first + " , " + this.last+ ")";
    }


}

【问题讨论】：

使用 HashMap 将是解决此问题的更好方法。
我明白这一点，但为此我的解决方案必须是 O(n log n) 而不是 O(n)。

标签： java arraylist subset quicksort

【解决方案1】：

在创建 Pair 对象的 while 循环中有一个无限循环。这就是你内存不足的原因。

我相信你需要在 while 循环的第一个条件中增加 i 和 j：

while (i < sizeOfArray && j < sizeOfArray)
{
    if (i != j && (array[j] - array[i] == diff))
    {
        Pair newPair = new Pair(array[j], array[i]);
        differencePairs.add(newPair);

        // increment both here
        i++;
        j++;
    }

    // rest of loop
}

【讨论】：