How to implement Insertion Sort?

Question

Ok, my goal is to be able to sort a text file of single entry per line. Im stuck to the point where i have to create the Insertion class. How do i pass the single link list (my own implementation, not Java's) and what else do i need to pass as a parameter? Here's my code so far. P.S The reason im using my own implementation of the linked list is because i want to know how the thing works and how the various actions done using a linked list work.

Any help would be greatly appreciated.

The Main:

    import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


public class Sort
{
    public static void main(String[] args) throws Exception
    {
        Scanner kb = new Scanner (System.in) ;
        File outputFile ;
        EntriesList list = new EntriesList () ;
        String line ;
        String entry ;
        String command ;
        String textContent ;


         // Create the new text file. If exists, it will continue to the next commands
        do
        {
            outputFile = new File("Entries.txt") ;

                if(!outputFile.exists())
                {
                    outputFile.createNewFile ();                    
                    System.out.println("The file was created as Entries.txt");
                    System.out.println("");
                }

        }while (!outputFile.exists()) ;

        // Define which file to stream in from          
        FileInputStream fileIn = new FileInputStream("Entries.txt") ;
        DataInputStream input = new DataInputStream (fileIn) ;
        BufferedReader br = new BufferedReader (new InputStreamReader (input)) ;

        try
        {               
            // Read each line of the file               
            while ((line = br.readLine()) != null)
            {
                     entry = line;
                     list.insert(entry) ;
            }       
            input.close() ;
        }catch (Exception e){
            System.err.println("Error. Could not read the file") ;
        }

        //Welcome message + entry counter
        System.out.println("Welcome. \nYou about to sort " + list.count("Entries.txt") + " entries. \nPlease use the following commands [Add -add new entry, View -view entries before sorting, -i -Insertion Sort, -s -Selection Sort, -m -Merge Sort, Exit]: " );
        System. out.println ("") ;          
        command = kb.next() ;

        // User Input
        do
        {
            if (command.equalsIgnoreCase("Add"))
            {
                System.out.println("Enter String value:") ;
                entry = kb.next() ;
                textContent = entry ;
                System.out.println("Entry added successfully") ;

                try
                {
                    //the "true" argument sets the FileWriter to append mode so that is does not overwrite the first time
                    BufferedWriter out = new BufferedWriter(new FileWriter("Entries.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() ;

                list.insert(entry) ;
            }

            else if (command.equalsIgnoreCase("View"))
            {
                if (!list.isEmpty())
                {
                    list.printList();
                    System.out.println ("Enter command:") ;
                    command = kb.next() ;
                }
                else
                {
                    System.out.println("File is empty. Please enter records first.");
                    System.out.println ("Enter ADD command:") ;
                    command = kb.next();
                }
            }
            else if (command.equalsIgnoreCase("Exit"))
            {
                System.exit(0) ;
            }
            else 
            {
                System.out.println("Unknown command. Please use ADD, VIEW or EXIT") ;
                command = kb.next() ;
            }
        }while (!command.equalsIgnoreCase("Exit")) ;
    }
}

The List implementation:

    import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;


public class EntriesList 
{
    private Entries head;
    private int listCount ;

    //LinkList constructor
    public EntriesList()
    {
            head = new Entries (null) ;
            listCount = 0 ;            
    }

    //Returns true if list is empty
    public boolean isEmpty() 
    {
            return head == null;
    }

    //Inserts a new Entry at the end of the list
    public void insert(String entryIn) 
    {
            Entries temp = new Entries (entryIn) ;
            Entries current = head ;

            // Go to the end of the list
            while (current.getNext() != null)
            {
                current = current.getNext() ;
            }

            // Last Entries's next reference is set to the noew node 
            current.setNext(temp) ;
            listCount++ ;
    }

    //Return the size of the list
    public int size()
    {
        return listCount ;
    }

        //Prints list data
    public void printList()
    {
            Entries currentEntry = head;
            while(currentEntry != null)
            {
                currentEntry.printLink();
                currentEntry = currentEntry.nextEntry;
            }
            System.out.println("");
    }

 // Count the lines in the text file
    public int count(String filename) throws IOException 
    {
        InputStream is = new BufferedInputStream(new FileInputStream(filename));
        try 
        {
            byte[] c = new byte[1024] ;
            int count = 0 ;
            int readChars = 0 ;
            while ((readChars = is.read(c)) != -1) 
            {
                for (int i = 0 ; i < readChars ; ++i)
                {
                    if (c[i] == '\n')
                        ++count ;
                }
            }
            return count ;
        } finally
        {
            is.close() ;
        }
    }
}

The Entries (links) creator:

public class Entries
{
    public String entry ;
    public Entries nextEntry;

    // Empty Link Constructor
    public Entries ()
    {

    }

    //Link constructor
    public Entries(String entryIn) 
    {
        entry = entryIn ;
        nextEntry = null ;
    }

    public String getEntry () 
    {
        return entry ;
    }

    public void setEntry (String entryIn)
    {
        entry = entryIn ;
    }

    public Entries getNext () 
    {
        return nextEntry ;
    }

    public void setNext (Entries nextEntryIn)
    {
        nextEntry = nextEntryIn ;
    }

    //Print Link data
    public void printLink()
    {
            System.out.println("") ;
            System.out.print(getEntry() +"\n");
            System.out.println("") ;
    }
}

And the almighty Insertion sort class:

public class Insertion 
{
    public String Sort (EntriesList list)
    {

    }
}

Answer 1

This post appears to be asking two separate questions. So I've answered them separately.

EDIT: Just noticed a problem with your linkedlist class. You'll have to first fix this and then take a look at my answers to your questions.

Your implementation is incorrect because you're not storing a reference to the next link in the linkedlist. Entries should store a reference to the next element. I recommend reading this article.

If you look at the diagram on that page...

each link (or entry as you're calling it) has a link pointing to its neighbour.

Implementing Insertion sort

I assume you want to sort you linked list alphabetically by the entry inside of it. If this is the case you simply swap out the integer compare in insertion sorts you'll see in text books / on the web for an alphabetical comparison.

Take a look at Comparing strings by their alphabetical order it's a similar question which tells you how to do alphabetical comparisons.

I also wrote a insertion sort class in Scala for integers last night here you might find it useful.

Iterating over a LinkedList

For passing your linked list you simply pass the head link. you can then iterate through the linkedlist by calling the next element of the list.

for example..

while(link < null){
  link.next
}

Assuming linkis equal to the head of the list the above loop will continue to get the next element in the linked list on till null (which should represent the end of the list)