2. 程式人生 > >STL演算法---排序演算法(二)

STL演算法---排序演算法(二)

阿新 • • 發佈：2019-01-04

4. random_shuffle(隨機調整次序)

對指定範圍內的元素隨機調整次序。
過載版本輸入一個隨機數產生操作
函式原形
template<class RanIt> void random_shuffle(RanIt first, RanIt last);
template<class RanIt, class Fun> void random_shuffle(RanIt first, RanIt last, Fun& f);
/////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	std::random_shuffle(nV1.begin(), nV1.end());
	// 排序後: 19, 16, -1, 15, 14, 19, 27, 11, 10, -2, 24, 13

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	std::random_shuffle(nV1.begin(), nV1.end());
	// 排序後: 19, 10, 16, 24, 15, 13, -1, 19, 11, 27, -2, 14
	
	return 0;
}

5. reverse / reverse_copy(反序排序)

5.1 reverse

將指定範圍內元素重新反序排序
函式原形
template<class BidIt> void reverse(BidIt first, BidIt last);


5.2 reverse_copy

與reverse類似，不過將結果寫入另一個容器
函式原形
template<class BidIt, class OutIt> OutIt reverse_copy(BidIt first, BidIt last, OutIt x);

/////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	std::reverse(nV1.begin(), nV1.end());
	// 排序後: 19, 19, -1, 24, 27, -2, 13, 10, 11, 15, 16, 14

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前nV1: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	nV2.resize(nV1.size());
	iter = std::reverse_copy(nV1.begin(), nV1.end(), nV2.begin());
	// 排序前nV1: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	// 排序後nV2: 19, 19, -1, 24, 27, -2, 13, 10, 11, 15, 16, 14, end(iter)

	return 0;
}

6. sort/ stable_sort

6.1 sort

以升序重新排列指定範圍內的元素。
過載版本使用自定義的比較操作
函式原形
template<class RanIt> void sort(RanIt first, RanIt last);
template<class RanIt, class Pred> void sort(RanIt first, RanIt last, Pred pr);


6.2 stable_sort

與sort類似，但保留相等元素之間的順序關係
函式原形
template<class BidIt> void stable_sort(BidIt first, BidIt last);
template<class BidIt, class Pred> void stable_sort(BidIt first, BidIt last, Pred pr);


/////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	std::sort(nV1.begin(), nV1.end());
	// 排序後: -2, -1, 10, 11, 13, 14, 15, 16, 19, 19, 24, 27

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10, 13, -2, 27, 24, -1, 19, 19
	std::stable_sort(nV1.begin(), nV1.end());
	// 排序後: -2, -1, 10, 11, 13, 14, 15, 16, 19, 19, 24, 27
	return 0;
}

7. rotate / rotate_copy

7.1 rotate

把[first, middle)的元素拷貝到last的後面; 或者說把[middle, last)的元素拷貝到first的前面.
template<class FwdIt> void rotate(FwdIt first, FwdIt middle, FwdIt last);

7.2 rotate_copy

與rotate類似，不過將結果寫入另一個容器
函式原形
template<class FwdIt, class OutIt> OutIt rotate_copy(FwdIt first, FwdIt middle, FwdIt last, OutIt x);
/////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);

	// 排序前: 14, 16, 15, 11, 10(middle), 13, -2, 27, 24, -1, 19, 19
	std::rotate(nV1.begin(), nV1.begin() + 4, nV1.end());
	// 排序後: 10, 13, -2, 27, 24, -1, 19, 19, 14, 16, 15, 11

	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(15);
	nV1.push_back(11);
	nV1.push_back(10);
	nV1.push_back(13);
	nV1.push_back(-2);
	nV1.push_back(27);
	nV1.push_back(24);
	nV1.push_back(-1);
	nV1.push_back(19);
	nV1.push_back(19);
	nV2.resize(nV1.size());
	// 排序前: 14, 16, 15, 11, 10(middle), 13, -2, 27, 24, -1, 19, 19
	std::rotate_copy(nV1.begin(), nV1.begin() + 4, nV1.end(), nV2.begin());
	// 排序後nV2: 10, 13, -2, 27, 24, -1, 19, 19, 14, 16, 15, 11, end(iter)

	return 0;
}

