Question

Sort a queue in java with generic type, below is my approach which has some issues. The porpose is to implement a method to sort the elements of the queue in ascending order, but I am not sure how to deal with generic type T instead of int or string. Need your help to solve this problem. Please post the correct code and the idea, thanks!

public static <T extends Comparable<T>> int minval(Queue<T> queue, int sort) { int min_index = -1; int size = queue.size(); T min_value; for (int i = 0; i < size; i++) { min_value = queue.peek(); queue.poll(); if (i > 0) { I current = queue.peek(); if (current.compareTo(min_value) <= 0 && i <= sort) { min_index = i; min_value = current; queue.add(current); return min_index; public static <T extends Comparable<T>> void insertion (Queue<T> queue, int min_index) { T min_value = null; int size = queue.size(); for (int i = 0; i < size; i++) { I current = queue.peek(); queue.poll(); if (i != min_index) { queue.add(current); } else { min_value = current; queue.add(min_value);

Answer 1

queue.add(queue.poll(); ** Ek <terminated> Queue Sorting (Java Application) C:\Pro Unsorted size: 7 [10, 60, 30, 20, 50, 40, 70] queue.add(maxValue); for(int i=0; i<(size - unsortedSize); i++) { queue.add(queue.poll()); Unsorted size: 6 [10, 30, 20, 50, 40, 60, 70] Unsorted size: 5 [10, 30, 20, 40, 50, 60, 70] public static <T extends Comparable<T>> void sortQueue (Queue<T> queue) { Unsorted size: 4 [10, 30, 20, 40, 50, 60, 70] int unsortedSize = queue.size(); while(unsortedSize >= 1) { Unsorted size: 3 [10, 20, 30, 40, 50, 60, 70] int maxIndex = maxVal(queue, unsortedSize); insertion(queue, maxIndex, unsortedSize); Unsorted size: 2 [10, 20, 30, 40, 50, 60, 70] System.out.println("Unsorted size: " + unsortedSize); System.out.println(queue); System.out.println(); unsortedSize--; Unsorted size: 1 [10, 20, 30, 40, 50, 60, 70] } public static void main(String[] args) { Queue<Integer> q = new LinkedList<Integer>(); q.add(10); 9.add(60); 9.add(30); q.add(20); 9.add(70); 9.add(50); q.add(40); sortQueue (9);

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

public class QueueSorting {
        
        // Find the minElement index from (0 to unsortedSize) fraction
        public static <T extends Comparable<T>> int maxVal(Queue<T> queue, int unsortedSize) {
                int maxIndex = 0;
                T maxVal = queue.peek();
                int size = queue.size();
                
                for(int i=0; i<size; i++) {
                        
                        // remove the element and add it back to other end
                        T x = queue.poll();
                        queue.add(x);
                        
                        if(unsortedSize > i && x.compareTo(maxVal) > 0) {
                                maxIndex = i;
                                maxVal = x;
                        }
                }

                return maxIndex;
        }

        public static <T extends Comparable<T>> void insertion(Queue<T> queue, int maxIndex, int unsortedSize) {

                int size = queue.size();
                
                T maxValue = null;
                
                for(int i=0; i<unsortedSize; i++) {
                        if(i == maxIndex) {
                                maxValue = queue.poll();
                        } else {
                                queue.add(queue.poll());
                        }
                }
                
                queue.add(maxValue);
                
                for(int i=0; i<(size - unsortedSize); i++) {
                        queue.add(queue.poll());
                }
        }

        public static <T extends Comparable<T>> void sortQueue(Queue<T> queue) {
                
                int unsortedSize = queue.size();
                
                while(unsortedSize >= 1) {
                        
                        int maxIndex = maxVal(queue, unsortedSize);
                        insertion(queue, maxIndex, unsortedSize);
                        
                        System.out.println("Unsorted size: " + unsortedSize);
                        System.out.println(queue);
                        System.out.println();
                        unsortedSize--;
                }

        }

        public static void main(String[] args) {
                Queue<Integer> q = new LinkedList<Integer>();
                q.add(10);
                q.add(60);
                q.add(30);
                q.add(20);
                q.add(70);
                q.add(50);
                q.add(40);
                
                sortQueue(q);
        }

}

Please upvote, as i have given the exact answer as asked in question. Still in case of any issues in code, let me know in comments. Thanks!