C# 在.NET中按距离对点列表排序

我需要按距离对点列表进行排序

比如说

input : [[1,2],[5,10],[2,4]...]
output : [[1,2],[2,4],[5,10]...]  

（假设几何上[1,2]和[2,4]最近，[2,4]和[5,10]最近

我需要它们按距离排序，即在几何图形上，点a离点b最近，点b离c最近，依此类推

有什么想法吗

编辑：代码示例

public class Point
{
   public double X {get;set;}
   public double Y {get;set;}
}


List<Point> points = new List<Point>();

所以我的问题是如何做到这一点

注意：此处不允许更改图表控件

谢谢

我想你想要这个，.有一个c#项目

下面是该链接中未修改的代码

class Dijkstra
    {        
        private int rank = 0;
        private int[,] L;
        private int[] C; 
        public int[] D;
        private int trank = 0;
        public Dijkstra(int paramRank,int [,]paramArray)
        {
            L = new int[paramRank, paramRank];
            C = new int[paramRank];
            D = new int[paramRank];
            rank = paramRank;
            for (int i = 0; i < rank; i++)
            {
                for (int j = 0; j < rank; j++) {
                    L[i, j] = paramArray[i, j];
                }
            }

            for (int i = 0; i < rank; i++)
            {
                C[i] = i;
            }
            C[0] = -1;          
            for (int i = 1; i < rank; i++)
                D[i] = L[0, i];
        }
        public void DijkstraSolving()
        {            
            int minValue = Int32.MaxValue;
            int minNode = 0;
            for (int i = 0; i < rank; i++)
            {
                if (C[i] == -1)
                    continue;
                if (D[i] > 0 && D[i] < minValue)
                {
                    minValue = D[i];
                    minNode = i;
                }
            }
            C[minNode] = -1;
            for (int i = 0; i < rank; i++)
            { 
                if (L[minNode, i] < 0)
                    continue;
                if (D[i] < 0) {
                    D[i] = minValue + L[minNode, i];
                    continue;
                }
                if ((D[minNode] + L[minNode, i]) < D[i])
                    D[i] = minValue+ L[minNode, i];
            }
        }
        public void Run()
        {
            for (trank = 1; trank >rank; trank++)
            {
                DijkstraSolving();
                Console.WriteLine("iteration" + trank);
                for (int i = 0; i < rank; i++)
                    Console.Write(D[i] + " ");
                Console.WriteLine("");
                for (int i = 0; i < rank; i++)
                    Console.Write(C[i] + " ");
                Console.WriteLine("");                
            }
        }
 }

Dijkstra类
{        
私有整数秩=0；
私有int[，]L；
私有int[]C；
公共int[]D；
私有int-trank=0；
公共Dijkstra（int-paramRank，int[，]paramArray）
{
L=新整数[paramRank，paramRank]；
C=新整数[paramRank]；
D=新的整数[paramRank]；
秩=准秩；
for（int i=0；i0&&D[i]rank；trank++）
{
dijkstra（）；
Console.WriteLine（“迭代”+trank）；
for（int i=0；i

我想你想要这个。有一个c#项目

下面是该链接中未修改的代码

class Dijkstra
    {        
        private int rank = 0;
        private int[,] L;
        private int[] C; 
        public int[] D;
        private int trank = 0;
        public Dijkstra(int paramRank,int [,]paramArray)
        {
            L = new int[paramRank, paramRank];
            C = new int[paramRank];
            D = new int[paramRank];
            rank = paramRank;
            for (int i = 0; i < rank; i++)
            {
                for (int j = 0; j < rank; j++) {
                    L[i, j] = paramArray[i, j];
                }
            }

            for (int i = 0; i < rank; i++)
            {
                C[i] = i;
            }
            C[0] = -1;          
            for (int i = 1; i < rank; i++)
                D[i] = L[0, i];
        }
        public void DijkstraSolving()
        {            
            int minValue = Int32.MaxValue;
            int minNode = 0;
            for (int i = 0; i < rank; i++)
            {
                if (C[i] == -1)
                    continue;
                if (D[i] > 0 && D[i] < minValue)
                {
                    minValue = D[i];
                    minNode = i;
                }
            }
            C[minNode] = -1;
            for (int i = 0; i < rank; i++)
            { 
                if (L[minNode, i] < 0)
                    continue;
                if (D[i] < 0) {
                    D[i] = minValue + L[minNode, i];
                    continue;
                }
                if ((D[minNode] + L[minNode, i]) < D[i])
                    D[i] = minValue+ L[minNode, i];
            }
        }
        public void Run()
        {
            for (trank = 1; trank >rank; trank++)
            {
                DijkstraSolving();
                Console.WriteLine("iteration" + trank);
                for (int i = 0; i < rank; i++)
                    Console.Write(D[i] + " ");
                Console.WriteLine("");
                for (int i = 0; i < rank; i++)
                    Console.Write(C[i] + " ");
                Console.WriteLine("");                
            }
        }
 }

Dijkstra类
{        
私有整数秩=0；
私有int[，]L；
私有int[]C；
公共int[]D；
私有int-trank=0；
公共Dijkstra（int-paramRank，int[，]paramArray）
{
L=新整数[paramRank，paramRank]；
C=新整数[paramRank]；
D=新的整数[paramRank]；
秩=准秩；
for（int i=0；i0&&D[i]rank；trank++）
{
dijkstra（）；
Console.WriteLine（“迭代”+trank）；
for（int i=0；i

在图形中，一组点

（x1，y1），（x2，y2），（x3，y3）…（xn，yn）

应按任意一个坐标值排序，因为它不是按顺序排列的最接近的点，而是具有最接近的x或y坐标值（以哪个轴为基准）的点。因此，用于制图的数组应为：

var orderedPoints=points.OrderBy(p=>p.X);

---

在上图中，直线L1的长度大于L2。但点P2而非P3应位于P1之后，因为在图形中，一组点

（x1，y1）、（x2，y2）、（x3，y3）…（xn，yn）

应根据任意一个坐标的值进行排序，因为它不是顺序中的下一个最近点，而是具有最近x或y坐标值（以哪个轴为基准）的点。因此，用于绘制图表的数组应为：

var orderedPoints=points.OrderBy(p=>p.X);

在上图中，直线L1的长度大于L2。但是点P2而不是P3应该

Function SortByDistance(ByVal lst As List(Of Point)) As List(Of Point)
    Dim out As New List(Of Point)
    out.Add(lst(NearestPoint(New Point(0, 0), lst)))
    lst.Remove(out(0))
    Dim x As Integer = 0
    For i As Integer = 0 To lst.Count - 1 + x
        out.Add(lst(NearestPoint(out(out.Count - 1), lst)))
        lst.Remove(out(out.Count - 1))
        x += 1
    Next
    Return out
End Function

Function NearestPoint(ByVal srcPt As Point, ByVal lookIn As List(Of Point)) As Integer
    Dim smallestDistance As KeyValuePair(Of Double, Integer)
    For i As Integer = 0 To lookIn.Count - 1
        Dim distance As Double = Math.Sqrt(Math.Pow(srcPt.X - lookIn(i).X, 2) + Math.Pow(srcPt.Y - lookIn(i).Y, 2))
        If i = 0 Then
            smallestDistance = New KeyValuePair(Of Double, Integer)(distance, i)
        Else
            If distance < smallestDistance.Key Then
                smallestDistance = New KeyValuePair(Of Double, Integer)(distance, i)
            End If
        End If
    Next
    Return smallestDistance.Value
End Function