重叠区间的个数

给定多个可能重合的区间，找出重叠区间的个数。

题解：

我们首先根据区间点的不同类型进行分类，分成start和end点。然后我们根据这些start和end节点的大小来排序，可以用Comparator接口，重写其compareTo方法。然后将按照Start排序之后的节点对，然后从前往后走，依次根据后一个节点对的起始节点的值和前一个节点的结束节点的值比较，如果后一个比前一个小，那么就说明存在重合区间，需要累加。

代码如下：

class Interval
{
    int start;
    int end;
    Interval(int a,int b)
    {
        start = a;
        end = b;
    }
}


class Com implements Comparator<Interval>
{
    public int compare(Interval i1,Interval i2)   //这个方法是看这个Interval类中的start值
    {
        if(i1.start == i2.start)
            return 0;
        else if(i1.start > i2.start)   //如果前面那一个大于后面那一个，那么就要交换
            return 1;
        else
            return -1;
    }
}

public class getOverlappingCount
{
    public static int GetOverLappingCount(Interval[] A)
    {
        int max = 0,count = 1;    
        if(A == null || A.length == 0)
            return max;
        ArrayList<Interval> list = new ArrayList<Interval>();
        for(int i = 0; i < A.length; i++)
        {
            list.add(new Interval(A[i].start,A[i].end));
            //list.add(new Interval(A[i].end,A[i].end));
        }
        Collections.sort(list,new Com());
        ／*for(int k = 0; k < list.size(); k++)
            System.out.println(list.get(k).start + "  " + list.get(k).end);*／
        for(int i = 0; i < list.size() - 1; i++)
        {
                if(list.get(i+1).start <= list.get(i).end)
                    count++;
                else
                {
                    if(count != 1)
                    {
                        max = max > count ? max : count;
                        count = 1;
                    }
                }
                max = max > count ? max : count;
                //System.out.println(count + " " + max);
        }
        return max;
    }
    /*public static void main(String[] args)   //测试样例
    {
        Interval i = new Interval(1,5);
        Interval j = new Interval(10,15);
        Interval k = new Interval(6,10);
        Interval l = new Interval(20,30);
        Interval m = new Interval(30,40);
        Interval n = new Interval(35,40);
        Interval[] in = new Interval[2];
        in[0] = i;
        in[1] = j;
        in[2] = k;
        in[3] = l;
        in[4] = m;
        in[5] = n;
        System.out.println(GetOverLappingCount(in));
    }*/
}

这以下的代码有误，采用的思路是此题解题方法比较简单，只要将区间分隔成各个点，每个点有两个属性，一个是值，一个是标志（0起点，1止点），然后对这些点排序，最后，从头开始扫描排序的结果，遇到起点重叠个数加1，遇到止点重叠个数减1，并且记录好重叠个数的最大值。

class Interval
{
	int start;
	int end;
	Interval(int a,int b)
	{
		start = a;
		end = b;
	}
}

class Point
{
	int value;
	int type;
	Point(int v,int t)
	{
		this.value = v;
		this.type = t;
	}
}

class Com implements Comparator<Point>
{
	public int compare(Point p1,Point p2)   //这个方法是看这个Point类中的value值
	{
		if(p1.value == p2.value)
			return 0;
		else if(p1.value > p2.value)   //如果前面那一个大于后面那一个，那么就要交换
			return 1;
		else 
			return -1;
	}
}

public class getOverlappingCount 
{
	public static int GetOverLappingCount(Interval[] A)
	{
		int max = 0,count = 1;    //这里count从1开始是因为计算的是重叠的区间，等于重叠区间个数加1
		if(A == null || A.length == 0)
			return max;
		ArrayList<Point> list = new ArrayList<Point>();
		for(int i = 0; i < A.length; i++)
		{
			list.add(new Point(A[i].start,0));
			list.add(new Point(A[i].end,1)); 
		}
		Collections.sort(list,new Com());
		for(int i = 0; i < list.size(); i++)
		{
			if(list.get(i).type == 0)
			{
				count++;
				if(count > 0)
				{
					max = Math.max(count, max);
				}
			}
			else
				count--;
			//System.out.println(count + " " + max);
		}
		return max;
	}
}