Question

它的铲斗排序算法，试图从点（0,0）获得K最近的位置。这是通过计算这些位置的距离并根据距离对它们进行划分来完成的。如果两个位置的距离相等，则优先考虑带有壁橱x的位置，然后是y（如果x值相同）

以下解决方案的时间复杂度是多少？ O（NlogN）或O（KNlogN）或其他任何东西

// java

Input: int k, List<Location>
Output: List<Location>

public class Location {
    //constructor x and y
    int x;
    int y;
    //get 
    //set

    //hashcode and equals
}

public class Solution {
    public List<Location> returnKNearestLocation(int k, List<Location> locations) {
        Map<Float, Set<Location>> map = new TreeMap<>();
        for(Location loc: locations) {
            float dist = calculateDistance(new Location(0,0), loc);
            List<Location> temp = map.getOrDefault(dist, new HashSet());
            temp.add(loc);
            map.put(temp);
        }

        List<Location> result = new ArrayList<>();
        int size = k;
        while(size > 0) {
            for(Float key : map.keySet()) {
                Set<Location> loc = map.get(key);
                Collection.sort(loc, p1, p2 -> {
                        return p1.x.equals(p2.x)? p1.y.compare(p2.y) : p1.x.compare(p2.x);
                });

                for(Location currLoc : loc) {
                    result.add(currLoc);
                    if(result.size() == k) {
                        return result;
                    }
                }
                size = size - loc.size();
            }                
        }

        return result;
    }

    private float calculateDistance(Location p, Location q) {
       // calculate distance Math.sqrt((P.x - Q.x)^2 + (P.y - Q.y)^2)
    }
}

Answer 1

我会说O（N * log（N））。

假设float dist = calculateDistance(new Location(0,0), loc)是O（1）。
put()中getOrDefault()和TreeMap的实现是O（log（N））。其他实现提供O（1）。我会看看HashMap。
add中HashSet的实施是O（1）（摊销）。
add中ArrayList的实施是O（1）（摊销）
如果所有物品都放在同一个桶中，BucketSort的最坏情况是O（N ^ 2）。

我会看一下HashMap而不是TreeMap。

所以，假设我没错：

第一个循环（ foreach loc ）的复杂度为O（N * log（N））。
第二个循环（，而大小> 0 ）是O（N * log（N））。
- 假设所有位置都放在同一个桶中，我们会对所有项目进行排序（O（N * log（N）））。
- 然后我们将遍历前K个元素，并添加到结果中 - 这需要O（K）＆lt; O（N）。

以下修改后的桶排序解决方案的时间复杂度

1 个答案: