实现插入排序，将列表传递给其他类

Question

我昨天发布了一个版本的代码，但我认为它可以处理一些改进或其他东西。 事情又卡住了。 如您所见，IM 试图对链表进行排序并将其写回文本文件。 第一个问题是，插入类中传递什么以及如何传递？ 第二个问题是如何实现按字母顺序的插入排序？ 我见过许多插入的例子整数和数组，但我似乎仍然遇到麻烦。这是我到目前为止的进展。

编辑1：忘记那个。

编辑2：如何实现可比较并使用我的方法按字母顺序排序（比较到忽略案例）？

主要：

import java.io.* ;
import java.util.Scanner ;
public class Sort 
{
    public static void main(String[] args) throws Exception 
    {
        File outputFile ;
        Scanner kb = new Scanner (System.in) ; 
        LinkedList list = new LinkedList() ;
        String command ;
        Insertion insertion = new Insertion() ;
        // Create the new text file. If exists, it will continue to the next commands
        do
        {
            outputFile = new File("db.txt") ;
                if(!outputFile.exists())
                {
                    outputFile.createNewFile ();                    
                    System.out.println("The file was created as db.txt");
                    System.out.println("");
                }
        }while (!outputFile.exists()) ;
        // Define which file to stream in from          
        FileInputStream fileIn = new FileInputStream("db.txt") ;
        DataInputStream input = new DataInputStream (fileIn) ;
        BufferedReader br = new BufferedReader (new InputStreamReader (input)) ;
        String line ;
        try
        {               
            // Read each line of the file               
            while ((line = br.readLine()) != null)
            {
                list.add(line) ;
            }       
            input.close() ;
        }catch (Exception e){
            System.err.println("Error. Could not read the file") ;
        }
        //System.out.println (list.toString()) ;
        //Welcome message
        System.out.println("Welcome. nPlease use the following commands [-i for Insertion Sort, -s for Selection Sort, -m for Merge sort, Exit to terminate]: " );
        System. out.println ("") ;          
        command = kb.next() ;
        do
        {
            if (command.equalsIgnoreCase("-i"))
            {
                insertion.Sort(list, list.size()) ;
                //try
                //{
                    //the "true" argument sets the FileWriter to append mode so that is does not overwrite the first line
                //  BufferedWriter out = new BufferedWriter(new FileWriter("db.txt", true));
                    //out.write(textContent) ;
                    //out.newLine() ;
                    //out.close() ;
                //}catch(IOException e)
                //{
                //  System.out.println("Could not write to file") ;
                //  System.exit(0) ;
                //}
                //System.out.println ("Enter command:") ;
                //command = kb.next() ;
            }
            else if (command.equalsIgnoreCase("-s"))
            {
            }
            else if (command.equalsIgnoreCase("-m"))
            {
            }
            else if (command.equalsIgnoreCase("Exit"))
            {
                System.exit(0) ;
            }
            else 
            {
                System.out.println("Unknown command. Please use -i, -s, -m or EXIT") ;
                command = kb.next() ;
            }
        }while (!command.equalsIgnoreCase("Exit")) ;
    }
}

链接列表：

    import java.lang.* ;
public class LinkedList
{
    //reference to the head node
    public Node head ;
    public int listCount ;
    //LinkedList Constructor
    public LinkedList ()
    {
        //empty list
        head = new Node (null) ;
        listCount = 0 ;
    }
    //add element to the end of the list
    public void add(String data)
    {
        Node temp = new Node (data) ;
        Node current = head ;
        //go to the end of the list
        while (current.getNext() != null)
        {
            current = current.getNext() ;
        }
        // last nodes next reference is set to the last node
        current.setNext(temp) ;
        //increment the number of elements
        listCount++ ; 
    }
    //return the size of the list
    public int size()
    {
        return listCount ;
    }
    public String toString()
    {
        Node current = head.getNext() ;
        String output = " " ;
        while (current != null)
        {
            output += "[" + current.getData().toString() + "]" ;
            current = current.getNext() ;
        }
        return output ;
    }

}

插入：

public class Insertion 
{
    public static void Sort (LinkedList listIn, int size)
    {
        int temp, i, j ;
        for (j=1;j<size;j++)
        {
            while(listIn.head)
        }
    }
}

节点类：

    public class Node 
    {
        //reference to the next node or null if not any
        Node next ;
        //the entries
        String data ;
        //Node Constructor
        public Node (String dataIn)
        {
            next = null ;
            data = dataIn ;
        }
        //Node constructor in case of the need to point to a certain node
        public Node (String dataIn, Node nextIn)
        {
            next = nextIn;
            data = dataIn ;
        }
        public String getData ()
        {
            return data ;
        }
        public void setData (String dataIn)
        {
            data = dataIn ;
        }
        public Node getNext ()
        {
            return next ;
        }
        public void setNext (Node nextIn)
        {
            next = nextIn ;
        }
    }
}

Answer 1

插入

类中传递什么以及如何传递？

你是说方法？您应该（至少）传入完整的LinkedList（而不仅仅是头部Node）。

第二个问题是如何实现按字母顺序的插入排序？

要么采用类型实现Comparable的元素列表，要么采用单独的Comparator参数，并使用它来比较元素。然后，您可以传入一个String列表的StringComparator，Integer s等的IntComparator。您所需要的只是实现所需的比较器，这通常是微不足道的，因此您可以为所需的任何类型重用排序算法。

第一种方法更简单，它直接适用于开箱即用的String（因为String已经实现了Comparable）。但请注意，它仅限于对象类型 - 对于基元类型（如 int），您需要第二种方法。再说一次，不能让泛型集合存储基元类型的元素。

您可以在Collections中看到两种泛型sort方法的示例：

public static <T extends Comparable<? super T>> void sort(List<T> list);
public static <T> void sort(List<T> list, Comparator<? super T> c)

如果你想保持你的LinkedList是非通用的，你可以删除（大部分）通用绒毛：

public static void sort(LinkedList list);
public static void sort(LinkedList list, Comparator<? super String> c)