C# 区间合并（Linq To Sql)

来源：互联网发布：https 隐藏index.php 编辑：程序博客网时间：2024/06/12 01:22

一、项目问题

C#的list<point>类型中存入了很多区间类似于（a--b)，Point.x存入的是开始位置，Point.Y存入的是结束位置。list<point>中存入了很多这样的

点，例如1--4,3---8,9--20,17--25。

而目前的问题是要把这些重合的区间从新合并成多个区间，例如上边四个区间应该合并为：1--8和9--25 。最后的list<point>类型中应该没有再重复的区间。

二、LInq方面的解决方案（一高手提供）

[csharp] view plaincopyprint?
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace ConsoleApplication1  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            List<Point> data = new List<Point>()  
            {  
                new Point() { X = 1, Y = 4 },  
                new Point() { X = 3, Y = 8 },  
                new Point() { X = 9, Y = 20 },  
                new Point() { X = 17, Y = 25 }  
            };  
            data.ForEach(x =>  
            {  
                if (data.Where(y => y != x).Any(y => y.X <= x.Y && y.Y >= x.X))  
                {  
                    var desc = data.Where(y => y != x).First(y => y.X <= x.Y && y.Y >= x.X);//返回除自己以外的满足条件的区间  
                    x.X = desc.X > x.X ? x.X : desc.X;  
                    x.Y = desc.Y > x.Y ? desc.Y : x.Y;  
                }  
            });  
            data = data.GroupBy(x => new { x.X, x.Y }).Select(x => new Point() { X = x.Key.X, Y = x.Key.Y }).ToList();//合并list<point>中重复的区间  
            foreach (var item in data)  
            {  
                Console.WriteLine(item);  
            }  
        }  
    }  
    class Point  
    {  
        public int X { get; set; }  
        public int Y { get; set; }  
        public override string ToString()  
        {  
            return string.Format("X = {0}, Y = {1}.", X, Y);  
        }  
    }  
}  

上面的代码输出为：1--8和9--25.

三、非Ling to Sql的解决方案（一）

因为我自己的版本面向的.Net FrameWork版本是2.0的，而只有3.5的.net FrameWork版本才支持Linq，所以我按照上面的办法写了跟上述功能相似的犯法，类似于Where和Group的用法，经过自己的测试达到了上述的要求，代码如下：

[csharp] view plaincopyprint?
    List<PointA> data = new List<PointA>   
    {   
    new PointA() { X = 18,Y = 26},  
            new PointA() { X = 3, Y = 8 },  
            new PointA() { X = 1, Y = 4 },  
            new PointA() { X = 9, Y = 20 },  
            new PointA() { X = 17, Y = 25 }  
    };  
    public void sort(List<PointA> data)  
    {  
        data.ForEach(x => {  
            PointA temp = new PointA();  
            temp = innerSort(data, x);//返回第一个满足条件的PontA类  
            if (0！=temp.X && 0!=temp.Y)  
            {  
                x.X = temp.X > x.X ? x.X : temp.X;  
                x.Y = temp.Y > x.Y ? temp.Y : x.Y;  
            }  
        });  
        /*删除重复数据*/  
        for (int i = 0; i < data.Count - 1; i++)  
        {  
            for (int j = data.Count - 1; j > i; j--)  
            {  
                if (data[j].X==data[i].X &&data[j].Y==data[i].Y)  
                {  
                    data.Remove(data[j]);  
                }  
            }  
        }  
        Console.WriteLine(data);  
    }  
    /*此方法用来返回第一个满足条件的PointA的区间*/  
  private PointA innerSort(List<PointA> list,PointA x)  
    {  
    PointA result = new PointA();  
    foreach (PointA y in list)  
    {  
        if (y != x && y.X <= x.Y && y.Y >= x.X)  
        {  
            result = y;  
            break;  
        }  
    }  
    return result;  
    }  
}  
class PointA  
{  
    public int X { get; set; }  
    public int Y { get; set; }  
    public override string ToString()  
    {  
        return string.Format("X = {0}, Y = {1}.", X, Y);  
    }  

四、非Linq解决方案（二）

上边的两个方法只能合并区间相邻的时候，比如（1,4）、（2、8），会输出（1,8），但是当输入（1,4）、（8,15）、（2,10）的时候输出结果是（1,10）、（8,15），显然结果是不正确的，所以自己又改进了以前的方法，如下所示：

[csharp] view plaincopyprint?
List<PointA> data = new List<PointA>   
        {   
        new PointA() { X = 18,Y = 26},  
                new PointA() { X = 3, Y = 8 },  
                new PointA() { X = 1, Y = 4 },  
                new PointA() { X = 9, Y = 20 },  
                new PointA() { X = 17, Y = 25 }  
        };  
        /// <summary>  
        /// 双重循环的合并算法，实现了任意多个区间的合并  
        /// 思路：外循环，从第一个到最后一个  
        /// 内循环，找到符合合并条件的选项，将合并后的数据保存在data[i-1]中，然后删除已经被合并的  
        /// 数据，同时将内循环的m初始化0，从新开始下一轮的循环，m!=i-1是为了限定在相等的时候不要  
        /// 删除数据  
        /// </summary>  
        /// <param name="data"></param>  
        public void SortTest(List<PointF> data)  
        {  
            for (int i = 1; i < data.Count; i++)  
            {  
                for (int m = i; m < data.Count; m++)  
                {  
                    if (data[m].X <= data[i-1].Y && data[m].Y >= data[i-1].X &&m!=i-1)  
                    {  
                        PointF tempPoint = new PointF();  
                        tempPoint.X = data[i-1].X > data[m].X ? data[m].X : data[i-1].X;  
                        tempPoint.Y = data[i-1].Y > data[m].Y ? data[i-1].Y : data[m].Y;  
                        data[i-1] = tempPoint;//结构体是值传递，要修改只能通过这种方式  
                        data.Remove(data[m]);  
                        m = 0;//从头开始此次循环合并  
                    }  
                }  
            }  
        }  
  
    }  
    class PointA  
    {  
        public int X { get; set; }  
        public int Y { get; set; }  
        public override string ToString()  
        {  
            return string.Format("X = {0}, Y = {1}.", X, Y);  
        }  
五、总结
      从这个例子可以看出使用Linq To Sql可以使程序的代码量大大减少，并且效率也很高。

0 0