常用拷貝和替換算法

copy——容器內指定范圍的元素拷貝到另一容器中

函數原型

• copy(iterator beg, iterator end, iterator dest);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回結束迭代器位置

  // beg 開始迭代器

  // end 結束迭代器

  // dest 目標起始迭代器

注意——利用copy算法在拷貝時，目標容器要提前開辟空間

示例

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> source {1, 2, 3, 4, 5};std::vector<int> destination(5);  // 提前開辟目標容器空間std::copy(source.begin(), source.end(), destination.begin());// 輸出目標容器中的內容for (auto i : destination) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：1 2 3 4 5

在上面的示例中，我們首先創建了一個源容器source，其中包含了一些整數。然后，我們創建了一個與源容器相同大小的目標容器destination，并且提前開辟了空間。

接下來，我們使用std::copy算法將源容器中的元素拷貝到目標容器中。通過傳遞源容器的迭代器source.begin()和source.end()以及目標容器的起始迭代器destination.begin()作為參數，實現了拷貝操作。

最后，遍歷目標容器，并打印其中的元素

replace——將容器內指定范圍的第一個舊元素修改為新元素

函數原型

• replace(iterator beg, iterator end, oldvalue, newvalue);

  // 將區間內舊元素 替換成 新元素

  // beg 開始迭代器

  // end 結束迭代器

  // oldvalue 舊元素

  // newvalue 新元素

注意——replace只會替換區間內滿足條件的第一個舊元素

示例

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec {1, 2, 3, 4, 5};std::replace(vec.begin(), vec.end(), 3, 9);// 輸出修改后的容器內容for (auto i : vec) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
1 2 9 4 5

在上面的示例中，我們首先創建了一個整數向量vec，其中包含了一些整數。然后，我們使用std::replace算法將容器中的舊元素3替換為新元素9。

通過傳遞容器的起始迭代器vec.begin()和結束迭代器vec.end()作為參數，以及要替換的舊元素3和新元素9，實現了替換操作。

最后，我們遍歷容器，并打印其中的元素，可以看到被替換的元素已經被修改為新元素。

replace_if——在指定范圍內將所有舊元素修改為新元素

函數原型

• **replace_if(iterator beg, iterator end, _pred, newvalue); **

  // 按條件替換元素，滿足條件的替換成指定元素

  // beg 開始迭代器

  // end 結束迭代器

  // _pred 謂詞,謂詞函數是一個返回布爾值的函數，用于確定元素是否滿足某個條件。

  // 注意謂語是返回bool的仿函數，是謂詞，是一個類，不是函數，但是可以當函數用
  // 因此可以利用仿函數靈活篩選滿足的條件

  // newvalue 替換的新元素

注意——replace會替換區間內滿足條件的所有舊元素

示例：

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec {1, 2, 3, 4, 5};std::replace_if(vec.begin(), vec.end(), [](int num){ return num == 3; }, 9);// 輸出修改后的容器內容for (auto i : vec) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
1 2 9 4 5

在這個示例中，我們使用了一個匿名的lambda函數作為謂詞函數來判斷元素是否需要被替換。lambda函數接受一個整數參數num，并返回一個bool值，判斷這個整數是否等于3。如果等于3，則將其替換為新元素9。

通過使用lambda函數作為謂詞函數，我們可以自定義替換的條件。在上述示例中，我們使用等于3的元素作為替換的條件。

需要注意的是，replace_if函數只會替換滿足條件的第一個元素，如果想要替換所有滿足條件的元素，可以考慮使用std::replace_copy_if或自定義循環進行處理。

swap——互換兩個容器的元素

函數原型

• swap(container c1, container c2);

  // 互換兩個容器的元素

  // c1容器1

  // c2容器2

注意——swap交換容器時，注意交換的容器要同種類型

交換不同類型的容器，將會導致編譯錯誤。

類型要匹配

