c++11新增加了一些便利的算法，這些新增的算法使我們的代碼寫起來更簡潔方便，這裡僅僅列舉一些常用的新增算法，算是做個總結，更多的新增算法讀者可以參考http://en.cppreference.com/w/cpp/algorithm。
算法庫新增了三個用於判斷的算法all_of、any_of和none_of：
template< class InputIt, class UnaryPredicate > bool all_of( InputIt first, InputIt last, UnaryPredicate p ); template< class InputIt, class UnaryPredicate > bool any_of( InputIt first, InputIt last, UnaryPredicate p ); template< class InputIt, class UnaryPredicate > bool none_of( InputIt first, InputIt last, UnaryPredicate p );
下面是這幾個算法的示例：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
vector<int> v = { 1, 3, 5, 7, 9 };
auto isEven = [](int i){return i % 2 != 0;
bool isallOdd = std::all_of(v.begin(), v.end(), isEven);
if (isallOdd)
cout << "all is odd" << endl;
bool isNoneEven = std::none_of(v.begin(), v.end(), isEven);
if (isNoneEven)
cout << "none is even" << endl;
vector<int> v1 = { 1, 3, 5, 7, 8, 9 };
bool anyof = std::any_of(v1.begin(), v1.end(), isEven);
if (anyof)
cout << "at least one is even" << endl;
}
輸出：
all is odd none is odd at least one is even
算法庫的查找算法新增了一個find_if_not，它的含義和find_if是相反的，即查找不符合某個條件的元素，find_if也可以實現find_if_not的功能，只需要將判斷式改為否定的判斷式即可，現在新增了find_if_not之後，就不需要再寫否定的判斷式了，可讀性也變得更好。下面是它的基本用法：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
vector<int> v = { 1, 3, 5, 7, 9,4 };
auto isEven = [](int i){return i % 2 == 0;};
auto firstEven = std::find_if(v.begin(), v.end(), isEven);
if (firstEven!=v.end())
cout << "the first even is " <<* firstEven << endl;
//用find_if來查找奇數則需要重新寫一個否定含義的判斷式
auto isNotEven = [](int i){return i % 2 != 0;};
auto firstOdd = std::find_if(v.begin(), v.end(),isNotEven);
if (firstOdd!=v.end())
cout << "the first odd is " <<* firstOdd << endl;
//用find_if_not來查找奇數則無需新定義判斷式
auto odd = std::find_if_not(v.begin(), v.end(), isEven);
if (odd!=v.end())
cout << "the first odd is " <<* odd << endl;
}
將輸出：
the first even is 4 the first odd is 1 the first odd is 1
可以看到使用find_if_not不需要再定義新的否定含義的判斷式了，更簡便了。
算法庫還增加了一個copy_if算法，它相比原來的copy算法多了一個判斷式，用起來更方便了，下面是它的基本用法：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
vector<int> v = { 1, 3, 5, 7, 9, 4 };
std::vector<int> v1(v.size());
//根據條件拷貝
auto it = std::copy_if(v.begin(), v.end(), v1.begin(), [](int i){return i%2!=0;});
//縮減vector到合適大小
v1.resize(std::distance(v1.begin(),it));
for(int i : v1)
{
cout<<i<<" ";
}
cout<<endl;
}
算法庫新增了iota用來方便的生成有序序列，比如我們需要一個定長數組，這個數組中的元素都是在某一個數值的基礎之上遞增的，那麼用iota可以很方便的生成這個數組了。下面是它的基本用法：
#include <numeric>
#include <array>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int> v(4) ;
//循環遍歷賦值來初始化數組
//for(int i=1; i<=4; i++)
//{
// v.push_back(i);
//}
//直接通過iota初始化數組，更簡潔
std::iota(v.begin(), v.end(), 1);
for(auto n: v) {
cout << n << ' ';
}
cout << endl;
std::array<int, 4> array;
std::iota(array.begin(), array.end(), 1);
for(auto n: array) {
cout << n << ' ';
}
std::cout << endl;
}
將輸出：
1 2 3 4 1 2 3 4
可以看到使用iota比遍歷賦值來初始化數組更簡潔，需要注意的是iota初始化的序列需要指定大小，如果上面的代碼中：vector<int> v(4) ;沒有指定初始化大小為4的話，則輸出為空。
算法庫還新增了一個同時獲取最大值和最小值的算法minmax_element，這樣我們如果想獲取最大值和最小值的時候就不用分別調用max_element和max_element算法了，用起來會更方便，minmax_element會將最小值和最大值的迭代器放到一個pair中返回，下面是它的基本用法：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
// your code goes here
vector<int> v = { 1, 2, 5, 7, 9, 4 };
auto result = minmax_element(v.begin(), v.end());
cout<<*result.first<<" "<<*result.second<<endl;
return 0;
}
將輸出：
1 9
算法庫新增了is_ sorted和is_ sorted_until算法，is_sort用來判斷某個序列是否是排好序的，is_sort_until則用來返回序列中前面已經排好序的部分序列。下面是它們的基本用法：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
vector<int> v = { 1, 2, 5, 7, 9, 4 };
auto pos = is_sorted_until(v.begin(), v.end());
for(auto it=v.begin(); it!=pos; ++it)
{
cout<<*it<< " ";
}
cout<<endl;
bool is_sort = is_sorted(v.begin(), v.end());
cout<< is_sort<<endl;
return 0;
}
將輸出：
1 2 5 7 9 0
總結：這些新增的算法讓我們用起來更加簡便，也增強了代碼的可讀性。
一、什麼是算法
算法是一系列解決問題的清晰指令，也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。算法常常含有重復的步驟和一些比較或邏輯判斷。如果一個算法有缺陷，或不適合於某個問題，執行這個算法將不會解決這個問題。不同的算法可能用不同的時間、空間或效率來完成同樣的任務。一個算法的優劣可以用空間復雜度與時間復雜度來衡量。
算法的時間復雜度是指算法需要消耗的時間資源。一般來說，計算機算法是問題規模n 的函數f(n)，算法執行的時間的增長率與f(n) 的增長率正相關，稱作漸進時間復雜度（Asymptotic Time Complexity）。時間復雜度用“O（數量級）”來表示，稱為“階”。常見的時間復雜度有： O（1）常數階；O（log2n）對數階；O（n）線性階；O（n2）平方階。
算法的空間復雜度是指算法需要消耗的空間資源。其計算和表示方法與時間復雜度類似，一般都用復雜度的漸近性來表示。同時間復雜度相比，空間復雜度的分析要簡單得多。
二、算法設計的方法
1.遞推法
遞推法是利用問題本身所具有的一種遞推關系求問題解的一種方法。設要求問題規模為N的解，當N=1時，解或為已知，或能非常方便地得到解。能采用遞推法構造算法的問題有重要的遞推性質，即當得到問題規模為i-1的解後，由問題的遞推性質，能從已求得的規模為1，2，…，i-1的一系列解，構造出問題規模為I的解。這樣，程序可從i=0或i=1出發，重復地，由已知至i-1規模的解，通過遞推，獲得規模為i的解，直至得到規模為N的解。
【問題】 階乘計算
問題描述：編寫程序，對給定的n（n≤100），計算並輸出k的階乘k！（k=1，2，…，n）的全部有效數字。
由於要求的整數可能大大超出一般整數的位數，程序用一維數組存儲長整數，存儲長整數數組的每個元素只存儲長整數的一位數字。如有m位成整數N用數組a[ ]存儲：
N=a[m]×10m-1+a[m-1]×10m-2+ … +a[2]×101+a[1]×100
並用a[0]存儲長整數N的位數m，即a[0]=m。按上述約定，數組的每個元素存儲k的階乘k！的一位數字，並從低位到高位依次存於數組的第二個元素、第三個元素……。例如，5！=120，在數組中的存儲形式為：
3 0 2 1 ……
首元素3表示長整數是一個3位數，接著是低位到高位依次是0、2、1，表示成整數120。
計算階乘k！可采用對已求得的階乘(k-1)！連續累加k-1次後求得。例如，已知4！=24，計算5！，可對原來的24累加4次24後得到120。細節見以下程序。
# include <stdio.h>
# include <malloc.h>
......
2.遞歸
遞歸是設計和描述算法的一種有力的工具，由於它在復雜算法的描述中被經常采用，為此在進一步介紹其他算法設計方法之前先討論它。
能采用遞歸描述的算法通常有這樣的特征：為求解規模為N的問題，設法將它分解成規模較小的問題，然後從這些小問題的解方便地構造出大問題的解，並且這些規模較小的問題也能采用同樣的分解和綜合方法，分解成規模更小的問題，並從這些更小問題的解構造出規模較大問題的解。特別地，當規模N=1時，能直接得解。
【問題】 編寫計算斐波那契（Fibonacci）數列的第n項函數fib（n）。
斐波那契數列為：0、1、1、2、3、……，即：
fib(0)=0;
fib(1)=1;
fib(n)=fib(n-1)+fib(n-2) （當n>1時）。
寫成遞歸函數有：
int ......余下全文>>
網上多的是
自己搜索一下,
樓主在讀大學嗎, 圖書管很多這樣的書啊,
看實體書,比網上閱讀還是好一些.
