C# sorting objects with out-of object parameters

Question

4.00/5 (1 vote)

See more:

I need to sort a list of x,y points based on distance to a given x,y point. How to do this in C#?

I noticed that the C# standard IComparable interface based sort algorithm does not work because the CompareTo function compares one x,y point to another and there is no way to give access to the third point needed to calculate the distance.

Is there some other C# sorting library that can do this?

I also found this, but I'm not quite sure how it works:

C#

public Comparison<T> MakeComparison<T>(object extraParameter)
{
    return
        delegate(T x, T y)
        {
            // do comparison with x, y and extraParameter
        }
}

Posted 8-May-11 0:10am

ukram2

Updated 8-May-11 0:31am

v5

Add a Solution

4 solutions

Solution 1

It's a bit simpler than that!
This example sorts a list of Points by looking only at the X distance:

        List<Point> p = new List<Point>();
        ... // Fill p with Points!
        p.Sort(new PointComparer());
        ...
public class PointComparer : IComparer<Point>
    {
    #region IComparer<Point> Members
    public int Compare(Point x, Point y)
        {
        return x.X - y.X;
        }
    #endregion
    }

[edit]Damnit! Caught by the HTML tags again! - OriginalGriff[/edit]

[edit2]"point" changed to "Point" :O - OriginalGriff[/edit2]

Posted 8-May-11 0:44am

OriginalGriff

Updated 8-May-11 1:04am

v3

Comments

yesotaso 8-May-11 6:52am

My 5. If point is your custom type see my solution.

OriginalGriff 8-May-11 7:05am

Oops! :O

ukram2 8-May-11 13:44pm

This one seems to be right also. It's a bit funny that my solution worked without any interface definition...

Solution 2

see if this alternate can help..

C#

class Program
   {
       public class User
       {
           public string Name;
           public int Age;

           public User(string name, int age)
           {
               this.Name = name;
               this.Age = age;
           }
       }

       static void Main(string[] args)
       {
           // array of custom type
           User[] users = new User[3] { new User("Betty", 23),  // name, age
                            new User("Susan", 20),
                            new User("Lisa", 25) };
           //The distance property
           int customVariable = 10;
           Array.Sort(users, delegate(User user1, User user2)
           {
               //the customVariable is accessable here
               int theCustomVariable = customVariable;
               //Write your logic here to compare it using customVariable
               return user1.Age.CompareTo(user2.Age);
           });
           // write array output
           foreach (User user in users) Console.Write(user.Name + user.Age + " ");
       }
   }

i'll for exact solution meanwhile :)

Thanks,
Hemant

Posted 8-May-11 0:52am

Hemant__Sharma

Solution 3

An alternative if "point" is your custom type.

C#

public class point: IComparable<point>
{
    // do your stuff
    public int CompareTo(point obj)
    {
        // Replace X with your distance stuff (however you compute it).
        return this.X.CompareTo(obj.X);
    }
}</point>

This way you can call sort without any parameters.

Posted 8-May-11 1:01am

yesotaso

Updated 8-May-11 1:03am

v3

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

ukram2 · Accepted Answer · 2011-05-08T02:18:00

Ok, found a solution that looks more or less ok to me. I used another class, point_sorter to hold the third point and defined a Comparison<T> Delegate compatible function there to compare the two points.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace point
{
    class point
    {
        public double x;
        public double y;
        public point(double px, double py)
        {
            x = px;
            y = py;
        }
    }
    class Program
    {
        class point_sorter
        {
            point p3;
            public point_sorter(point p_p3)
            {
                p3 = p_p3;
            }
            public int compare_points(point p1, point p2)
            {
                double distance_this = (p3.x - p1.x) * (p3.x - p1.x) + (p3.y - p1.y) * (p3.y - p1.y);
                double distance_other = (p3.x - p2.x) * (p3.x - p2.x) + (p3.y - p2.y) * (p3.y - p2.y);
                return distance_this.CompareTo(distance_other);
            }
        }
        static void Main(string[] args)
        {
            List<point> point_list = new List<point>();
            point_list.Add(new point(1, 2));
            point_list.Add(new point(3, 4));
            point_list.Add(new point(5, 5));
            point p3 = new point(6, 6);
            point_sorter ps = new point_sorter(p3);
            point_list.Sort(ps.compare_points);
        }
    }
}