Come ottenere una coda inversa

[tulipan]

Il problema che sottopongo all'attenzione di questo forum è il seguente:

Restituire una nuova coda, che contiene i valori
della coda passata per argomento, ma in ordine inverso.
La coda originale non deve essere modificata.



Ho provato a realizzare il seguente codice sorgente ma, se pur non ci sono problemi a compile time, a run- time non ottengo niente, nel senso che non viene stampato nessun risultato.
Riporto qui il codice che ho scritto:

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
    * Restituireunanuovacoda, checontiene i valori
    * dellacodapassata per argomento, ma in ordineinverso. 
    * Lacodaoriginale non deveesseremodificata. 
    */
public class ReverseQ {


    public static Queue<Integer> reverse( Queue<Integer> input ) {
        
        if (input == null)
              throw new IllegalArgumentException("La coda deve essere inizializzata");
        Integer[] arr=new Integer[input.size()];
        Queue<Integer> qAux=new LinkedList<Integer>();
          
        int i=0;
        while ( ! input.isEmpty( )) {
                 Integer tmp=input.peek();
            
                 arr[i]=tmp;
            
        }
                
        for(int j=arr.length-1;j>=0;i-- ) {
            qAux.add(arr[j]);
        }
        
        
        
        return qAux;
    
    }
} 

Perché?
tulipan

[andbin]

Ho provato a realizzare il seguente codice sorgente ma, se pur non ci sono problemi a compile time, a run- time non ottengo niente, nel senso che non viene stampato nessun risultato.

La prima questione è che hai usato peek. Il peek "guarda" solo il valore in testa ma NON lo rimuove. Quindi, in sostanza, con quel while non stai affatto andando avanti.
La richiesta comunque è molto chiara sul fatto che la coda originale non debba essere modificata. Pertanto non puoi togliergli elementi, nemmeno con il poll (o remove). In pratica puoi solo iterare sulla coda input, con il for-each o con l'Iterator esplicito.

Poi comunque hai pure usato un array, che è di "troppo". In realtà è molto più semplice di quanto pensi. LinkedList è-una Queue, quindi ti basta solo creare 1 LinkedList. In un LinkedList è facile/efficiente aggiungere in testa e in coda. Se aggiungi in coda, replichi lo stesso ordine della Queue originale. Basta inserire dal lato opposto .....

[tulipan]

Grazie, non ci ero arrivato

[tulipan]

Alla luce di quanto mi è stato detto ho realizzato il seguente metodo:

public class ReverseQ {


    public static LinkedList<Integer> reverse( Queue<Integer> qAux2 ) {
    	System.out.println("sono entrato nel metodo reverse()");
    	if (qAux2 == null)
    	      throw new IllegalArgumentException("La coda deve essere inizializzata");
    	
    	System.out.println("sono dopo IF");
    	
    	LinkedList<Integer> qAux=new LinkedList<Integer>();
    	System.out.println(qAux2.size());  
    	for (int i = 0; i < qAux2.size(); i++) {
    		
    		System.out.println("sono entrato nel FOR");
    		
    		if(qAux2.isEmpty()) {
    			qAux.add(i);
    		}else {
    			System.out.println("sono entrato nel else ");
    			qAux.addFirst(i);
    		}
    	}
    	for(Integer elem : qAux)
    	     System.out.println("qAux: "+elem);
    	return qAux;
    
    }
} 

In pratica, mi sono creato un Main in cui ho creato una coda ed inserito degli interi. Poi ho richiamato il metodo reverse() passandogli la coda appena creata, ma stranamente effettuando il debug del codice ho notato che la coda nel metodo reverse() ha dimensione zero. Non mi è chiaro il perché.

[andbin]

A parte i println di log che sono ok, non è quello il punto, purtroppo non ci siamo ancora. Innanzitutto non serve usare un indice, anche perché una Queue non è indirizzabile per indice. Poi oltretutto hai fatto add(i) e addFirst(i) ma così non ha senso, perché inserisci il numero dell'indice (0, 1, 2 .....), non il valore a quella posizione.

Ripeto: è sufficiente il enhanced for ("for-each") o un Iterator esplicito e poi inserire (sempre) in testa. Non serve nemmeno isEmpty().

Ah, poi il metodo sarebbe più corretto come hai scritto all'inizio, cioè che ritorna un Queue.

public static Queue<Integer> reverse( Queue<Integer> input )


P.S. me ne sono dimenticato prima ma aggiungo: per cortesia non postare codice "colorato", perché è difficile da quotare.