Tri pas une LinkedList standard

Question

J'ai un LinkedList<Individual> où Individual est une classe qui a un champ processorTime. Il est nécessaire de trier cette LinkedList (ordre décroissant) en se basant sur une fonction estimate(processorTime) qui renvoie des entiers.

S'il vous plaît, dites-moi comment puis-je faire cela?

Answer 1

Vérifiez ce guide ici:

http://leepoint.net/notes-java/data/collections/comparators.html

Citations du site:

L'interface java.util.Comparator peut être utilisé pour créer des objets pour passer à trier les méthodes ou tri des structures de données. Un comparateur doit définir une fonction de comparaison qui prend deux objets et renvoie un -1, 0 ou 1

code collé:

// File: arrays/filelist/Filelistsort.java 
// Purpose: List contents of user home directory. 
//   Demonstrates use of Comparators to sort the 
//   same array by two different criteria. 
// Author: Fred Swartz 2006-Aug-23 Public domain. 

import java.util.Arrays; 
import java.util.Comparator; 
import java.io.*; 

public class Filelistsort { 

    //======================================================= main 
    public static void main(String[] args) { 
     //... Create comparators for sorting. 
     Comparator<File> byDirThenAlpha = new DirAlphaComparator(); 
     Comparator<File> byNameLength = new NameLengthComparator(); 

     //... Create a File object for user directory. 
     File dir = new File(System.getProperty("user.home")); 
     File[] children = dir.listFiles(); 

     System.out.println("Files by directory, then alphabetical"); 
     Arrays.sort(children, byDirThenAlpha); 
     printFileNames(children); 

     System.out.println("Files by length of name (long first)"); 
     Arrays.sort(children, byNameLength); 
     printFileNames(children); 
    } 

    //============================================= printFileNames 
    private static void printFileNames(File[] fa){ 
     for (File oneEntry : fa) { 
      System.out.println(" " + oneEntry.getName()); 
     } 
    } 
} 


////////////////////////////////////////////////// DirAlphaComparator 
// To sort directories before files, then alphabetically. 
class DirAlphaComparator implements Comparator<File> { 

    // Comparator interface requires defining compare method. 
    public int compare(File filea, File fileb) { 
     //... Sort directories before files, 
     // otherwise alphabetical ignoring case. 
     if (filea.isDirectory() && !fileb.isDirectory()) { 
      return -1; 

     } else if (!filea.isDirectory() && fileb.isDirectory()) { 
      return 1; 

     } else { 
      return filea.getName().compareToIgnoreCase(fileb.getName()); 
     } 
    } 
} 


////////////////////////////////////////////////// NameLengthComparator 
// To sort by length of file/directory name (longest first). 
class NameLengthComparator implements Comparator<File> { 

    // Comparator interface requires defining compare method. 
    public int compare(File filea, File fileb) { 
     int comp = fileb.getName().length() - filea.getName().length(); 
     if (comp != 0) { 
      //... If different lengths, we're done. 
      return comp; 
     } else { 
      //... If equal lengths, sort alphabetically. 
      return filea.getName().compareToIgnoreCase(fileb.getName()); 
     } 
    } 
} 

Answer 2

Voulez-vous dire que le LinkedList n'est pas standard ou que l'ordre de tri basé sur la durée du processeur n'est pas standard?

Si ce dernier, alors tout ce que vous devez faire est d'utiliser Collections.sort(list,comparator) et fournir une implémentation appropriée de Comparator<NodeType> pour votre liste. Voir aussi "implementing compareTo()" qui donne de bons conseils connexes.

Affichez le code de votre noeud et la sortie désirée, et nous pouvons vous donner une direction plus spécifique.

Collections.sort(list,new Comparator<Individual>() { 
    @Override 
    public int compare(final Individual i1, final Individual i2) { 
    return i1.processorTime - i2.processorTime; 
    } 

    @Override 
    public boolean equals(Object foo) { 
    return false; // doesn't matter, but false is better 
    } 
}); 

Answer 3

Collections.sort(linkedList, new Comparator<Individual>() { 
    int compare(Individual i1, Individual i2) { 
     ... 
    } 
    });