8. inplace_merge / merge

8.1 inplace_merge

合併兩個有序序列，結果序列覆蓋兩端範圍。
過載版本使用輸入的操作進行排序
函式原形
template<class BidIt> void inplace_merge(BidIt first, BidIt middle, BidIt last);
template<class BidIt, class Pred> void inplace_merge(BidIt first, BidIt middle, BidIt last, Pred pr);

8.2 merge

合併兩個有序序列，存放到另一個序列。過載版本使用自定義的比較
函式原形
template<class InIt1, class InIt2, class OutIt> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x);
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x, Pred pr);

/////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1, nV3;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(7);		// --
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);

	// nV1中包含了兩組有序序列
	// 排序前: 12, 13, 14, 15, 50, 7(middle), 23, 27, 28, 30, 34, 35, 37
	std::inplace_merge(nV1.begin(), nV1.begin() + 5, nV1.end());
	// 排序後: 7, 12, 13, 14, 15, 23, 27, 28, 30, 34, 35, 37, 50

	// 升序
	nV1.clear();
	nV1.push_back(14);
	nV1.push_back(16);
	nV1.push_back(18);
	nV1.push_back(20);

	// 升序
	nV2.clear();
	nV2.push_back(-2);
	nV2.push_back(13);
	nV2.push_back(20);
	nV2.push_back(25);
	nV2.push_back(26);
	nV3.resize(nV1.size() + nV2.size());
	iter = std::merge(nV1.begin(), nV1.end(), nV2.begin(), nV2.end(), nV3.begin());
	// 排序後nV3: -2, 13, 14, 16, 18, 20, 20, 25, 26, end(iter)
	return 0;
}

相關推薦

STL演算法---排序演算法(二)

4. random_shuffle(隨機調整次序) 對指定範圍內的元素隨機調整次序。 過載版本輸入一個隨機數產生操作 函式原形 template<class RanIt> void random_shuffle(RanIt first, RanIt last);

STL之排序演算法

1.merge() 以下是排序和通用演算法：提供元素排序策略 merge: 合併兩個有序序列，存放到另一個序列。 例如： vecIntA,vecIntB,vecIntC是用vector宣告的容器，vecIntA已包含1,3,5,7,9元素，vecIntB已包含2,4,6,8元素

STL is_sorted排序演算法

排序是要耗費時間的，尤其是在有大量元素時。測試元素段是否已經排好序可以避免不必要的排序操作。如果兩個迭代器引數所指定範圍內的元素是升序排列的，函式模板 is_sorted() 就會返回 true。 為了能夠順序處理元素，迭代器至少需要是正向迭代器。提醒一下，正向迭代器支援字首和字尾形式的自增

STL nth_element排序演算法

nth_element() 演算法和 partial_sort() 不同。應用的範圍由它的第一個和第三個引數指定。第二個引數是一個指向第 n 個元素的迭代器。如果這個範圍內的元素是完全有序的，nth_dement() 的執行會導致第 n 個元素被放置在適當的位置。這個範圍內，在第 n 個元素之前

STL partial_sort排序演算法

通過示例很容易理解什麼是部分排序。假設有一個容器，它儲存了 100 萬個數值，但我們只對其中最小的 100 個感興趣。可以對容器的全部內容排序，然後選擇前 100 個元素，但這可能有點消耗時間。這時候需要使用部分排序，只需要這些數中的前100個是有序放置的。 對於部分排序，有一個特殊的演算法

STL stable_sort排序演算法

sort() 演算法可能會改變相等元素的順序，有時候這不是我們想要的。假設有一個儲存某種事務的容器，或許是銀行賬戶。進一步假設，在處理它們之前，為了能夠有序更新這些賬戶，需要按照賬號對這些事務排序。如果出現相等事務的順序反映的是它們新增到容器的時間順序，就需要維持這個順序不變。如果允許對給定賬戶

STL is_permutation排序演算法

is_permutation() 演算法可以用來檢查一個序列是不是另一個序列的排列，如果是，會返回 true。下面是在這個演算法中使用 lambda 表示式的示例： std::vector<double> data1{ 44.5, 22.0, 15.6, 1.5 }; std::

