Как получить вывод из древовидной карты последовательно, не завися от значения ключа в Java - PullRequest
Новая
       9

Как получить вывод из древовидной карты последовательно, не завися от значения ключа в Java

0 голосов
/ 19 января 2019

У меня проблема с программированием. У меня есть два массива. nums1 = {1,7,11} и nums2 = {2,4,6}. Я должен выяснить наименьшую сумму, берущую 1 число из каждого массива до k-го времени. В моем примере k = 3. Таким образом, наименьшие суммы: {1 + 2 = 3}, {1 + 4 = 5}, {1 + 6 = 7}. Массивы всегда в отсортированном порядке.

Я использовал Treemap для решения этой проблемы.

Вот и мы: 

public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
     Map<Integer,int[]> value=new TreeMap<>();
     int[]arr_hold=new int[2];
     int []solve_arr=new int[k];
     List<int[]> solve = new ArrayList<>();
     ArrayList<Integer>add_sum= new ArrayList<>();
     int sum=0;
     for(int i=0;i<nums1.length;i++){
         for(int j=0;j<nums2.length;j++){
             sum=nums1[i]+nums2[j];
             arr_hold[0]=nums1[i];
             arr_hold[1]=nums2[j];
             value.put(sum,arr_hold);
         }
     }


     return solve;
 }

Проблемы: 1.При печати System.out.println (значение); Выход: 

{3=[I@75412c2f, 5=[I@75412c2f, 7=[I@75412c2f, 9=[I@75412c2f, 11=[I@75412c2f, 13=[I@75412c2f, 15=[I@75412c2f, 17=[I@75412c2f}

Теперь, почему значения массива arr_hold не отображаются должным образом?

Поскольку я беру Treemap, он уже показывает мне вывод в отсортированном формате. Поэтому, если я возьму 1, 2, 3 значение из древовидной карты, моя проблема будет решена. Но ограничение здесь 

 value.get() method

Элемент поиска зависит от значения ключа. Так что, если я возьму цикл для получения 3 самых маленьких значений из древовидной карты, это даст мне нулевой вывод, поскольку ключи не совпадают. 

 for(int k1=0;k1<k;k1++){
         System.out.println(value.get(k1));
     }

Выход: ноль 

     null

     null

Как мне решить мою проблему на моем пути ?

1 Ответ

0 голосов
/ 20 января 2019

А как же это: 

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

public class KSmallestPairs {
    public static void main(String[] args) {
        System.out.println(kSmallestPairs(new int[]{1,7,11}, new int[]{2,4,6}, 3));
    }

    public static List<SumPair> kSmallestPairs(int[] leftInts, int[] rightInts, int k) {
        if (k < 1) {
            throw new IllegalArgumentException("k (=" + k + ") must higher than 0!");
        } else if (leftInts.length * rightInts.length < k) {
            throw new IllegalArgumentException("k (=" + k
                    + ") cannot be higher than the length of the cartesian product (="
                    + leftInts.length * rightInts.length + ")");
        }

        final List<SumPair> sumPairs = new ArrayList<>();
        int minLeftIndex = 0;
        int minRightIndex = 0;
        for (int leftIndex = 0, rightIndex = 0;
             leftIndex < leftInts.length
                     && rightIndex < rightInts.length
                     && sumPairs.size() < k; ) {            
            final int leftInt = leftInts[leftIndex];
            final int rightInt = rightInts[rightIndex];
            sumPairs.add(new SumPair(leftInt, rightInt));

            if(leftIndex + 1 < leftInts.length && rightIndex + 1 < rightInts.length) {
                final int nextLeftInt = leftInts[leftIndex + 1];
                final int nextRightInt = rightInts[rightIndex + 1];
                final int sumOfLeftIntAndNextRightInt = leftInt + nextRightInt;
                final int sumOfNextLeftIntAndRightInt = nextLeftInt + rightInt;
                if(sumOfLeftIntAndNextRightInt < sumOfNextLeftIntAndRightInt) {
                    rightIndex++;
                } else {
                    leftIndex++;
                }
            } else if(leftIndex + 1 < leftInts.length) {
                leftIndex++;
                rightIndex = minRightIndex;
                minLeftIndex++;
            } else if(rightIndex + 1 < rightInts.length) {
                leftIndex = minLeftIndex;
                rightIndex++;
                minRightIndex++;
            }
        }
        return sumPairs;
    }

    static class SumPair {
        private final int leftInt;
        private final int rightInt;

        public SumPair(int leftInt, int rightInt) {
            this.leftInt = leftInt;
            this.rightInt = rightInt;
        }

        public int getLeftInt() {
            return leftInt;
        }

        public int getRightInt() {
            return rightInt;
        }

        public int getSum() {
            return leftInt + rightInt;
        }

        @Override
        public String toString() {
            return leftInt + "+" + rightInt + "="+ getSum();
        }
    }
}

Вывод: 

[1+2=3, 1+4=5, 1+6=7, 7+2=9]

Он с нетерпением находит k пар наименьшей суммы.

...