stablesort演算法函數

A. sort 函數是穩定的嗎

既然有穩定排序函數STL stable_sort，說明sort()函數的演算法不是穩定演算法（這並不代表在所有情況下都不穩定）。
排序演算法的穩定性是指對排序指標項相同的記錄，在排序後不改變其相對順序。
你驗證的數據多並不一定就有代表性。如果排序指標項都是兩兩不同的，就不存在穩定性的問題。如果能夠找到函數的詳細說明，根據其演算法就可以很快確定是否穩定。如果找不到函數的詳細說明，而要自行驗證其穩定性，應該先設計各種情況下的數據再進行檢驗。
可以參見如下位置的例子：
http://www.cppblog.com/woaidongmao/archive/2011/07/23/140205.html

B. c++stl中的stable-sort函數，顧名思義，推測它通常用什麼演算法實現

大家都能取得的一個共識是函數庫對數據類型的選擇對其可重用性起著至關重要的作用。舉例來說，一個求方根的函數，在使用浮點數作為其參數類型的情況下的可重用性肯定比使用整型作為它的參數類型要高。而C++通過模板的機制允許推遲對某些類型的選

C. 簡明扼要的介紹下stable_sort（）函數的用法。

需包含頭文件：#include <algorithms>因為它是庫函數
用法：和sort一樣一下介紹一下sort的用法
sort的應用；
1、可以傳入兩個參數；
sort(a,a+N) ,其中a是數組，a+N表示對a[0]至a[N-1]的N個數進行排序(默認從小到大排序)；
2、傳入三個參數；
sort(a,a+N,cmp),第三個參數是一個函數 ；
如果讓函數從大到小排序，可以用如下演算法實現；
bool cmp(int a,int b){return a>b};
sort(A,A+N,cmp);
但是有區別，區別是stable_sort函數遇到兩個數相等時，不對其交換順序；這個應用在數組裡面不受影響，當函數參數傳入的是結構體時，會發現兩者之間的明顯區別。

D. C++sort函數

之所以出現這個問題，這是因為stable_sort調用了別的一些函數，這種調用的參數包含了你vector中的元素，而在那些函數中，參數類型都是const的，所以最終predicate調用的時候，必須參數也是const的，舉個簡單的例子，相當於stable_sort幹了以下的事情：
template <typename Input, typename Pred>
void stable_sort(Input begin, Input end, Pred p) {
do_something(*begin, p);
}
template <typename T, typename Pred>
void do_something(const T &val, Pred p) {
p(val, val);
}
注意，在最後的do_something函數中，類型T就是你vector中元素的類型，從sort調用過來的時候，參數已經變成了const類型，所以pred調用的時候參數必須也是const的

E. c語言運用sort 排序函數，需要的頭文件是什麼

sort不屬於C語言的標准函數，所以也沒有相應的頭文件，但是可以自定義。

sort函數為將整型數組從小到大排序。

voidsort(int*a,intl)//a為數組地址，l為數組長度。

{

inti,j;

intv;

//排序主體

for(i=0;i<l-1;i++)

for(j=i+1;j<l;j++)

{

if(a[i]>a[j])//如前面的比後面的大，則交換。

{

v=a[i];

a[i]=a[j];

a[j]=v;

}

}}

(5)stablesort演算法函數擴展閱讀

c語言自有的qsort函數

#include<stdio.h>

#include<stdlib.h>

intcomp(constvoid*a,constvoid*b)//用來做比較的函數。

{

return*(int*)a-*(int*)b;

}

intmain()

{

inta[10]={2,4,1,5,5,3,7,4,1,5};//亂序的數組。

inti;

qsort(a,n,sizeof(int),comp);//調用qsort排序

for(i=0;i<10;i++)//輸出排序後的數組

{

printf("%d ",array[i]);

}

return0;

}

F. 代碼如下，為什麼stable_sort的謂詞函數的形參改為非const之後報錯

這是因為stable_sort調用了別的一些函數，這種調用的參數包含了你vector中的元素
而在那些函數中，參數類型都是const的，所以最終predicate調用的時候，必須參數也是const的

舉個簡單的例子，相當於stable_sort幹了以下的事情：
template <typename Input, typename Pred>
void stable_sort(Input begin, Input end, Pred p) {
do_something(*begin, p);
}

template <typename T, typename Pred>
void do_something(const T &val, Pred p) {
p(val, val);
}

注意，在最後的do_something函數中，類型T就是你vector中元素的類型，從sort調用過來的時候，參數已經變成了const類型，所以pred調用的時候參數必須也是const的

以上代碼對解釋排序過程沒有意義，這代碼也不和語法，因為我沒有告訴你do_something的模板參數T是哪裡來的。這牽扯到meta-programming的東西，我不在這里多解釋。我要說明的重點是讓你看到vector的元素類型T是如何變成const T &的

G. stable_sort的排序問題！謝謝

演算法使用的是歸並排序，詳見維基網路
islonger是個函數指針，在比較時，會調用islonger。svec的各個數值是可以隨機訪問的。所以就可以通過反復比較svec中各個元素來排序。