STL sort排序演算法詳細介紹

                C++之所以得到這麼多人的喜歡，是因為它既具有面向物件的概念，又保持了C語言高效的特點。STL 排序演算法同樣需要保持高效。因此，對於不同的需求，STL提供的不同的函式，不同的函式，實現的演算法又不盡相同。1.1 所有sort演算法介紹所有的sort演算法的引數都需要輸入一個範

整理：STL sort排序演算法詳細介紹

一切複雜的排序操作，都可以通過STL方便實現 ! 0 前言: STL，為什麼你必須掌握 對於程式設計師來說，資料結構是必修的一門課。從查詢到排序，從連結串列到二叉樹，幾乎所有的演算法和原理都需要理解，理解不了也要死記硬背下來。幸運的是這些理論都已經比較成熟，演算法也基本

排序演算法之選擇排序（關鍵詞：資料結構/演算法/排序演算法/選擇排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 選擇排序演算法 程式碼 from swap import swap def select_sort(nums): n = len(nums) i = 0 while

排序演算法之插入排序（關鍵詞：資料結構/演算法/排序演算法/插入排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 插入排序演算法 程式碼 def insert_sort(nums): i = 1 n = len(nums) while i <= n-1: j = i

排序演算法之氣泡排序（關鍵詞：資料結構/演算法/排序演算法/氣泡排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 氣泡排序演算法 程式碼 from swap import swap def bubble_sort(nums): n = len(nums) for i in rang

演算法——排序演算法——計數排序優化

在前幾篇部落格中講了計數排序的一般方法，理解起來比較簡單。但是上一次提到的計數排序只是簡單的按照陣列下標統計輸出了元素的值，並沒有真正將原來的資料進行排序。在日常的使用當中，往往會出現相同的資料進行排序，如果還使用前幾篇的方法就會發現有些力不從心了，下面來說說如何對計數排序進行優化。 比如說有幾

演算法 排序演算法的穩定性

排序與搜尋 排序演算法（英語：Sorting algorithm）是一種能將一串資料依照特定順序進行排列的一種演算法。 排序演算法的穩定性 穩定性：穩定排序演算法會讓原本有相等鍵值的紀錄維持相對次序。也就是如果一個排序演算法是穩定的，當有兩個相等鍵值的紀錄R和S，且在原本的列表中R出現在

排序演算法之快速排序（關鍵詞：資料結構/演算法/排序演算法/快速排序）

快速排序 實現 def partition(nums, left, right): middle = (left+right) // 2 pivot = nums[middle] swap(nums, middle, right) # 現在主元 pivot 等於 num

排序演算法之歸併排序（關鍵詞：資料結構/演算法/排序演算法/歸併排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 歸併排序演算法 程式碼 def merge(a, b): res = [] A = 0 B = 0 while A<len(a) and B<len(b

排序演算法之堆排序（關鍵詞：資料結構/演算法/排序演算法/堆排序）

假定：有 1 個亂序的數列 nums ，其中有 n 個數。 要求：排好序之後是 從小到大 的順序。 堆排序演算法 原理 先將原始的堆，調整為最大堆： 從倒數第 1 個有子結點的結點(下標為 index = n//2 - 1)開始，將以結點 index 為根結點的子堆

最全的最通俗易懂的演算法——排序演算法【1】

1、氣泡排序 氣泡排序的基本思想就是：從無序序列頭部開始，進行兩兩比較，根據大小交換位置，直到最後將最大（小）的資料元素交換到了無序佇列的隊尾，從而成為有序序列的一部分；下一次繼續這個過程，直到所有資料元素都排好序。 # python [升序的排序] s = [3,4

資料結構與演算法——排序演算法之快速排序

資料結構與演算法——排序演算法之快速排序 快速排序定義 快速排序由C. A. R. Hoare在1962年提出通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行

演算法 排序演算法之基數排序

基數排序 基數排序也稱作桶排序，是一種當關鍵字為整數型別時非常高效的排序方法。 基本思想 設待排序的元素是m位d進位制整（不足m位的關鍵字在高位補0），設定d個桶，令其編號分別為0，1，2…d-1。 首先元素最低位的數值一次把各個元素放到相應的桶