在列表上实现排序算法<string>

Question

I have created some sorting algorithms inside CustomDataList class:

public void SortStudents() //sorts students alphabetically
    {
        string temp;
        for (int i = 0; i < students.Count; i++)
        {
            for (int j = i + 1; j < students.Count; j++)
            {
                if (string.Compare(students[i], students[j]) > 0)
                {
                    temp = students[j];
                    students[j] = students[i];
                    students[i] = temp;
                }
            }
            Console.WriteLine(students[i]);
        }
    }


    public string GetMaxElement()
    {
        string tempMax = null;
        foreach (string element in students)
        {
            if (tempMax == null || string.Compare(tempMax, element) > 0)
            {
                tempMax = element;
            }
        }
        return tempMax;
    }

    public string GetMinElement()
    {
        string tempMin = null;
        foreach (string element in students)
        {
            if (tempMin == null || string.Compare(tempMin, element) < 0)
            {
                tempMin = element;
            }
        }
        return tempMin;
    }
}

And the following code inside the Main() method:

CustomDataList customDataList = new CustomDataList();
        //Add(element)
        customDataList.AddStudent("Jenny");
        customDataList.AddStudent("Loren");
        customDataList.AddStudent("Martin");
        customDataList.AddStudent("Hannah");
        customDataList.AddStudent("Joules");
        customDataList.AddStudent("Daniel");
        customDataList.AddStudent("Andy");
        customDataList.AddStudent("Emilio");
        customDataList.AddStudent("Ariana");
        customDataList.AddStudent("Nikkita");

This code works fine, but now I need to add other sorting algorithms (for example algorithms that sort the list based on the length of the name) similar to SortStudents() method (without using .Sort() method).

I would appreciate it if you could suggest other kind of sorting and some hints about how to create that sorting algorithm.

Answer 1

If you are not obliged to use regular array operations, I suggest you to use linq

var result = customDataList.OrderBy(x => x.Length)

and for sorting by name

var result = customDataList.OrderBy(x => x);

If you need to use array sort algorithm, replace

if (string.Compare(students[i], students[j]) > 0)

With

if (students[i].Length < students[j].Length)

Answer 2

You can make it more object oriented. Declare a student class like this:

public class Student : IComparable<Student>
{
    public int ID {get;set;}
    public string Name {get;set;}

    public int CompareTo(Student other)
    {
        return string.Compare(Name, other.Name);
    }
}

Now,

List<Student> customDataList = new List<Student>();

customDataList.AddStudent("Jenny");
customDataList.AddStudent("Loren");
customDataList.AddStudent("Martin");
customDataList.AddStudent("Hannah");
customDataList.AddStudent("Joules");
customDataList.AddStudent("Daniel");
customDataList.AddStudent("Andy");
customDataList.AddStudent("Emilio");
customDataList.AddStudent("Ariana");
customDataList.AddStudent("Nikkita");

customDataList.Sort();  // sorts by name. default sorting

To implement multiple sorting, you can do this: implement an IComparer interface:

public class NameLengthComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

then call like

NameLengthComparer nc = new NameLengthComparer();
customDataList.Sort(nc);  // sorts by length of Name

Reference: https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.sort?redirectedfrom=MSDN&view=netframework-4.7.2#System_Collections_Generic_List_1_Sort_System_Collections_Generic_IComparer__0__

Answer 3

If you build a solid enterprise application, and want to support many types of objects / sorting algorithms / comparison logic, then you need to consider proper object-oriented IComparable , as suggested by other answers. You may also want to wrap your sorting algorithm into an abstract interface.

However, if you are just experimenting, as a point of view, there is a more functional way to implement it and it may look more natural for some developers, for example for JavaScript developers.

You can pass a Func as a high-order function which will be responsible for the logic of comparing objects. It is much shorter and lets you reuse your sorting algorithm with any kind of comparison logic without implementing monstrous synthetic comparer classes.

public void SortStudents(Func<string, string, int> compareFunction) 
{
    string temp;
    for (int i = 0; i < students.Count; i++)
    {
        for (int j = i + 1; j < students.Count; j++)
        {
            if (compareFunction(students[i], students[j]) > 0)
            {
                temp = students[j];
                students[j] = students[i];
                students[i] = temp;
            }
        }
        Console.WriteLine(students[i]);
    }
}

SortStudents(string.Compare); // sorts students alphabetically
SortStudents((a, b) => a.Length.CompareTo(b.Length)); // sorts students by the length of their names

You can then reuse this Func in any other algorithms involving comparison:

public string GetMaxElement(Func<string, string, int> compareFunction)   
{
    string tempMax = null;

    foreach (string element in students)
    {
        if (tempMax == null || compareFunction(tempMax, element) > 0)
        {
            tempMax = element;
        }
    }

    return tempMax;
}

Answer 4

You can use IComparer interface

public void SortStudents(IComparer<string> comparer) // sort students using bubble sort
{
    string temp;
    for (int i = 0; i < students.Count; i++)
    {
        for (int j = i + 1; j < students.Count; j++)
        {
            if (comparer.Compare(students[i], students[j]) > 0) // use given comparer instead.
            {
                temp = students[j];
                students[j] = students[i];
                students[i] = temp;
            }
        }
        Console.WriteLine(students[i]);
    }
}

And sort like

//sorts students alphabetically
customDataList.SortStudents(Comparer<string>.Create((a, b) => string.Compare(a, b)));

//sorts students by length
customDataList.SortStudents(Comparer<string>.Create((a, b) => a.Length.CompareTo(b.Length)));

Basically, you are using the same sorting algorithm, same code but with different comparison logic provided by IComparer interface.

This technique is called "Dependency Injection". in this case is type of a method injection.