怎么对stl中的list进行稳定排序？？

[excited_lamb]

1，好像stable_sort()不支持list啊，那怎么对stl中的list进行稳定排序？？
2，看如下程序，为什么cmpNo,cmpName函数放在Table类里，程序通不过，而全局的就可以呢？？

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

struct Stu
{
     string         No;
     string         Name; 
};
class Table
{
      public:
          void build(char *flName);
          void show();
          void sortNo();
          void sortName();
         private:
          /*  摆这里会报错，为什么？？ 
          bool cmpNo(const Stu& s1, const Stu& s2)
               {return s1.No < s2.No;}
          bool cmpName(const Stu& s1, const Stu& s2)
               {return s1.Name < s2.Name;}
          */
          list<Stu> T;
          ifstream  In;
};

bool cmpNo(const Stu& s1, const Stu& s2)
     {return s1.No < s2.No;}
bool cmpName(const Stu& s1, const Stu& s2)
     {return s1.Name < s2.Name;}
     
void Table:: build(char *flName)
{
     In.close();
     In.clear();
     In.open(flName);
     Stu tmp;
     while(In >> tmp.Name && In >> tmp.No)
        T.push_back(tmp);
}

void Table:: show()
{
     list<Stu>::iterator it = T.begin();
     cout << "\nafter sort:" << endl;
     while(it != T.end())
     {
          cout << it->Name << "\t" << it->No << endl;
          it++;
     }
     
}

void Table:: sortNo()
{
     T.sort(cmpNo);
     //sort       (T.begin(), T.end(), cmpNo);  不行 
     //stable_sort(T.begin(), T.end(), cmpNo);  不行.. 
}

void Table:: sortName()
{
     T.sort(cmpName);
}

int main(int argc, char *argv[])
{
    Table A;
    A.build("a.txt"); A.show();
    A.sortNo();       A.show();
    A.sortName();     A.show();
    system("PAUSE");
    return EXIT_SUCCESS;
}

先谢过了~

[baihacker]

在class Table内的话要加上
Table::(如果不是友元的话)

如果stable_sort不行,自己写一个稳定的排序就是了啊...

[laibach0304]

stable_sort支持list，你的程序有问题。

关于是全局还是成员的，这个你得好好看书了

[richbirdandy]

1.list的成员函数sort是基于快速排序
要稳定排序 只有自己写了
2.如果放到类里，就需要通过类的对象或者指针访问
而sort的比较函数需要一个public的函数 而且能直接调用而不是通过对象调用

[richbirdandy]

template <class RandomAccessIterator, class Compare>
void stable_sort ( RandomAccessIterator first, RandomAccessIterator last,
Compare comp );
要随机指针 不能用于list

[richbirdandy]

[Quote=引用 5 楼 richbirdandy 的回复:]
template <class RandomAccessIterator, class Compare>
void stable_sort ( RandomAccessIterator first, RandomAccessIterator last,
Compare comp );
要随机指针 不能用于list
[/Quote]
写错了 随机迭代器

[excited_lamb]

在class Table内的话要加上
Table::(如果不是友元的话)
---------------------------------------
不行的，，是内部函数调用啊，也不需要啊，，


2.如果放到类里，就需要通过类的对象或者指针访问
而sort的比较函数需要一个public的函数 而且能直接调用而不是通过对象调用
--------------------------------------------
不明白你的意思，，我是在类成员函数中调用sort()没用对象调用啊~~

[excited_lamb]

第一个问题，，没现成的稳定排序对list，要自己写？
第二个问题你能解释清楚点吗？？

[richbirdandy]

[Quote=引用 7 楼 excited_lamb 的回复:]
在class Table内的话要加上
Table::(如果不是友元的话)
---------------------------------------
不行的，，是内部函数调用啊，也不需要啊，，


2.如果放到类里，就需要通过类的对象或者指针访问
而sort的比较函数需要一个public的函数 而且能直接调用而不是通过对象调用
--------------------------------------------
不明白你的意思，，我是在类成员函数中调用sort()没用对象调用啊~~
[/Quote]
sort (T.begin(), T.end(), cmpNo);
这个函数 一般会有这一行实现
if(cmpNo(a,b))//a,b为容器内对象
lz想想这个cmpNo(a,b)语句怎么让它成功吧

[richbirdandy]

这里的sort是个全局函数
即使用成员函数调用它
它还是个全局函数

[wangdeqie]

如果sort调用的排序规则是类的成员函数，要用mem_fun

[richbirdandy]

[Quote=引用 11 楼 wangdeqie 的回复:]
如果sort调用的排序规则是类的成员函数，要用mem_fun
[/Quote]
对呀 忘了这个适配器了

[excited_lamb]

谢谢啊，我明白了！！

[pengzhixi]

private:
/* 摆这里会报错，为什么？？
bool cmpNo(const Stu& s1, const Stu& s2)
{return s1.No < s2.No;}
bool cmpName(const Stu& s1, const Stu& s2)
{return s1.Name < s2.Name;}
*/

既然是作为类的一个成员函数，里面的第一个参数可以不需要吧

[wangdeqie]

//可以改成这样
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <list>
#include <algorithm>
#include <string>
using namespace std;

struct Stu
{
	string No;
	string Name; 
};
class Table
{
public:
	void build(char *flName);
	void show();
	void sortNo();
	void sortName();
private:
        struct cmpNo
        {	
            bool operator()(const Stu& s1, const Stu& s2)
            {
                 return s1.No < s2.No;
            }        
        };
        struct cmpName
        {	
            bool operator()(const Stu& s1, const Stu& s2)
            {
                 return s1.Name < s2.Name;
            }        
        };        
	list<Stu> T;
	ifstream  In;
};

bool cmpName(const Stu& s1, const Stu& s2)
{
     return s1.Name < s2.Name;
}


void Table:: build(char *flName)
{
	In.close();
	In.clear();
	In.open(flName);
	Stu tmp;
	while(In >> tmp.Name && In >> tmp.No)
        T.push_back(tmp);
}

void Table:: show()
{
	list<Stu>::iterator it = T.begin();
	cout << "\nafter sort:" << endl;
	while(it != T.end())
	{
		cout << it->Name << "\t" << it->No << endl;
		it++;
	}
	
}

void Table:: sortNo()
{
	T.sort(cmpNo());
}

void Table:: sortName()
{
	T.sort(cmpName());
}

int main(int argc, char *argv[])
{
    
    Table A;
    A.build("a.txt"); A.show();
    A.sortNo();       A.show();
    A.sortName();     A.show();
    system("PAUSE");
    return EXIT_SUCCESS;
}

[iambic]

std::list的sort是stable的。

[iambic]

分数给了错误的答案……

[richbirdandy]

[Quote=引用 16 楼 iambic 的回复:]
std::list的sort是stable的。
[/Quote]

// list 不能使用STL 演算法 sort()，必須使用自己的 sort() member function，
// 因為STL演算法sort() 只接受RamdonAccessIterator. 
// 本函式採用 quick sort. 
template <class T, class Alloc>
void list<T, Alloc>::sort() {
  // 以下判斷，如果是空白串列，或僅有一個元素，就不做任何動作。
  // 使用 size() == 0 || size() == 1 來判斷，雖然也可以，但是比較慢。
  if (node->next == node || link_type(node->next)->next == node) return;

  // 一些新的 lists，做為中介資料存放區
  list<T, Alloc> carry;
  list<T, Alloc> counter[64];
  int fill = 0;
  while (!empty()) {
    carry.splice(carry.begin(), *this, begin());
    int i = 0;
    while(i < fill && !counter[i].empty()) {
      counter[i].merge(carry);
      carry.swap(counter[i++]);
    }
    carry.swap(counter[i]);         
    if (i == fill) ++fill;
  } 

  for (int i = 1; i < fill; ++i) 
     counter[i].merge(counter[i-1]);
  swap(counter[fill-1]);
}

[richbirdandy]

[Quote=引用 17 楼 iambic 的回复:]
分数给了错误的答案……
[/Quote]
好像是稳定的 我错了。。。

[excited_lamb]

饿，的确是稳定的，，，，

只能对 iambic 说声不好意思了~~
因为你回复的时候我已经结贴了....
你应该不会恨我吧....

[iambic]

只是看到有错误的回复心里不舒服而已。