Java 如何找到两个优先级队列之间的并集？

我已经找到了两个优先级队列之间的交叉点和差异，但是我很难找到如何找到这两个队列之间的联合。我觉得我可以用数组来完成这项工作，但我正在努力找到一种处理优先级队列的方法（任务需要它）

在此处输入代码公共静态优先级队列交叉点（优先级队列q1、优先级队列q2）{
PriorityQueue q3=新建PriorityQueue（）；
用于（字符串：q1）{
如果（q2.包含（字符串））{
q3.添加（字符串）；
}
}
返回q3；
}
在此处输入代码公共静态优先级队列差异（优先级队列q1，优先级队列交叉队列）{
PriorityQueue q3=新建PriorityQueue（）；
用于（字符串：q1）{
if（intersectionQueue.contains（字符串））{
}否则{
q3.添加（字符串）；
}
}
返回q3；
}

---

我只是在这里寻找提示而不是解决方案，真的需要帮助吗？这比较简单，对吧？只需将两个队列的所有项添加到结果队列中。就这样

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2){
    PriorityQueue<String> q3 = new PriorityQueue<>();
    q3.addAll(q1);
    q3.addAll(q2);
    return q3;
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
PriorityQueue q3=新建PriorityQueue（）；
q3.addAll（第一季度）；
q3.全部相加（q2）；
返回q3；
}

更新

如果您不想允许重复

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2){
    Set<String> hashSet = new HashSet<>(q1);
    hashSet.addAll(q2);
    return new PriorityQueue<>(hashSet);
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
Set hashSet=新hashSet（q1）；
hashSet.addAll（q2）；
返回新的优先级队列（hashSet）；
}

工会？这比较简单，对吧？只需将两个队列的所有项添加到结果队列中。就这样

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2){
    PriorityQueue<String> q3 = new PriorityQueue<>();
    q3.addAll(q1);
    q3.addAll(q2);
    return q3;
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
PriorityQueue q3=新建PriorityQueue（）；
q3.addAll（第一季度）；
q3.全部相加（q2）；
返回q3；
}

更新

如果您不想允许重复

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2){
    Set<String> hashSet = new HashSet<>(q1);
    hashSet.addAll(q2);
    return new PriorityQueue<>(hashSet);
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
Set hashSet=新hashSet（q1）；
hashSet.addAll（q2）；
返回新的优先级队列（hashSet）；
}

警告：您正在对非集合集合对象应用集合语义，因此，如果输入优先级队列包含重复元素，则结果是任意的

假设没有，另一个问题是代码使用的是O（n）

contains（）

方法，因此操作是O（m*n）

为了获得更好的性能，您应该使用真实的

---

标准类，包括所有实现，相当于“集合交集”。实现使用

c.contains（o）

，因此

c

应该是一个对象，从而产生o（m+n）性能

public static PriorityQueue<String> intersection(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.retainAll(new HashSet<>(q2));
    return q3;
}

public static PriorityQueue<String> difference(PriorityQueue<String> q1, PriorityQueue<String> intersectionQueue) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.removeAll(new HashSet<>(intersectionQueue));
    return q3;
}

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    Set<String> set = new HashSet<>(q1);
    set.addAll(q2);
    return new PriorityQueue<>(set);
}

---

标准的

Set

类都实现了，这相当于一个“Set并集”。使用

HashSet

会产生O（m+n）性能

public static PriorityQueue<String> intersection(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.retainAll(new HashSet<>(q2));
    return q3;
}

public static PriorityQueue<String> difference(PriorityQueue<String> q1, PriorityQueue<String> intersectionQueue) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.removeAll(new HashSet<>(intersectionQueue));
    return q3;
}

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    Set<String> set = new HashSet<>(q1);
    set.addAll(q2);
    return new PriorityQueue<>(set);
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
Set=newhashset（q1）；
set.addAll（q2）；
返回新的优先级队列（设置）；
}

警告：您正在对非集合集合对象应用集合语义，因此，如果输入优先级队列包含重复元素，则结果是任意的

假设没有，另一个问题是代码使用的是O（n）

contains（）

方法，因此操作是O（m*n）

为了获得更好的性能，您应该使用真实的

---

标准类，包括所有实现，相当于“集合交集”。实现使用

c.contains（o）

，因此

c

应该是一个对象，从而产生o（m+n）性能

public static PriorityQueue<String> intersection(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.retainAll(new HashSet<>(q2));
    return q3;
}

public static PriorityQueue<String> difference(PriorityQueue<String> q1, PriorityQueue<String> intersectionQueue) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.removeAll(new HashSet<>(intersectionQueue));
    return q3;
}

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    Set<String> set = new HashSet<>(q1);
    set.addAll(q2);
    return new PriorityQueue<>(set);
}

---

标准的

Set

类都实现了，这相当于一个“Set并集”。使用

HashSet

会产生O（m+n）性能

public static PriorityQueue<String> intersection(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.retainAll(new HashSet<>(q2));
    return q3;
}

public static PriorityQueue<String> difference(PriorityQueue<String> q1, PriorityQueue<String> intersectionQueue) {
    PriorityQueue<String> q3 = new PriorityQueue<>(q1);
    q3.removeAll(new HashSet<>(intersectionQueue));
    return q3;
}

public static PriorityQueue<String> union(PriorityQueue<String> q1, PriorityQueue<String> q2) {
    Set<String> set = new HashSet<>(q1);
    set.addAll(q2);
    return new PriorityQueue<>(set);
}

公共静态优先级队列联合（优先级队列q1、优先级队列q2）{
Set=newhashset（q1）；
set.addAll（q2）；
返回新的优先级队列（设置）；
}

我的理解是OP在避免重复。据我所知，队列不像集合那样丢弃重复项。避免重复项？例如，[2,2,2]和[2,2]的并集将产生[2,2,2]或[2,2]或[2]？从我在问题中看到的情况来看，似乎是

[2]

。我不确定，我只是认为这就是我的意图。嘿，kaidul，我不能这样做，因为我不能有重复。令人沮丧的是，我可以用数组很容易地解决这个问题，但我正在努力找到一种使用quese的方法，非常棘手。我的理解是OP是避免重复的。据我所知，队列不像集合那样丢弃重复项。避免重复项？例如，[2,2,2]和[2,2]的并集将产生[2,2,2]或[2,2]或[2]？从我在问题中看到的情况来看，似乎是

[2]

。我不太清楚，我只是认为这就是我的意图。嘿，kaidul，我不能这么做，因为我不能让你失望，我可以用数组很容易地解决这个问题，但我正在努力找到一种解决quese的方法，非常棘手，[2，2，2]和[2，2]的预期输出是什么？[2，2，2]的预期输出是什么还有[2，2]？非常感谢！！！！我不知道如何给你一个名誉点，我不常来这里。非常感谢你！！！！我不知道如何给你一个名誉点，我不常来这里。