要交換的容器類型要相同，或者滿足可以進行隱式轉換的條件。例如，兩個 std::vector<int> 可以直接交換，但是 std::vector<int> 和 std::vector<double> 之間不能直接交換。

容器的狀態

交換容器時，要確保容器處于有效狀態，即它們不應被移動、釋放或銷毀。否則，交換操作可能會導致未定義行為。

迭代器的失效

交換容器后，原來容器中的迭代器將會失效。如果有其他依賴于這些迭代器的代碼，則需要謹慎處理，避免使用失效的迭代器。

容器的大小和內存開銷

交換容器實際上是交換了它們的內部數據結構，這意味著會涉及到元素的復制或移動操作。如果容器的大小較大，交換操作可能會帶來顯著的內存開銷和性能損失。

異常安全性

交換容器可能會引發異常，因此在交換操作之前，要考慮異常安全性，采取適當的措施來處理異常，以確保程序能夠正常執行。

示例

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec1 {1, 2, 3};std::vector<int> vec2 {4, 5, 6};swap(vec1, vec2);// 輸出交換后的vec1std::cout << "vec1: ";for (auto i : vec1) {std::cout << i << " ";}std::cout << std::endl;// 輸出交換后的vec2std::cout << "vec2: ";for (auto i : vec2) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
vec1: 4 5 6
vec2: 1 2 3

在這個示例中，我們創建了兩個vector類型的容器vec1和vec2。
然后，通過調用swap函數來交換這兩個容器的元素。最
終，vec1中的元素變成了4, 5, 6，vec2中的元素變成了1, 2, 3。

常用算術生成算法

注意——算術生成算法屬于小型算法，使用時包含的頭文件為 #include <numeric>

accumulate—— 計算區間內容器元素累計總和

函數原型

• accumulate(iterator beg, iterator end, value);

  // 計算容器元素累計總和

  // beg 開始迭代器

  // end 結束迭代器

  // value 起始值
  //起始值value是可選的，如果不提供該參數，那么默認起始值將是容器中的第一個元素的值。（看下面例子）

注意——如果容器為空，而且沒有提供起始值參數，則調用accumulate函數會導致未定義行為

所以，在使用accumulate函數時，建議在累加之前檢查容器是否非空，或者提供一個明確的起始值參數。

示例

#include <iostream>
#include <vector>
#include <numeric>int main() {std::vector<int> vec {1, 2, 3, 4, 5};int sum = std::accumulate(vec.begin(), vec.end());std::cout << "Sum: " << sum << std::endl;return 0;
}

輸出結果為：
Sum: 15

在這個示例中，我們調用了accumulate函數來計算容器vec中元素的累計總和，但沒有提供起始值參數。由于沒有指定起始值，accumulate函數會使用容器中的第一個元素作為起始值進行累加運算。

因此，根據示例中的容器vec，累計總和仍然是15。

fill——用于將指定范圍內的元素都設置為給定的值

函數原型

• fill(iterator beg, iterator end, value);

  // 向容器中填充元素

  // beg 開始迭代器

  // end 結束迭代器

  // value 填充的值

注意——fill函數會將指點范圍內所有元素都填充為給定的值，原本已的值會被覆蓋。

示例

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec {1, 2, 3, 4, 5};std::fill(vec.begin(), vec.end(), 10);// 輸出填充后的向量std::cout << "Filled Vector: ";for (auto i : vec) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：

Filled Vector: 10 10 10 10 10
在這個示例中，我們有一個包含初始值的向量vec，其中包含了數字1到5。然后，我們使用fill函數將容器vec中的所有元素都填充為10。

最終的輸出結果顯示，原本向量中的元素已經被覆蓋，全部變成了10, 10, 10, 10, 10。

因此，需要注意，在使用fill函數時，如果你希望保留原有元素的值，只填充指定范圍內的部分元素，可以使用更具靈活性的方法，如迭代器和算法結合使用來實現部分填充。

常用集合算法

set_intersection——求兩個容器的交集

