using System;

using System.Collections.Generic;

public class Program

{

    //I seem to have forgotten about you, old chap.  Sorry about that.  Maybe I'll come back to ya, and make you proper.

    //The class SortUtility should be an encapsulated beast.  It should give you want you need to spit out the sorted numbers, and whatever.

    //Right now, I'm mish-mashing about.

    //It's all polly-woggle if you ask me.

    public static void Main()

    {

        Console.WriteLine("Hello World");

        //I could have saved myself a lot of trouble by never using that generic collection.  Maybe?  For consideration.

        int[] values = {9, 3, 5, 8, 20, 300, 2, 2, 0, -32, 32};

        List<int> testValuesToSort = new List<int>(values);

        SortUtility test1 = new SortUtility(testValuesToSort, ESortMethods.Bubble);

        Console.WriteLine("Goodbye.");

    }

}

​

public enum ESortMethods {None, Bubble, Insert, Select, Shell, Merge, Heap, Quick, Quick3}

​

public class SortUtility

{

    private List<int> inputList;  //Maybe this should be a reference to the unchanged list?  We would have to create a copy.

    private List<int> outputList;

    public delegate List<int> Sorter (List<int> listToSort);

    Sorter sortHandler;

    //START OF METHODS FOR THE Sorter DELEGATE.

    //Method used for the default case.  To make it clear what would happen if you don't provide a sortMethod.

    private List<int> noSort (List<int> listToSort) {return listToSort;}

    private List<int> bubbleSort (List<int> listToSort)

    {

        /*

            The bubble sort algorithm - it is very simple, however can be very inefficent.

            In large, very disorganized collections, it could take a prohibitively long time to run.

            However, it's fine for small lists of things.

        */

        int[] intList = listToSort.ToArray();

        /*

        HOW DOES A BUBBLE SORT WORK?

        If we interate through the list without having to do a swap, then we've gotten a clean pass through.  

        If we've passed through the entire list, without having to do a swap, then the list is sorted.

        If the list is sorted, then we are finished, and can return the generated list.

        */

        bool cleanPassThrough;

        do

        {

            cleanPassThrough = true;  //Default this to true.  We assume the list is sorted, unless we find otherwise.

            //POSSIBLE BUG HERE:  If we never enter the FOR statement (maybe because the array to sort is too small?), then we could get a false result.

            //  SYNTAX --- FOR LOOPS

            //      for (initializer; booleanCondition.loopWhileTrue; iterator){ <LOOP BODY> }

            //      //NOTE THE LACK OF A SEMI-COLON AFTER THE ITERATOR CLAUSE.

            //  NOTE:   No special iterator command is needed.  It iterates at the end of the block.  

            //  C# KEYWORDS FOR SPECIFIC TO LOOPS AND SWITCH STATEMENTS:

            //      continue; //this will cause it to jump to the next iteration, without running the rest of the code.

            //      break;  //this will break out of the loop.

​

            /*

                A consideration when looping with arrays:  Array length, vs a zero-indexed array.

                Arrays in C# are zero-based; the first element in an array has an index of ZERO.

                    int[] myArray = { 5, 8, 20, 3};

                    //  myArray[0] is equal to 5.

                    //  myArray[1] is equal to 8.

            */

            /*NOTE:  The condition for continuing to loop is:

                iterator < intList.Length - 1;

            Why?  Because we compare an item, with the item that comes AFTER it.

            There is no item AFTER the last item in the list.  So we need to stop looping through the list, one item before the end of the collection.

            */

            for ( int iterator = 0; iterator < intList.Length - 1; iterator++ ) 

            { 

                int itemA = intList[iterator];

                int itemB = intList[iterator + 1];

                if (itemA > itemB) 

                {   

                    //Here, we swap the two items.

                    cleanPassThrough = false;  //If you've entered this block, then there will be at least one more run through.  (This is inefficent, but hey, welcome to bubble sort.)

                    int tempHoldingSpot = itemA;

                    itemA = itemB;

                    itemB = tempHoldingSpot;

                    //Do I want to write some stuff to the console, to explain what switches are happening?  It COULD be interesting to see.  But only if it is formatted to make it paletable.

                    intList[iterator] = itemA;

                    intList[iterator + 1] = itemB;

                }

            }

        } while (cleanPassThrough == false);

        Console.WriteLine("Within the BubbleSort() method, the readout of intList:");

        foreach (int intItem in intList)

        {

            Console.Write(intItem.ToString());

            Console.Write("  ---  ");

        } Console.WriteLine("");

        return new List<int>(intList);

    }

    //END OF METHODS FOR THE Sorter DELEGATE.

    //CONSTRUCTOR

    public SortUtility(List<int> input, ESortMethods sortMethod)

    {

        inputList = new List<int>(input);  //Create a copy of the list as received so that we can reference it as needed.

        inputList = input;  // ????? 

        switch (sortMethod)

        {

            case ESortMethods.Bubble:

                sortHandler = bubbleSort;

                break;

            case ESortMethods.None:  //Intentionally left blank - control will fall through to default case.

            default:

                sortHandler = noSort;

                break;

        }

        Console.WriteLine("Before sort:  ");

        foreach (int intItem in inputList)

        {

            Console.Write(intItem.ToString());

            Console.Write("  ---  ");

        }   Console.WriteLine("");

        sortHandler(inputList);

        /*

            This whole bit about 

                value types versus reference types, 

                passing by value versus passing by reference, 

                and when you don't specify in the code what to do, what is the default?

            When I called the method...

                sortHandler(inputList);

            ...that method takes as parameters.

            ...

            ...

            ...

            Nevermind.  I shot myself in the foot, I did.  I was trying to be all fancy, and then I got myself caught with my pants down.

            I speficially made a copy of the original unsorted list, so I could print them all out at any time (or pull them back as actual data, if we add permanence to this class).

            The variable inputList is a List<int> ... and that is DEFINITELY a reference type.  However, that isn't what I passed to the method.

            ...

            ...

            ...

            No wait.  It is.  I didn't mean to.  But I did.

        */

        Console.WriteLine("After sort:");

        foreach (int intItem in inputList)

        {

            Console.Write(intItem.ToString());

            Console.Write("  ---  ");

        }   Console.WriteLine("");

    }

}