如何在Java中查找队列中元素的最后一次出现

Question

I am trying to find the last occurence of a particular string in a queue.I am using another queues and variables. I am stuck here though, should i use stacks or queues to solve this and how. Any help would be appreciated.

import java.util.Stack;
import java.util.Queue;
import java.util.LinkedList;

public class StackQueue{
public static void remove(Queue<String> queue, String toRemove){
    if(queue.isEmpty()){throw new NullPointerException();}

    Queue<String> tmp = new LinkedList<>();
    Queue<String> tmp1 = new LinkedList<>();
    int count = 0;

    while(! queue.isEmpty()){
        String removed = queue.remove();        
        if(toRemove == removed){
            tmp.add(removed);
            count++;
        }
        else{
            tmp1.add(removed);
        }       
    }

    while (!tmp1.isEmpty()){
        queue.add(tmp1.remove());
    }
}
public static void main(String[] args){
    Queue<String> q = new LinkedList<>();
    q.add("a");
    q.add("e");
    q.add("b");
    q.add("a");     
    q.add("e");


    System.out.println(q);
    remove(q, "a");     
    System.out.println(q);
}
 }

Answer 1

A Queue isn't a good fit for your usage, in fact the name of your class StackQueue hints that you probably want a Deque (although this may be coincidence).

The Deque (double-ended queue) interface specifies the exact method you require, removeLastOccurrence(Object o) . Essentially a Deque lets you add a remove from both ends, which also facilitates Stack behavior and so if a lot more flexible, giving you remove operations which work from both ends.

A Queue in contrast only provides removal from the front of the queue or by searching for first occurrence found in the Queue (although this can be implementation dependent since the remove(Object o) method specified in the Collection interface does not state that it has to be the first occurrence...)

The issue with a Queue for your use case is that the interface is intended to only allow queue like behavior, preventing usage of the underlying implementation without casting which would allow such a task to be performed more easily (eg LinkedList or ArrayDeque ). Casting is far from desirable for this, what if the actual implementation changed?

If you insist on using a Queue then another solution which does not requiring making another Queue would be to use the queue's Iterator and Iterator.remove() . For example:

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {

    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("a");
        queue.add("d");
        queue.add("a");
        queue.add("b");
        System.out.println("Before: " + queue);
        remove(queue, "a");
        System.out.println("After: " + queue);
    }

    public static void remove(Queue<String> queue, String toRemove){
        int indexToRemove = findLastIndex(queue, toRemove);
        removeIndex(queue, indexToRemove);
    }

    private static int findLastIndex(Queue<String> queue, String value) {
        int indexToRemove = -1;
        int index = 0;
        for (Iterator<String> iterator = queue.iterator(); iterator.hasNext(); index++) {
            String current = iterator.next();
            if (value.equals(current)) {
                indexToRemove = index;
            }
        }
        return indexToRemove;
    }

    private static void removeIndex(Queue<String> queue, int indexToRemove) {
        int index = 0;
        for (Iterator<String> iterator = queue.iterator(); iterator.hasNext() && index <= indexToRemove; index++) {
            iterator.next();
            if (index == indexToRemove) {
                iterator.remove();
            }
        }
    }
}

Answer 2

Here's one way to do it. Iterate through the queue and dump its contents into a temporary queue (like you're doing). Keep track of the last seen index of the element to remove. Lastly, iterate through the temporary queue and dump its contents back into the original queue, ignoring the item at the found index.

public static void remove(Queue<String> queue, String toRemove) {
    Queue<String> tmp = new LinkedList<>();
    int lastFoundIdx = -1;

    for (int i = 0; !queue.isEmpty(); i++) {
        String elem = queue.poll();

        if (elem.equals(toRemove)) {
            lastFoundIdx = i;
        }

        tmp.offer(elem);
    }

    for (int i = 0; !tmp.isEmpty(); i++) {
        if (i == lastFoundIdx) {
            tmp.poll();
        }
        else {
            queue.offer(tmp.poll());
        }
    }
}

Answer 3

Could not agree more to djbrown, stack is the best fit for your case. In fact there is a built in function that returns lastIndexOf an element of a stack. Below is the working example.

public static void main(String[] args) {
    Stack<String> stack = new Stack<>();
    stack.add("a");
    stack.add("e");
    stack.add("b");
    stack.add("k");
    stack.add("b");
    stack.add("c");
    stack.add("l");

    System.out.println("Original stack: " + stack);
    remove(stack, "a");
    System.out.println("Modified stack: " + stack);
  }

  private static void remove(Stack<String> stack, String toRemove) {
    int indexOfToRemove = stack.lastIndexOf(toRemove);
    if (indexOfToRemove == -1) {
      return;
    }
    Stack<String> tempStack = new Stack<>();
    int originalSize = stack.size();
    for (int i = 0; i < originalSize - indexOfToRemove - 1; i++) {
      tempStack.push(stack.pop());
    }
    stack.pop();  //Extra pop to remove the desired element
    System.out.println("Temporary stack: " + tempStack);
    while (!tempStack.empty()) {
      stack.push(tempStack.pop());
    }
  }

Output:

Original stack: [a, e, b, k, b, c, l]
Temporary stack: [l, c, b, k, b, e]
Modified stack: [e, b, k, b, c, l]

Answer 4

Use Deque. You can add/remove on both sides. deque.getLast(), deque.getFirst() will give you that what you want.