set_intersection 函數通常用于計算兩個有序集合的交集。
但是，它實際上可以用于任何支持隨機訪問的序列容器，而不僅限于集合。

函數原型

• set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
  // beg1 容器1開始迭代器
  // end1 容器1結束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結束迭代器
  // dest 目標容器開始迭代器

總結

• 求交集的兩個集合必須是有序序列
• 目標容器開辟空間需要從兩個容器中取小值
• set_intersection返回值既是交集中最后一個元素的位置

示例：

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec1 {1, 2, 3, 4, 5};std::vector<int> vec2 {3, 4, 5, 6, 7};std::vector<int> intersection(std::min(vec1.size(), vec2.size()));auto it = std::set_intersection(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), intersection.begin());// 輸出交集中的元素std::cout << "Intersection: ";for (auto i = intersection.begin(); i != it; ++i) {std::cout << *i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
Intersection: 3 4 5

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數。我們需要找出這兩個向量的交集。

首先，我們創建了一個目標容器intersection，它的大小為兩個輸入容器中較小的那個。

然后，使用set_intersection函數將兩個輸入容器中的交集復制到目標容器intersection中。set_intersection函數接受五個參數，分別是兩個輸入容器的起始和結束迭代器，以及目標容器的起始迭代器。這樣，交集中的元素就會復制到目標容器中。

最后，我們遍歷目標容器中的元素，并輸出交集中的值。

set_union——求兩個集合的并集

函數原型

• set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // beg1 容器1開始迭代器
  // end1 容器1結束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結束迭代器
  // dest 目標容器開始迭代器

總結（和set_intersection差不多）

• 求并集的兩個集合必須的有序序列
• 目標容器開辟空間需要兩個容器相加
• set_union返回值既是并集中最后一個元素的位置

示例

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec1 {1, 2, 3, 4, 5};std::vector<int> vec2 {3, 4, 5, 6, 7};std::vector<int> unionSet(vec1.size() + vec2.size());auto it = std::set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), unionSet.begin());// 輸出并集中的元素std::cout << "Union: ";for (auto i = unionSet.begin(); i != it; ++i) {std::cout << *i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
Union: 1 2 3 4 5 6 7

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數。我們需要找出這兩個向量的并集。

首先，我們創建了一個目標容器unionSet，它的大小為兩個輸入容器的總大小。

然后，使用set_union函數將兩個輸入容器中的并集復制到目標容器unionSet中。
set_union函數接受五個參數，分別是兩個輸入容器的起始和結束迭代器，以及目標容器的起始迭代器。這樣，并集中的元素就會復制到目標容器中。

最后，我們遍歷目標容器中的元素，并輸出并集中的值。

set_difference——求兩個集合的差集

函數原型

• set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // beg1 容器1開始迭代器
  // end1 容器1結束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結束迭代器
  // dest 目標容器開始迭代器

總結（都差不多）

• 求差集的兩個集合必須的有序序列
• 目標容器開辟空間需要從兩個容器取較大值
• set_difference返回值既是差集中最后一個元素的位置

示例：

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> vec1 {1, 2, 3, 4, 5};std::vector<int> vec2 {3, 4, 5, 6, 7};std::vector<int> difference(std::max(vec1.size(), vec2.size()));auto it = std::set_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), difference.begin());// 輸出差集中的元素std::cout << "Difference: ";for (auto i = difference.begin(); i != it; ++i) {std::cout << *i << " ";}std::cout << std::endl;return 0;
}

輸出結果為：
Difference: 1 2

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數。我們需要找出這兩個向量的差集。

首先，我們創建了一個目標容器difference，它的大小為兩個輸入容器中較大的那個。

然后，使用set_difference函數將兩個輸入容器中的差集復制到目標容器difference中。
set_difference函數接受五個參數，分別是兩個輸入容器的起始和結束迭代器，以及目標容器的起始迭代器。這樣，差集中的元素就會復制到目標容器中。

最后，我們遍歷目標容器中的元素，并輸出差集中的值。