C++ sort自定义比较函数

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

#include <iostream>

#include <utility>

#include <vector>

#include <algorithm>

structNode

{

    std::stringfirst_name;

    std::string last_name;

    // 构造函数

    Node(std::string x,std::stringy): first_name(x),last_name(y){}

    // 重载 `operator<`

    booloperator<(const Node&r)const

    {

        if(first_name!=r.first_name){

            returnfirst_name<r.first_name;

        }

        returnlast_name< r.last_name;

    }

    // 重载操作符>(如果需要)

    booloperator>(constNode&r)const

    {

        if(first_name!= r.first_name){

            return first_name>r.first_name;

        }

        returnlast_name>r.last_name;

    }

};

intmain()

{

    std::vector<Node>v={

        {"Barack","Obama"},{"George", "Washington"},{"George","Bush"},

        {"Abraham","Lincoln"},{"John", "Tyler"},{"John","Kennedy"}

    };

    // 按名字的升序对Vector进行排序

    std::sort(v.begin(), v.end());

    // 按名字的降序对Vector进行排序

    // std::sort(v.begin(), v.end(), std::greater<Node>());

    for(constNode&node: v)

    {

        std::cout<<'{'<<node.first_name<<',' <<node.last_name<<'}';

        std::cout<<std::endl;

    }

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#include <iostream>

#include <utility>

#include <vector>

#include <algorithm>

structNode

{

    std::stringfirst_name;

    std::string last_name;

    // 构造函数

    Node(std::string x,std::stringy): first_name(x),last_name(y){}

};

// 重载 `operator<`

booloperator<(constNode &x,constNode&y){

    if(x.first_name!= y.first_name){

        return x.first_name<y.first_name;

    }

    returnx.last_name<y.last_name;

}

intmain()

{

    std::vector<Node>v={

        {"Barack","Obama"},{"George", "Washington"},{"George","Bush"},

        {"Abraham","Lincoln"},{"John", "Tyler"},{"John","Kennedy"}

    };

    std::sort(v.begin(), v.end());

    for (constNode&node:v)

    {

        std::cout<<'{'<< node.first_name<<','<< node.last_name<<'}';

        std::cout<<std::endl;

    }

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#include <iostream>

#include <utility>

#include <vector>

#include <algorithm>

structNode

{

    std::stringfirst_name;

    std::string last_name;

    // 构造函数

    Node(std::string x,std::stringy): first_name(x),last_name(y){}

};

intmain()

{

    std::vector<Node>v={

        {"Barack","Obama"},{"George", "Washington"},{"George","Bush"},

        {"Abraham","Lincoln"},{"John", "Tyler"},{"John","Kennedy"}

    };

    std::sort(v.begin(), v.end(),

            [](constNode&x,const Node&y){

                // 先比较姓氏

                if(x.last_name!= y.last_name){

                    return x.last_name<y.last_name;

                }

                // 仅当姓氏相等时才比较名字

                return x.first_name<y.first_name;

            });

    for(constNode&node:v)

    {

        std::cout <<'{'<<node.first_name<< ','<<node.last_name<<'}';

        std::cout<<std::endl;

    }

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

#include <iostream>

#include <utility>

#include <vector>

#include <algorithm>

structNode

{

    std::stringfirst_name;

    std::string last_name;

    // 构造函数

    Node(std::string x,std::stringy): first_name(x),last_name(y){}

};

structcomp

{

    bool operator()(constNode&x,const Node&y)const{

        // 先比较姓氏

        if(x.last_name!= y.last_name){

            return x.last_name<y.last_name;

        }

        // 仅当姓氏相等时才比较名字

        returnx.first_name <y.first_name;

    }

};

int main()

{

    std::vector<Node> v={

        {"Barack", "Obama"},{"George","Washington"}, {"George","Bush"},

        {"Abraham","Lincoln"},{"John", "Tyler"},{"John","Kennedy"}

    };

    std::sort(v.begin(), v.end(),comp());

    for(constNode&node:v)

    {

        std::cout<<'{'<<node.first_name<<','<< node.last_name<<'}';

        std::cout<<std::endl;

    }

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

#include <iostream>

#include <utility>

#include <vector>

#include <algorithm>

structNode

{

    std::stringfirst_name;

    std::string last_name;

    // 构造函数

    Node(std::string x,std::stringy): first_name(x),last_name(y){}

};

boolfn(constNode&x, constNode&y)

{

    // 先比较姓氏

    if(x.last_name!= y.last_name){

        return x.last_name<y.last_name;

    }

    // 仅当姓氏相等时才比较名字

    returnx.first_name< y.first_name;

}

intmain()

{

    std::vector<Node>v={

        {"Barack","Obama"},{"George", "Washington"},{"George","Bush"},

        {"Abraham","Lincoln"},{"John", "Tyler"},{"John","Kennedy"}

    };

    std::sort(v.begin(), v.end(),fn);

    for(constNode&node:v)

    {

        std::cout<<'{'<<node.first_name<<','<< node.last_name<<'}';

        std::cout<<std::endl;

    }

    return0;

}