c#多点坐标怎么按进到远排列？

[qq_21238201]

比如一个数组存放很多坐标

           
 string[,] zb = new string[10,2];
            zb[0, 0] = "10";//这个是编号
            zb[0, 1] = "100,100";//这个是坐标
            zb[1, 0] = "12";
            zb[1, 1] = "56,180";
            zb[2, 0] = "5";
            zb[2, 1] = "76,55";
            zb[3, 0] = "11";
            zb[3, 1] = "87,86";
            ......

这样的一个数组 第二个下标为0的是这个坐标的编号,第二个下表为1的是这个编号的坐标

然后怎么才能得出从0,0开始 理0,0最近的坐标的编号。不用得到坐标 用坐标排序完 得到 排序好的 对应的编号。

比如返回的排序 5,11,10,12 只要返回所对应的编号就好 这样要怎么写？？？？

[qq_21238201]

比如这个图上的每个点的坐标是食物，我应该怎么走才是最近的？

坐标都保存在数组里，每个坐标有相对应的编号，但是这个编号是没有规律的随机的。要怎么计算才能通过坐标获得 吃这些食物的最近的走路方式。按编号坐标编号排序出来？？？我研究了几天了研究不出来 帮帮忙呗

[qq_21238201]

引用 2 楼 xomix 的回复:

首先，你现有的这些变量组是不合适做排序等操作的，你需要序列化他们变成以下类型（仅仅为了方便排序远近，具体对象类型你需要根据业务需求自己去定义）：

        class zb
        {
            public class piont {
                public int x { get; set; }
                public int y { get; set; }
            }
            public string id { get; set; }
        }

有了对象类型后请自行将你的对象序列化为你自己定义的新类型。 接下来我们看看怎么确定物体的坐标距离自己近。 首先自己肯定也要有个坐标，自己不在坐标系内是不可能获取这些物体距离自己的距离的，所以自己肯定也有个 piont 属性，有x和y的值。 然后物体的坐标是x1 y1，这时候物体距离自己的距离就可以使用 两点间距离公式 来确定了： 用了百度知道的图片，侵删。 接下来排序距离值就可以按距离排序了。

就是排序的算法写不来 List<double> 我对这个不是很了解呢···

[非专业开发Five]

首先，你现有的这些变量组是不合适做排序等操作的，你需要序列化他们变成以下类型（仅仅为了方便排序远近，具体对象类型你需要根据业务需求自己去定义）：

        class zb
        {
            public class piont {
                public int x { get; set; }
                public int y { get; set; }
            }
            public string id { get; set; }
        }

有了对象类型后请自行将你的对象序列化为你自己定义的新类型。 接下来我们看看怎么确定物体的坐标距离自己近。 首先自己肯定也要有个坐标，自己不在坐标系内是不可能获取这些物体距离自己的距离的，所以自己肯定也有个 piont 属性，有x和y的值。 然后物体的坐标是x1 y1，这时候物体距离自己的距离就可以使用 两点间距离公式 来确定了： 用了百度知道的图片，侵删。 接下来排序距离值就可以按距离排序了。

[zhuowp]

是的，按照楼上的算出排序字段，然后可以放到List<double>里面，调用Sort方法排序就可以了。 不过补充一点，为了提高计算速度，在这里没必要开方。

[非专业开发Five]

引用 3 楼 zhuo_wp 的回复:

是的，按照楼上的算出排序字段，然后可以放到List<double>里面，调用Sort方法排序就可以了。 不过补充一点，为了提高计算速度，在这里没必要开方。

看怎么想了，其实开放花不了多少时间，开方后回头要输出距离的时候也很简单就能输出了。

[xuzuning]

当然，如果你非要说：我就是要对多维数组排序
那也可以这样

            var a = new int[,]
            {
                {10, 100, 100},
                {12,  56, 180},
                { 5,  76,  55},
                {11,  87,  86}
            };
            a = MultiSort(a, 1, 2);
            for (var i = 0; i < a.GetLongLength(0); i++)
            {
                for (var j = 0; j < a.GetLongLength(1); j++) Console.Write("{0}\t", a[i, j]);
                Console.WriteLine();
            }

        static int[,] MultiSort(int[,] a, params int[] p)
        {
            var len = a.GetLongLength(0);
            var b = new int[len];
            for (var i = 0; i < len; i++) b[i] = i;
            for (var q = 0; q < p.Length; q++)
            {
                var k = p[q];
                for (var i = 0; i < b.Length - 1; i++)
                {
                    for (var j = 0; j < b.Length - 1 - i; j++)
                    {
                        if (a[b[j], k] > a[b[j + 1], k])
                        {
                            int c = b[j];
                            b[j] = b[j + 1];
                            b[j + 1] = c;
                        }
                    }
                }
            }
            var res = new int[len, a.GetLongLength(1)];
            for (var i = 0; i < b.Length; i++)
            {
                for (var j = 0; j < a.GetLongLength(1); j++)
                {
                    res[i, j] = a[b[i], j];
                }
            }
            return res;
        }
 

