Question

The question is this:

You need to sort a queue in a new member method void sort() you add to the queue.

The rules are:

• You can not use any loops. Only recursion is allowed.
• You can create as many private methods as you wish.
• You may create and use two auxiliary queues of the same kind (call it Queue – has a default constructor).
• You don’t know anything about the internal structure of the queue.
• The only methods given to you are: bool empty(), Data peek(), Data dequeue(), void enqueue(Data d)
• dequeue() returns null if the list is empty, enqueue() ignores null inputs.
• The sorting order needs to be ascending (front of queue should have the smallest value).
• The comparable value is in integer inside the Data structure, called x.

I know it can be solved. I have yet to find an answer for this. Any ideas would be appreciated.

Answer 1

First of all, thanks for the answers. They pointed me to the right solution. I voted them up to give credit, but since I managed to solve this question, I’ll accept my own answer (at least until a better one comes).

So first of all, the homework was about “Taxies” (you know how homework is…) and a TaxiQueue, in Java.

The solution was:

public void sort() {
    sort(this);
}

private void sort(TaxiQueue toSort) {
    // Prepare split parts for later merging   
    TaxiQueue m1 = new TaxiQueue(), m2 = new TaxiQueue();

    // Return if there's only 1 element in the queue
    // since it's essentially "sorted".
    if(singleItem(toSort))
        return;

    // Split toSort into 2 parts
    split(toSort, m1, m2);
    // Sort each part recursively (by splitting and merging)
    sort(m1);
    sort(m2);
    // Merge each part into 1 sorted queue
    merge(toSort,  m1, m2);
}

private boolean singleItem(TaxiQueue tq) {
    Taxi temp = tq.dequeue();
    boolean retVal = tq.empty();
    tq.enqueue(temp);
    return retVal;
}

private void merge(TaxiQueue toSort, TaxiQueue m1, TaxiQueue m2) {
    // Notice that m1 and m2 are already sorted, and now we need
    // to merge them.
    // In the case that one of them is empty and the other one isn't,
    // simply append all remaining "higher" values into toSort.
    if(m1.empty()) {
        appendQueue(m2, toSort);
        return;
    }
    else if (m2.empty()) {
        appendQueue(m1, toSort);
        return;
    }
    // The critical comparison part...
    if(m1.peek().getId() < m2.peek().getId())
        toSort.enqueue(m1.dequeue());
    else
        toSort.enqueue(m2.dequeue());
    // Continue merging elements into toSort.
    merge(toSort, m1, m2);
}

// Split toSort into m1 and m2 as equally as possible
private void split(TaxiQueue toSort, TaxiQueue m1, TaxiQueue m2) {
    if(toSort.empty())
        return;
    m1.enqueue(toSort.dequeue());
    split(toSort,  m2, m1);
}

// Enqueue everything in src to dest.
private void appendQueue(TaxiQueue src, TaxiQueue dest) {
    if (src.empty())
        return;
    dest.enqueue(src.dequeue());
    appendQueue(src, dest);
}

I hope that other students may find it useful some day!