排序算法
按照是否將元素放入到內存中，排序分為內部排序和外部排序。內部排序適合元素不多的文件，按照元素的排序原則，內部排序分為：
- 插入排序
- 交換排序
- 選擇排序
- 歸并排序
插入排序
基本方法是：尋找一個指定元素在待排序元素中的位置，然后將它插入
直接插入
基本思想：每次將一個待排序的元素按其關鍵碼的大小插入到一個已經排好序的有序序列中，知道全部元素排序好。
void insert_sort(int arr[], int len){
for (int i=1; i<len; i++) {
int temp = arr[i] ;
for (int j = i-1; j>=0; j--) {
//j+1位置一直是空的，
if (arr[j]>temp) {
arr[j+1] = arr[j] ;
}else {
arr[j+1] = temp ;
break ;
}
}
}
}
直接插入的兩個特點： 基本有序的序列，直接插入最快。 記錄個數很少的無序序列，直接插入也很快
希爾排序
希爾排序是對直接插入排序的一種改進。它的基本思想是：將待排序的元素分成多個子集，分別對這些子集進行直接插入排序，待整個序列都有序時，再對元素進行一次直接插入排序。
void Sort::shell_sort(int arr[] ,int len) {
//增長區間
for (int d = len /2; d>=1; d = d/2)
{ //一次希爾排序
for (int i = d; i < len; i++)
{ //和有序的數組的最后一個元素比較
if (arr[i]<arr[i-d])
{
int temp = arr[i] ;
int j = i-d ;
while(j>=0&&arr[j]>temp){
arr[j+d] = arr[j];
j = j-d;
}
arr[j+d] = temp ;
}
}
}
}
交換排序
交換排序的基本方法是：在待排序的元素中選擇兩個元素，將他們的關鍵碼進行比較，進行排序。
冒泡排序
基本思想是：兩兩比較相鄰的元素，如果反序，則交換位置，直到沒有反序的元素為止。
void bubble_sort(int arr[], int len){
//從小到大
for (int i = 0; i<len; i++) {
for (int j = len-1; j>i; j--) {
if (arr[j]<arr[j-1]) {
int temp = arr[j] ;
arr[j] = arr[j-1] ;
arr[j-1] = temp ;
}
}
}
}
快速排序
快速排序是冒泡排序的改進算法，快速排序元素的比較設移動是序列的兩端到中間進行的。它的基本思想是：
在分區中選擇一個元素為軸值，將待排序的元素劃分為兩個分區，左側元素的關鍵碼都小于或者等于軸值，右側元素的關鍵碼的值都大于或者等于軸值。重復上述過程，直到整個序列有序。
void quick_sort(int arr[], int left, int right){
//遞歸結束條件
if (left<right) {
//一次遍歷
int i = left , j = right , key = arr[left] ;
while (i<j) {
while (i<j&&arr[j]>key)
j-- ;
if (i<j)
arr[i++] =arr[j];
while (i<j&& arr[i]<key)
i++ ;
if (i<j)
arr[j--] = arr[i] ;
}
//遞歸
arr[i]=key ;
quick_sort(arr, left, i-1);
quick_sort(arr, i+1, right);
}
}
選擇排序
選擇排序的基本思想是：每趟排序在待排序列表中選擇關鍵碼最小的元素，順序添加到已將排序好的有序序列中去，直到全部記錄都排序完成
簡單選擇排序
簡單選擇排序的基本思想是：每趟在待排序的序列中找出最小的記錄加到序列頭部。直到都排序完成。
void select_sort(int arr[], int len){
for (int i= 0; i<len-1; i++) {
int temp = i ;
for (int j=i+1; j<len; j++) {
if(arr[j]<arr[temp]){
temp = j ;
}
}
if (temp != i) {
int arrTemp = arr[i] ;
arr[i] = arr[temp] ;
arr[temp] =arrTemp ;
}
}
}
堆排序
堆排序是對簡單選擇排序的改進。堆排序利用了前一趟比較的結果，減小了比較的次數，從而提高整個排序的效率。
//調整堆
void Sort::heap_adjust(int arr[], int i, int len){
int child = 2 * i + 1;
int temp;
while (child<len) {
// 得到子結點中鍵值較大的結點 這里求的是大根堆, 如果是小根堆，下面變為arr[child + 1] < arr[child]
if (child < len - 1 && arr[child + 1]>arr[child])
child ++;
//這里求的是大根堆，如果求小根堆arr[i] > arr[child]
if (arr[i] <arr[child])
{
temp = arr[i];
arr[i] = arr[child];
arr[child] = temp;
i =child ;
child = 2 * i + 1;
}
else
break;
}
}
//堆排序
void Sort::heap_sort(int arr[], int len){
int i;
// 調整序列的前半部分元素，調整完之后第一個元素是序列的最大的元素
for (int i = len / 2 - 1; i >= 0; i--)
{
heap_adjust(arr, i, len);
}
for (i = len - 1; i > 0; i--)
{
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 不斷縮小調整heap的范圍，每一次調整完畢保證第一個元素是當前序列的最大值
heap_adjust(arr, 0, i);
}
}
歸并排序
歸并排序的基本思想方法是：將兩個或者兩個以上的有序序列歸并成一個有序序列
void merge(int arr[], int temp_arr[], int start_index, int mid_index, int end_index){
int i=start_index;
int k=0;
int j=mid_index+1 ;
//直到一個組數被遍歷完
while (i<mid_index+1 && j<1+end_index) {
if (arr[i]>arr[j]) {
temp_arr[k++] =arr[j++];
}else{
temp_arr[k++] =arr[i++];
}
}
//將沒被遍歷完的數組添加到數組中去
while (i<1+mid_index) {
temp_arr[k++]= arr[i++];
}
while (j<1+end_index) {
temp_arr[k++] =arr[j++];
}
for (i = 0, j = start_index; j <1+end_index; i ++, j ++)
arr[j] = temp_arr[i];
}
void merge_sort(int arr[], int arr_temp[],int start_index, int end_index){
if (start_index<end_index) {
int mid = (start_index+end_index)/2 ;
merge_sort(arr, arr_temp, start_index, mid);
merge_sort(arr, arr_temp, mid+1, end_index);
merge(arr, arr_temp, start_index, mid, end_index);
}
排序的比較
排序方法 | 平均復雜度 | 空間復雜度 | 穩定性
------------ | ------------- | ------------
直接插入排序 | O(n2)| O(1) | 穩定
希爾排序 | O(nlog2n) | O(1) |不穩定
冒泡排序 | O(n2)|O(1)|穩定
快速排序 | O(nlog2n) | O(nlog2n)|不穩定
簡單選擇排序 | O(n2) | O(1)| 穩定
堆排序 | O(nlog2n) | O(1)| 不穩定
歸并排序 | O(nlog2n) | O(n)| 穩定
STL中相關排序算法
所有STL sort算法函數的名字列表:
| 函數名 | 功能描述 |
|---|---|
| sort | 對給定區間所有元素進行排序 |
| stable_sort | 對給定區間所有元素進行穩定排序 |
| partial_sort | 對給定區間所有元素部分排序 |
| partial_sort_copy | 對給定區間復制并排序 |
| nth_element | 找出給定區間的某個位置對應的元素 |
| is_sorted | 判斷一個區間是否已經排好序 |
| partition | 使得符合某個條件的元素放在前面 |
| stable_partition | 相對穩定的使得符合某個條件的元素放在前面 |
比較函數：
當你需要按照某種特定方式進行排序時，你需要給sort指定比較函數，否則程序會自動提供給你一個比較函數
vector < int > vect;
sort(vect.begin(), vect.end());//此時相當于調用
sort(vect.begin(), vect.end(), less<int>() );
sort 中的其他比較函數
| equal_to | 相等 |
|---|---|
| not_equal_to | 不相等 |
| less | 小于 |
| greater | 大于 |
| less_equal | 小于等于 |
| greater_equal | 大于等于 |
上述例子中系統自己為sort提供了less仿函數。在STL中還提供了其他仿函數，以下是仿函數列表: 不能直接寫入仿 函數的名字，而是要寫其重載的()函數： less<int>();
當你的容器中元 素時一些標準類型（int float char)或者string時，你可以直接使用這些函數模板。但如果你時自己定義的類型或者你需要按照其他方式排序，你可以有兩種方法來達到效果：一種是自己寫比較函數。另一種是重載類型的'<'操作賦。
全排序：
全排序即把所給定范圍所有的元素按照大小關系順序排列。sort采用的是成熟的"快速排序算法"(目前大部分STL版本已經不是采用簡單的快速排序，而是結合內插排序算法)。復雜度為nlog2n。stable_sort采用的是"歸并排序"，分派足夠內存時，其算法復雜度為nlog2n, 否則 其復雜度為nlog2n*log2n，其優點是會保持相等元素之間的相對位置在排序前后保持一致。
用于全排序的函 數有：
void sort(RandomAccessIterator first, RandomAccessIterator last);void sort(RandomAccessIterator first, RandomAccessIterator last,StrictWeakOrdering comp);void stable_sort(RandomAccessIterator first, RandomAccessIterator last);void stable_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp);
局部排序：
partial_sort采用的堆排序（heapsort），它在任何情況下的復雜度都是nlog2n。
局部排序其實是為了減少不必要的操作而提供的排序方式。
其函數原型為：
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,RandomAccessIterator last);void partial_sort(RandomAccessIterator first,RandomAccessIterator middle,RandomAccessIterator last, StrictWeakOrdering comp);RandomAccessIterator partial_sort_copy(InputIterator first, InputIteratorlast,RandomAccessIteratorresult_first,RandomAccessIterator result_last);RandomAccessIterator partial_sort_copy(InputIterator first, InputIteratorlast,RandomAccessIteratorresult_first,RandomAccessIterator result_last, Compare comp);
例如：班上有1000個學生，我想知道分數最低的5名是哪些人。
partial_sort(vect.begin(),vect.begin()+5,vect.end(),less<student>());
nth_element 指定元素排序
void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);void nth_element(RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last,StrictWeakOrdering comp);
例如：班上有1000個學生，我想知道分數排在倒數第4名的學生。
nth_element(vect.begin(), vect.begin()+3, vect.end(),less<student>());
partition 和stable_partition
partition就是把一個區間中的元素按照某個條件分成兩類，并沒有排序。
其函數原型為：
ForwardIterator partition(ForwardIterator first, ForwardIterator last, Predicate pred)ForwardIterator stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
例如：班上10個學生，計算所有沒有及格（低于60分）的學生：
student exam("pass", 60);
stable_partition(vect.begin(), vect.end(), bind2nd(less<student>(), exam));
效率由高到低（耗時由小變大）
partion | |
-----|
stable_partition |
nth_element|
partial_sort|
sort|
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排序。
