STL之C++ 实例

1. sort 和容器
STL中标准容器主要vector, list, deque, string, set, multiset, map, multimay， 其中set, multiset, map, multimap都是以树结构的方式存储其元素详细内容请参看：学习STL map, STL set之数据结构基础. 因此在这些容器中，元素一直是有序的。

这些容器的迭代器类型并不是随机型迭代器，因此，上述的那些排序函数，对于这些容器是不可用的。上述sort函数对于下列容器是可用的：
　1．vector
　2．string
　3．deque
如果你自己定义的容器也支持随机型迭代器，那么使用排序算法是没有任何问题的。
 
对于list容器，list自带一个sort成员函数list::sort(). 它和算法函数中的sort差不多，但是list::sort是基于指针的方式排序，也就是说，所有的数据移动和比较都是此用指针的方式实现，因此排序后的迭代器一直保持有效（vector中sort后的迭代器会失效).
 
2. 选择合适的排序函数
为什么要选择合适的排序函数？可能你并不关心效率(这里的效率指的是程序运行时间), 或者说你的数据量很小， 因此你觉得随便用哪个函数都无关紧要。
 
其实不然，即使你不关心效率，如果你选择合适的排序函数，你会让你的代码更容易让人明白，你会让你的代码更有扩充性，逐渐养成一个良好的习惯，很重要吧 smile 。
 
如果你以前有用过C语言中的qsort, 想知道qsort和他们的比较，那我告诉你，qsort和sort是一样的，因为他们采用的都是快速排序。从效率上看，以下几种sort算法的是一个排序，效率由高到低（耗时由小变大）：
   1. partion
   2. stable_partition
   3. nth_element
   4. partial_sort
   5. sort
   6. stable_sort
记得，以前翻译过Effective STL的文章，其中对如何选择排序函数总结的很好：
    ★若需对vector, string, deque, 或 array容器进行全排序，你可选择sort或stable_sort；
    ★若只需对vector, string, deque, 或 array容器中取得top n的元素，部分排序partial_sort是首选.
    ★若对于vector, string, deque, 或array容器，你需要找到第n个位置的元素或者你需要得到top n且不关系top n中的内部顺序，nth_element是最理想的；
    ★若你需要从标准序列容器或者array中把满足某个条件或者不满足某个条件的元素分开，你最好使用partition或stable_partition；
    ★若使用的list容器，你可以直接使用partition和stable_partition算法，你可以使用list::sort代替sort和 stable_sort排序。若你需要得到partial_sort或nth_element的排序效果，你必须间接使用。正如上面介绍的有几种方式可以选择。

所以，练习如下：
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

/**//* --------------------------------------------- */

/**//* define use type... */
class defineClass 
...{
public:
    defineClass(int a, int b) : first(a), second(b) ...{}

    bool operator < (defineClass& def) const
    ...{
        return first < def.first;
    }

public:
    int first;
    int second;
};

bool less_second(const defineClass& type_src, 
                 const defineClass& type_det)
...{
    return type_src.second < type_det.second;
}

/**//* with stable_sort test */
bool less_str_length(const string& str, 
                     const string& str_)
...{
    return str.length() < str_.length();
}

/**//* --------------------------------------------- */
class partialTest
...{
public:
    partialTest(const string& str, int b) : name(str), score(b) ...{} 
    string name;
    int score;

    bool operator < (const partialTest& part) const
    ...{
        return score < part.score;
    }
};

/**//* --------------------------------------------- */
/**//* Main */
int main(int argc, char* argv[])
...{
    cout << "stl_sort test start...." << endl;

    /**//* sort ... */
    vector<int> int_vector;

    int_vector.push_back(5);
    int_vector.push_back(2);
    int_vector.push_back(8);
    int_vector.push_back(4);
    int_vector.push_back(2);

    vector<int>::iterator int_iter;
    
    /**//* default sort... */
    sort(int_vector.begin(), int_vector.end());

    for(int_iter = int_vector.begin(); int_iter != int_vector.end(); int_iter++) ...{
        cout << *int_iter << endl;
    }
    
    /**//*
     * Functional:
     * less, greater, equal_to, not_equal_to, less_equal, greater_equal.
     */

    /**//* less functional sort...  */
    sort(int_vector.begin(), int_vector.end(), less<int>());
    
    for(int_iter = int_vector.begin(); int_iter != int_vector.end(); int_iter++) ...{
        cout << *int_iter << endl;
    }
    
    /**//* greater functional sort...  */
    sort(int_vector.begin(), int_vector.end(), greater<int>());
    
    for(int_iter = int_vector.begin(); int_iter != int_vector.end(); int_iter++) ...{
        cout << *int_iter << endl;
    }
    
    /**//* --------------------------------------------- */
    int i;
    vector<defineClass> def_vector;
    
    for (i = 0; i < 10; i++) ...{
        defineClass def_type(10 - i, i * 2);
        def_vector.push_back(def_type);
    }
    
    /**//* not sort */
    for (i = 0; i < def_vector.size(); i++) ...{
        cout << "(" 
            << def_vector[i].first
            << ", "
            << def_vector[i].second 
            << ")" 
            << endl;
    }
    
    /**//* default sort for first */
    sort(def_vector.begin(), def_vector.end());
    for (i = 0; i < def_vector.size(); i++) ...{
        cout << "(" 
            << def_vector[i].first
            << ", "
            << def_vector[i].second 
            << ")" 
            << endl;
    }
    
    /**//* default sort for second */
    sort(def_vector.begin(), def_vector.end(), less_second);
    for (i = 0; i < def_vector.size(); i++) ...{
        cout << "(" 
            << def_vector[i].first
            << ", "
            << def_vector[i].second 
            << ")" 
            << endl;
    }

    /**//* --------------------------------------------- */
    /**//* stable_sort test... */
    vector<string> str_vector;

    str_vector.push_back("Hubei_wh");
    str_vector.push_back("Jiangsu_nanj"); /**//* len = 12 */
    str_vector.push_back("Xinjiang_wulmq");
    str_vector.push_back("zhejiang_hz");
    str_vector.push_back("Guangdong_Gz"); /**//* len = 12 */
    str_vector.push_back("123456789012"); /**//* len = 12 */

    sort(str_vector.begin(), str_vector.end(), less_str_length);

    for (i = 0; i < str_vector.size(); i++) ...{
        cout << str_vector[i].c_str() << endl;
    }

    stable_sort(str_vector.begin(), str_vector.end(), less_str_length);
    
    for (i = 0; i < str_vector.size(); i++) ...{
        cout << str_vector[i].c_str() << endl;
    }

    /**//* --------------------------------------------- */

    /**//* partial_sort and partial_sort_copy test ...*/
    vector<partialTest> part_vector;
    string name[] = ...{ "Tom", "Jim", "Mary", "Piter", "Lily", "lulx", "fanm", "luci"};
    int score[]  = ...{  89, 78, 79, 98, 100, 70, 69, 75 };

    for (i = 0; i < 8; i++) ...{
        partialTest student(name[i], score[i]);
        part_vector.push_back(student);
    }
    
    partial_sort(part_vector.begin(), part_vector.begin() + 4, 
        part_vector.end(), less<partialTest>());

    for (i = 0; i < part_vector.size(); i++) ...{
        cout << part_vector[i].name.c_str()
            << " "
            << part_vector[i].score
            << endl;
    }

    /**//* --------------------------------------------- */

    cout << "stl_sort test end...." << endl;

    return 0;
}