[BillChen385691631]

引用 8 楼 xuzuning 的回复:

当然，如果你非要说：我就是要对多维数组排序 那也可以这样

            var a = new int[,]
            {
                {10, 100, 100},
                {12,  56, 180},
                { 5,  76,  55},
                {11,  87,  86}
            };
            a = MultiSort(a, 1, 2);
            for (var i = 0; i < a.GetLongLength(0); i++)
            {
                for (var j = 0; j < a.GetLongLength(1); j++) Console.Write("{0}\t", a[i, j]);
                Console.WriteLine();
            }

        static int[,] MultiSort(int[,] a, params int[] p)
        {
            var len = a.GetLongLength(0);
            var b = new int[len];
            for (var i = 0; i < len; i++) b[i] = i;
            for (var q = 0; q < p.Length; q++)
            {
                var k = p[q];
                for (var i = 0; i < b.Length - 1; i++)
                {
                    for (var j = 0; j < b.Length - 1 - i; j++)
                    {
                        if (a[b[j], k] > a[b[j + 1], k])
                        {
                            int c = b[j];
                            b[j] = b[j + 1];
                            b[j + 1] = c;
                        }
                    }
                }
            }
            var res = new int[len, a.GetLongLength(1)];
            for (var i = 0; i < b.Length; i++)
            {
                for (var j = 0; j < a.GetLongLength(1); j++)
                {
                    res[i, j] = a[b[i], j];
                }
            }
            return res;
        }
 

怎么才能定义数组为字符串类型？因为编号不是数字 是比如1-2 5-4 这样的编号

[非专业开发Five]

引用 5 楼 qq_21238201 的回复:

[quote=引用 2 楼 xomix 的回复:] 首先，你现有的这些变量组是不合适做排序等操作的，你需要序列化他们变成以下类型（仅仅为了方便排序远近，具体对象类型你需要根据业务需求自己去定义）：

        class zb
        {
            public class piont {
                public int x { get; set; }
                public int y { get; set; }
            }
            public string id { get; set; }
        }

有了对象类型后请自行将你的对象序列化为你自己定义的新类型。 接下来我们看看怎么确定物体的坐标距离自己近。 首先自己肯定也要有个坐标，自己不在坐标系内是不可能获取这些物体距离自己的距离的，所以自己肯定也有个 piont 属性，有x和y的值。 然后物体的坐标是x1 y1，这时候物体距离自己的距离就可以使用 两点间距离公式 来确定了： 用了百度知道的图片，侵删。 接下来排序距离值就可以按距离排序了。

就是排序的算法写不来 List<double> 我对这个不是很了解呢···[/quote] 有现成的排序接口：

            List<double> lst = new List<double>() { 2.1, 0.2, 1.1, 9.9, 8.88, 1.11 };
            lst.Sort();

[xuzuning]

C#对二维数组未提供排序方法，要先化为一维的才可进行排序
好的数据结构，往往能得到事半功倍的效果。所以不要总是试图在一棵树上吊死

        static void Main(string[] args)
        {
            var zb = new List<dot>()
            {
                new dot(){id = 10, x = 100, y = 100},
                new dot(){id = 12, x =  56, y = 180},
                new dot(){id =  5, x=   76, y =  55},
                new dot(){id = 11, x=   87, y =  86},
            };
            //按欧氏距离排序
            var o = zb.OrderBy(t => Math.Sqrt(t.x * t.x + t.y * t.y)).ToList();
            foreach (var t in o) Console.WriteLine(t.id); 
            //按曼哈顿距离排序
            var m = zb.OrderBy(t => t.x + t.y).ToList();
            foreach (var t in m) Console.WriteLine(t.id);
            
        }
        struct dot
        {
            public int id;
            public int x;
            public int y;
        }

可以看到：用 曼哈顿距离 就足以满足要求了

[xuzuning]

数组只能保存一种类型，不要太任性了 现在虽然鼓励创新，但基本规则总是要遵守的