编辑代码

#include <iostream>
#include <algorithm>
#include <list>
#include <vector>

using namespace std;

struct classi{
        int start;
        int end;

        classi(int s, int e) {
            start = s;
            end = e;
        }
};


void printNonIntersectclass(list<classi> &nonIntersectclass) {
    for (list<classi>::iterator i = nonIntersectclass.begin(); i != nonIntersectclass.end(); ++i)
    {
        cout << "[" << i->start << "," << i->end << "] ";
    }
    cout << endl;
}

bool compareclassLength(classi left, classi right) {
    return (left.end - left.start) < (right.end - right.start);
}

bool compareclassStart(classi left, classi right) {
    return left.start < right.start;
}

void findNonIntersectclass(vector<classi> &c, list<classi> &nonIntersectclass) {
  
    sort(c.begin(), c.end(), compareclassStart);

    
    vector<classi>::iterator selected = c.begin();

    while(selected != c.end())
    {
        int classiEnd = selected->end;
        vector<classi>::iterator minEnd = c.end();
        for(vector<classi>::iterator i = selected; i != c.end(); i++) 
        {
            cout << "start: " << i -> start << " end: " << i -> end << endl;
            cout << classiEnd << endl;
            cout << nonIntersectclass.size() << endl;
            if (nonIntersectclass.size() > 0)
            {
                
                if (nonIntersectclass.back().end <= i -> start && classiEnd >= i -> end)
                {
                    cout << "start: " << nonIntersectclass.back().start << " end: " << nonIntersectclass.back().end << endl;
                    minEnd = i;
                    classiEnd = i -> end;
                }
            }
            else
            {
                if (classiEnd >= i -> end)
                {
                    minEnd = i;
                   classiEnd = i -> end;
                }
            }
            
        }

        if ( minEnd != c.end())
        {
            selected = minEnd;
            nonIntersectclass.push_back(*selected);
           
        }
         ++selected;
    }
}

int main(){
    vector<classi> C;
    C.push_back(classi(800,930));
    C.push_back(classi(830,1000));
    C.push_back(classi(930,1200));
    C.push_back(classi(1000,1100));
    C.push_back(classi(1130,1230));
    list<classi> nonIntersectclass;
    findNonIntersectclass(C, nonIntersectclass);
    printNonIntersectclass(nonIntersectclass);
}