H. c++排序函數

首先看sort函數見下表：

函數名 功能描述
sort 對給定區間所有元素進行排序
stable_sort 對給定區間所有元素進行穩定排序
partial_sort 對給定區間所有元素部分排
partial_sort_ 對給定區間復制並排序
nth_element 找出給定區間的某個位置對應的元素
is_sorted 判斷一個區間是否已經排好序
partition 使得符合某個條件的元素放在前面
stable_partition 相對穩定的使得符合某個條件的元素放在前面

要使用此函數只需用#include <algorithm> sort即可使用，語法描述為：
sort(begin,end)，表示一個范圍，例如：

int _tmain(int argc, _TCHAR* argv[])
{
int a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return 0;
}

輸出結果將是把數組a按升序排序，說到這里可能就有人會問怎麼樣用它降序排列呢？這就是下一個討論的內容.
一種是自己編寫一個比較函數來實現，接著調用三個參數的sort：sort(begin,end,compare)就成了。對於list容器，這個方法也適用，把compare作為sort的參數就可以了，即：sort(compare).
1）自己編寫compare函數：

bool compare(int a,int b)
{
return a<b; //升序排列，如果改為return a>b，則為降序
}
int _tmain(int argc, _TCHAR* argv[])
{
int a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,compare);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return 0;
}

2）更進一步，讓這種操作更加能適應變化。也就是說，能給比較函數一個參數，用來指示是按升序還是按降序排,這回輪到函數對象出場了。
為了描述方便，我先定義一個枚舉類型EnumComp用來表示升序和降序。很簡單：
enum Enumcomp{ASC,DESC};
然後開始用一個類來描述這個函數對象。它會根據它的參數來決定是採用「<」還是「>」。

class compare
{
private:
Enumcomp comp;
public:
compare(Enumcomp c):comp(c) {};
bool operator () (int num1,int num2)
{
switch(comp)
{
case ASC:
return num1<num2;
case DESC:
return num1>num2;
}
}
};

接下來使用 sort(begin,end,compare(ASC)實現升序，sort(begin,end,compare(DESC)實現降序。
主函數為：

int main()
{
int a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,compare(DESC));
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return 0;
}

3)其實對於這么簡單的任務（類型支持「<」、「>」等比較運算符），完全沒必要自己寫一個類出來。標准庫里已經有現成的了，就在functional里，include進來就行了。functional提供了一堆基於模板的比較函數對象。它們是（看名字就知道意思了）：equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。對於這個問題來說，greater和less就足夠了，直接拿過來用：
升序：sort(begin,end,less<data-type>());
降序：sort(begin,end,greater<data-type>()).

int _tmain(int argc, _TCHAR* argv[])
{
int a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
sort(a,a+20,greater<int>());
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return 0;
}

4)既然有迭代器，如果是string 就可以使用反向迭代器來完成逆序排列，程序如下：

int main()
{
string str("cvicses");
string s(str.rbegin(),str.rend());
cout << s <<endl;
return 0;
}

qsort():
原型:
_CRTIMP void __cdecl qsort (void*, size_t, size_t,int (*)(const void*, const void*));
解釋: qsort ( 數組名 ，元素個數，元素佔用的空間(sizeof)，比較函數)
比較函數是一個自己寫的函數 遵循 int com(const void *a,const void *b) 的格式。
當a b關系為 > < = 時，分別返回正值 負值 零 （或者相反）。
使用a b 時要強制轉換類型，從void * 轉換回應有的類型後，進行操作。
數組下標從零開始,個數為N, 下標0-(n-1)。
實例：

int compare(const void *a,const void *b)
{
return *(int*)b-*(int*)a;
}
int main()
{
int a[20]={2,4,1,23,5,76,0,43,24,65},i;
for(i=0;i<20;i++)
cout<<a[i]<<endl;
qsort((void *)a,20,sizeof(int),compare);
for(i=0;i<20;i++)
cout<<a[i]<<endl;
return 0;
}

I. C++中關於泛型演算法sort()用法的問題C++達人進！

首先實現這個排序有兩種方式，一個自己定義一個返回值為bool的比較函數。
一個是自己定義類中的<操作函數。
第一種方式可以簡單寫為。
bool cmp(node x,node y)
{
return x.key1<b.key1;
}
sort(vec.begin,vec.end.cmp);
這種排序是從小到大的，也就是如果cmp(a,b)為真，則a一定在b的前面，如果
cmp(a,b)和cmp(b,a)都為false.的話，也就是a.key1==b.key1,則他們的先後順序則是不一定的，可能a在b前面，也可能b在a前面。
也就是說這種排序演算法是不穩定的。
第二種方式
struct node{
int key1;
int key2;
book operator <(const node &m)
{
return key1<m.key1;
}
}
這樣就不用自己定義比較函數。
對與sort()排序是不穩定的，正如前面說的，如果需要穩定排序的話，可以使用
stable_sort，它可以保證相等的元素原來的相對次序是不變的。