Question

所以我们假设我们有queue可以在其中存储任何整数。

我需要做的（测试）是编写一个能够创建（并返回）新队列的函数，而不会让原始队列发生变化。

你可以更改它，但在功能结束时它必须与开头一样

我们假设class Queue中的唯一方法是：

插入/添加
除去
偷看
isEmpty（如果队列为空则返回True）

在新队列中，我们将得到每个整数，然后是它在第一个队列中出现的次数。

除了我可以使用的初始队列：Stack（s），Array（s），new Queue（s）和可能的LinkedList（s）。

也可以编写新功能。

直接解决方案（我猜）是在任何方法中复制第一个队列，然后使用while（！isEmpty）和一个计数器，然后将该数字添加到所需队列并从复制中删除之一。

我现在还没有记下这一点，但我真的不能想到一种更干净，更有效的方法，所以任何帮助都会受到赞赏。感谢。

Answer 1

你可能会在一段时间内找到更好的解决方案，但这就是我所做的：

public static Queue<Integer> countQueue(Queue<Integer> q) {
    LinkedList<Integer> valuesList = new LinkedList<>();
    // since we can't iterate on the Queue
    // we remove the head element
    while(!q.isEmpty()) {
        int x = q.remove();
        valuesList.add(x);
    }

    LinkedList<Integer> nonRepeated = new LinkedList<>();
    LinkedList<Integer> timesCount = new LinkedList<>();

    while(!valuesList.isEmpty()) {
        int value = valuesList.remove();
        q.add(value); // get the original queue back
        int index = nonRepeated.indexOf(value);
        if (index == -1) {
            nonRepeated.add(value);
            timesCount.add(1);
        } else {
            timesCount.set(index, timesCount.get(index)+1);
        }
    }
    Queue<Integer> output = new ArrayDeque<>();
    while(!nonRepeated.isEmpty()) {
        output.add(nonRepeated.remove());
        output.add(timesCount.remove());
    }

    return output;
}

如果您对创建获取队列大小的方法感兴趣，这可能是最简单的解决方案之一：

public static int getQueueSize(Queue<Integer> q) {
    int i=0;
    Queue<Integer> backupQueue = new ArrayDeque<>(); 
    while(!q.isEmpty()) {
        i++;
        backupQueue.add(q.remove());
    }
    while(!backupQueue.isEmpty())
        q.add(backupQueue.remove());
    return i;
}

每当使用队列，堆栈等时，您都需要注意数据结构的范例，例如FIFO（先进先出）和LIFO（后进先出），其中将决定你应该如何迭代结构。

Answer 2

想法：迭代队列并像你一样重新添加元素。保留地图以存储每个元素的计数。然后将地图转换为队列。

像这样（未经测试）：

public Queue<Integer> count(Queue<Integer> input) {
  int size = input.size();
  Map<Integer, Integer> counts = new HashMap<>();
  for (int i = 0; i < size; i++) {
      Integer element = input.remove(); // take from front of queue.
      if (!counts.contain(element)) {
          counts.put(element, 1);
      } else {
          counts.put(element, counts.get(element) + 1);
      }
      input.add(element); // now it's in the back of the queue.
  }

  // convert map to queue.
  Queue<Integer> output = new Queue<>();
  for (Integer key : counts.keySet()) {
      output.add(key);
      output.add(counts.get(key));
  }
  return output;

请注意，输出将不包含相同顺序的整数...但维护顺序不是问题语句的一部分。如果是，您可以考虑使用其他数据结构来保持计数。

如何获取数字出现在队列中的次数（Java）？

2 个答案: