c++ sort()是稳定排序吗?
c++sort不是稳定排序，stl中stable_sort才是稳定排序。
稳定排序的概念：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。
c++sort函数用法
用法如下：
sort函数可以三个参数也可以两个参数，必须的头文件＃include < algorithm>和using namespace std；它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)。Sort函数有三个参数：（第三个参数可不写）
第一个是要排序的数组的起始地址。
第二个是结束的地址（最后一位要排序的地址）
第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。
特点说明
适用对象：支持随机访问的容器，即只支持序列式容器（vector, deque, array）。
排序范围：左闭右开，即 [ )。
在第 2 种版本定义中，comp 可以是 C++ STL 标准库提供的排序规则（比如 std::greater< T >），也可以是自定义的排序规则。
关于自定义的参数comp的设计原则：comp带两个同类型的参数，如果第一个参数排在第二个参数前面，返回true，否则返回fal。
返回值：无，因为它直接通过迭代器（指针）改变容器。
默认进行升序排序。
不稳定的排序：不能保证相同元素的相对顺序不变，sort() 函数是基于快速排序实现的。stable_sort()才是稳定的。
c++stl中的stable-sort函数，顾名思义，推测它通常用什么算法实现
大家都能取得的一个共识是函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比使用整型作为它的参数类型要高。而C++通过模板的机制允许推迟对某些类型的选
c++的问题，有关数据挖掘c4.5
double
Entropy(double
p,
double
s)
{
double
n
=
s
-
p;
double
result
=
0;
if
(n
!=
0)
result
+=
-
double(n)
/
s
*
log(double(n)
/
s)
/
log(2.0);
if
(p
!=
0)
result
+=
double(-p)
/
s
*
log(double(p)
/
s)
/
log(2.0);
return
result;
}
double
Gain(double
p1,
double
s1,
double
p2,
double
s2)
{
return
Entropy(p1
+
p2,
s1
+
s2)
-
double(p1
/
s1)
*
Entropy(p1,
s1)
-
double(p2
/
s2)
*
Entropy(p2,
s2);
}
void
processConValue()
{
int
con[6]
=
{2,
3,
8,
11,
14,
15};
for
(int
i
=
0;
i
<
6;
i++)
{
sortKind
=
con[i];
stable_sort(Otrain.begin(),
Otrain.end(),
header);
/*
for
(vector<OriganData>::iterator
it
=
Otrain.begin();
it
!=
Otrain.end();
it++)
cout
<<
(*it).A2
<<
(*it).label
<<
'\t';
cout
<<
endl;
*/
double
bestGain
=
0;
//记录最佳的Gain。
double
gain;
vector<OriganData>::iterator
bestit
=
Otrain.end();
for
(vector<OriganData>::iterator
it
=
Otrain.begin();
it
!=
Otrain.end()
-
1;
it++)
{
if
((*it).label
!=
(*(it
+
1)).label)
{
int
p1
=
0,
p2
=
0,
n1
=
0,
n2
=
0;
//记录正反例的个数
for
(vector<OriganData>::iterator
jt
=
Otrain.begin();
jt
!=
it
+
1;
jt++)
if
((*jt).label
==
'+')
p1++;
el
n1++;
for
(vector<OriganData>::iterator
jt
=
it
+
1;
jt
!=
Otrain.end();
jt++)
if
((*jt).label
==
'+')
p2++;
el
n2++;
gain
=
Gain(p1,
p1
+
n1,
p2,
p2
+
n2);
if
(gain
>
bestGain)
{
bestGain
=
gain;
bestit
=
it;
}
}
}
if
(bestit
==
Otrain.end())
bestit
=
Otrain.begin();
switch
(sortKind)
{
ca
2:
conSpit[i]
=
((*bestit).A2
+
(*(bestit
+
1)).A2)
/
2;
break;
ca
3:
conSpit[i]
=
((*bestit).A3
+
(*(bestit
+
1)).A3)
/
2;
break;
ca
8:
conSpit[i]
=
((*bestit).A8
+
(*(bestit
+
1)).A8)
/
2;
break;
ca
11:
conSpit[i]
=
((*bestit).A11
+
(*(bestit
+
1)).A11)
/
2;
break;
ca
14:
conSpit[i]
=
((*bestit).A14
+
(*(bestit
+
1)).A14)
/
2;
break;
ca
15:
conSpit[i]
=
((*bestit).A15
+
(*(bestit
+
1)).A15)
/
2;
break;
}
}
}
