項目常用演算法

① 以下哪個是目前區塊鏈項目的主流演算法

拜占庭協定、非對稱加密技術、容錯問題、Paxos 演算法（一致性演算法）、共識機制、分布式存儲

② 程序員都應該精通的六種演算法，你會了嗎

對於一名優秀的程序員來說，面對一個項目的需求的時候，一定會在腦海里浮現出最適合解決這個問題的方法是什麼，選對了演算法，就會起到事半功倍的效果，反之，則可能會使程序運行效率低下，還容易出bug。因此，熟悉掌握常用的演算法，是對於一個優秀程序員最基本的要求。

那麼，常用的演算法都有哪些呢？一般來講，在我們日常工作中涉及到的演算法，通常分為以下幾個類型：分治、貪心、迭代、枚舉、回溯、動態規劃。下面我們來一一介紹這幾種演算法。

一、分治演算法

分治演算法，顧名思義，是將一個難以直接解決的大問題，分割成一些規模較小的相同問題，以便各個擊破，分而治之。

分治演算法一般分為三個部分：分解問題、解決問題、合並解。

分治演算法適用於那些問題的規模縮小到一定程度就可以解決、並且各子問題之間相互獨立，求出來的解可以合並為該問題的解的情況。

典型例子比如求解一個無序數組中的最大值，即可以採用分治演算法，示例如下：

def pidAndConquer(arr,leftIndex,rightIndex):

if(rightIndex==leftIndex+1 || rightIndex==leftIndex){

return Math.max(arr[leftIndex],arr[rightIndex]);

}

int mid=(leftIndex+rightIndex)/2;

int leftMax=pidAndConquer(arr,leftIndex,mid);

int rightMax=pidAndConquer(arr,mid,rightIndex);

return Math.max(leftMax,rightMax);

二、貪心演算法

貪心演算法是指在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，他所做出的僅是在某種意義上的局部最優解。

貪心演算法的基本思路是把問題分成若干個子問題，然後對每個子問題求解，得到子問題的局部最優解，最後再把子問題的最優解合並成原問題的一個解。這里要注意一點就是貪心演算法得到的不一定是全局最優解。這一缺陷導致了貪心演算法的適用范圍較少，更大的用途在於平衡演算法效率和最終結果應用，類似於：反正就走這么多步，肯定給你一個值，至於是不是最優的，那我就管不了了。就好像去菜市場買幾樣菜，可以經過反復比價之後再買，或者是看到有賣的不管三七二十一先買了，總之最終結果是菜能買回來，但搞不好多花了幾塊錢。

典型例子比如部分背包問題：有n個物體，第i個物體的重量為Wi，價值為Vi，在總重量不超過C的情況下讓總價值盡量高。每一個物體可以只取走一部分，價值和重量按比例計算。

貪心策略就是，每次都先拿性價比高的，判斷不超過C。

三、迭代演算法

迭代法也稱輾轉法，是一種不斷用變數的舊值遞推新值的過程。迭代演算法是用計算機解決問題的一種基本方法，它利用計算機運算速度快、適合做重復性操作的特點，讓計算機對一組指令(或一定步驟)進行重復執行，在每次執行這組指令(或這些步驟)時，都從變數的原值推出它的一個新值。最終得到問題的結果。

迭代演算法適用於那些每步輸入參數變數一定，前值可以作為下一步輸入參數的問題。

典型例子比如說，用迭代演算法計算斐波那契數列。

四、枚舉演算法

枚舉演算法是我們在日常中使用到的最多的一個演算法，它的核心思想就是:枚舉所有的可能。枚舉法的本質就是從所有候選答案中去搜索正確地解。

枚舉演算法適用於候選答案數量一定的情況。

典型例子包括雞錢問題，有公雞5，母雞3，三小雞1，求m錢n雞的所有可能解。可以採用一個三重循環將所有情況枚舉出來。代碼如下：

五、回溯演算法

回溯演算法是一個類似枚舉的搜索嘗試過程，主要是在搜索嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就「回溯」返回，嘗試別的路徑。

許多復雜的，規模較大的問題都可以使用回溯法，有「通用解題方法」的美稱。

典型例子是8皇後演算法。在8 8格的國際象棋上擺放八個皇後，使其不能互相攻擊，即任意兩個皇後都不能處於同一行、同一列或同一斜線上，問一共有多少種擺法。

回溯法是求解皇後問題最經典的方法。演算法的思想在於如果一個皇後選定了位置，那麼下一個皇後的位置便被限制住了，下一個皇後需要一直找直到找到安全位置，如果沒有找到，那麼便要回溯到上一個皇後，那麼上一個皇後的位置就要改變，這樣一直遞歸直到所有的情況都被舉出。

六、動態規劃演算法

動態規劃過程是：每次決策依賴於當前狀態，又隨即引起狀態的轉移。一個決策序列就是在變化的狀態中產生出來的，所以，這種多階段最優化決策解決問題的過程就稱為動態規劃。

動態規劃演算法適用於當某階段狀態給定以後，在這階段以後的過程的發展不受這段以前各段狀態的影響，即無後效性的問題。

典型例子比如說背包問題，給定背包容量及物品重量和價值，要求背包裝的物品價值最大。

③ 請問現在開發項目一般用到哪些加密演算法

現階段開發項目主要用到 BASE64 、 MD5 、 SHA 、 HMAC 幾種加密演算法。 BASE64 編碼演算法不算是真正的加密演算法。 MD5 、 SHA 、 HMAC 這三種加密演算法，可謂是非可逆加密，就是不可解密的加密方法，我們稱之為單向加密演算法。我們通常只把他們作為加密的基礎。單純的以上三種的加密並不可靠。 BASE64的加密解密是雙向的，可以求反解。 MD5、SHA以及HMAC是單向加密，任何數據加密後只會產生唯一的一個加密串，通常用來校驗數據在傳輸過程中是否被修改。其中HMAC演算法有一個密鑰，增強了數據傳輸過程中的安全性，強化了演算法外的不可控因素。 單向加密的用途主要是為了校驗數據在傳輸過程中是否被修改。

④ Unity3D開發 經常用到什麼演算法

第一，unity只是一個工具
第二，演算法和數據結構和具體的工具無關
第三，編程基本的算姿昌法無非是排序演算法、樹形結構、鏈表、隊列等
第四，演算法根據需要去使用，如果是做游戲，一堆的計算機圖形學知識需要掌握，如果做3d，必要的3d知識不能少。如果使用物理引擎，請學好各種物理知識。如果做渲染，請做好shader編程的知識儲備。
第五，unity提跡晌扒供了足夠多的功能，理解是前謹灶提，使用是基礎，融會貫通是目的

⑤ 幾種常用溫控演算法的比較與總結

        最近在做一個有關大氣VOCs實時監測的項目，由於該項目要求控溫精度在0.1度之內，所以就研究了一下有關溫控的演算法，我們知道對於一些大慣性的系統，比如加熱爐、智能小車中都會用到PID（比例、積分和微分）演算法，而PID演算法分為二值式、位置式、增量式和分段式，當然也有模糊式等。現根據在實際項目中的應用情況將其總結如下：

        （1）二值式

        二值式溫控演算法只存在兩個狀態，不是開，就是關。常用在一些控溫精度不高的場合。

        （2）位置式

        位置式PID演算法由於計算量比較大，降低了單片機的運行速度，需要單片機比較大的內存，所以在實際應用中應用的比較少，除非有特除要求的場合。

        （3）增量式

        增量式PID演算法相比二值式控溫精度比較高，相比位置式計算量減少了許多，提高了單片機的運行速度，也增大了單片機的選擇餘地（內存要求降低）。為了提高溫控的速度，減少溫控所需要的時間，所以該增加式PID演算法常與BangBang演算法、大林演算法相結合使用。BangBang演算法和大林演算法即是全功率加熱，比如BangBang-PID演算法通過會有一個閾值，一旦採用BangBang或大林演算法升溫到閾值時，就會自動切換到增量式PID演算法進行控溫。另外該閾值的選擇是個難點，閾值小了，升溫時間比較長，閾值大了，過沖量比較大，所以說該閾值的選擇需要從以下兩個方面去確定：升溫速率、距離設定值的差值大小等方面。

        （4）分段式

        分段式PID演算法雖然比模糊PID演算法差一些，但是模糊PID控制大多數還停留在理論階段，應用到實際系統的還比較少，控制效果如何還不是很確定。分段式PID演算法在某些方面與模糊式PID演算法有很多相近的地方，也是對信號進行閾值的劃分，然後在不同的閾值階段採用不同的控制參數。分段PID優於模糊PID的地方在於我們現有的工控機在編輯控制演算法時是數字式的，模糊PID演算法要想實現其功能除了要進行數據的離散化外，其用到的數據參數也比較多導致統計起來比較麻煩，經過以上對比分析，從系統的可實現性方面考慮，還是採用分段式PID演算法的比較多些。

        根據項目的實際控制結果表明單純的採用單一的PID參數進行調節要想達到較為理想的控制效果是不容易的。所以可以根據控制對象的實際情況及偏差的大小，在不同的控制階段給定不同的PID調節參數，這樣可以在偏差大的時候加大比例調節，降低積分作用，偏差小的時候減少比例作用，加大積分作用。這樣既可以增加響應速度，超調量也不會太大，這就是分段PID的控制思想。  下面對普通PID與分段PID在同一控制變數下做出的反應做一下對比，他們的輸出曲線如下圖：

        在上圖輸出曲線中可以看出在目標值情況相同的情況下，分段PID的響應速度更快，達到目標值時分段PID比普通PID所用的時間少一半，所用控制系統的快速性被分段PID明顯提高了。採用分段PID即是將一個控制過程進行分段控制，可以避免採用單一PID控制時對誤差積累較多的缺點（採用單一PID演算法時，剛開始啟動時目標值與實際值的差值會很大，如果有積分變數的話，積分變數大了會導致較大的積累偏差，導致消除困難，造成系統較大的系統超調；積分變數小了會導致精差消除較慢。），這樣在每一階段都對誤差進行消除，最後誤差結果會小很多。分段PID演算法的實現步驟：這里假定閾值a為偏差的50%，閾值b為偏差的30%。

        a、根據工程需要設置閾值a>b>0;

        b、當偏差較大，且偏差大於等於a時，採用PD控制，可加快系統響應；

        c、當偏差較小，且大於b，小於a時採用PI控制；

        d、當偏差小於b時，採用PID控制（P設的小些，I設的大些），可減少系統精差。

        以上是對幾種常用PID演算法的比較和總結，在實際的項目中用的比較多的是增量式PID演算法和分段式PID演算法，分段式PID算比單一的增量式PID演算法控溫速度快，精度更高，雖然分段PID演算法參數整定比較繁瑣些，但鑒於它的控制速度快、精度高，還是推薦使用分段PID演算法應用於溫度控制、電機控制等領域或項目中。

⑥ 數據結構 java開發中常用的排序演算法有哪些

排序演算法有很多，所以在特定情景中使用哪一種演算法很重要。為了選擇合適的演算法，可以按照建議的順序考慮以下標准：
（1）執行時間
（2）存儲空間
（3）編程工作
對於數據量較小的情形，（1）（2）差別不大，主要考慮（3）；而對於數據量大的，（1）為首要。

主要排序法有：
一、冒泡（Bubble）排序——相鄰交換
二、選擇排序——每次最小/大排在相應的位置
三、插入排序——將下一個插入已排好的序列中
四、殼（Shell）排序——縮小增量
五、歸並排序
六、快速排序
七、堆排序
八、拓撲排序

一、冒泡（Bubble）排序

----------------------------------Code 從小到大排序n個數------------------------------------
void BubbleSortArray()
{
for(int i=1;i<n;i++)
{
for(int j=0;i<n-i;j++)
{
if(a[j]>a[j+1])//比較交換相鄰元素
{
int temp;
temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;
}
}
}
}
-------------------------------------------------Code------------------------------------------------
效率 O（n²）,適用於排序小列表。

二、選擇排序
----------------------------------Code 從小到大排序n個數--------------------------------
void SelectSortArray()
{
int min_index;
for(int i=0;i<n-1;i++)
{
min_index=i;
for(int j=i+1;j<n;j++)//每次掃描選擇最小項
if(arr[j]<arr[min_index]) min_index=j;
if(min_index!=i)//找到最小項交換，即將這一項移到列表中的正確位置
{
int temp;
temp=arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp;
}
}
}
-------------------------------------------------Code-----------------------------------------
效率O（n²），適用於排序小的列表。

三、插入排序
--------------------------------------------Code 從小到大排序n個數-------------------------------------
void InsertSortArray()
{
for(int i=1;i<n;i++)//循環從第二個數組元素開始，因為arr[0]作為最初已排序部分
{
int temp=arr[i];//temp標記為未排序第一個元素
int j=i-1;
while (j>=0 && arr[j]>temp)/*將temp與已排序元素從小到大比較，尋找temp應插入的位置*/
{
arr[j+1]=arr[j];
j--;
}
arr[j+1]=temp;
}
}
------------------------------Code--------------------------------------------------------------
最佳效率O（n）；最糟效率O（n²）與冒泡、選擇相同，適用於排序小列表
若列表基本有序，則插入排序比冒泡、選擇更有效率。

四、殼（Shell）排序——縮小增量排序
-------------------------------------Code 從小到大排序n個數-------------------------------------
void ShellSortArray()
{
for(int incr=3;incr<0;incr--)//增量遞減，以增量3，2，1為例
{
for(int L=0;L<(n-1)/incr;L++)//重復分成的每個子列表
{
for(int i=L+incr;i<n;i+=incr)//對每個子列表應用插入排序
{
int temp=arr[i];
int j=i-incr;
while(j>=0&&arr[j]>temp)
{
arr[j+incr]=arr[j];
j-=incr;
}
arr[j+incr]=temp;
}
}
}
}
--------------------------------------Code-------------------------------------------
適用於排序小列表。
效率估計O（nlog2^n）~O（n^1.5），取決於增量值的最初大小。建議使用質數作為增量值，因為如果增量值是2的冪，則在下一個通道中會再次比較相同的元素。
殼（Shell）排序改進了插入排序，減少了比較的次數。是不穩定的排序，因為排序過程中元素可能會前後跳躍。

五、歸並排序
----------------------------------------------Code 從小到大排序---------------------------------------
void MergeSort(int low,int high)
{
if(low>=high) return;//每個子列表中剩下一個元素時停止
else int mid=(low+high)/2;/*將列表劃分成相等的兩個子列表,若有奇數個元素，則在左邊子列表大於右側子列表*/
MergeSort(low,mid);//子列表進一步劃分
MergeSort(mid+1,high);
int [] B=new int [high-low+1];//新建一個數組，用於存放歸並的元素
for(int i=low,j=mid+1,k=low;i<=mid && j<=high;k++)/*兩個子列表進行排序歸並，直到兩個子列表中的一個結束*/
{
if (arr[i]<=arr[j];)
{
B[k]=arr[i];
I++;
}
else
{ B[k]=arr[j]; j++; }
}
for( ;j<=high;j++,k++)//如果第二個子列表中仍然有元素，則追加到新列表
B[k]=arr[j];
for( ;i<=mid;i++,k++)//如果在第一個子列表中仍然有元素，則追加到新列表中
B[k]=arr[i];
for(int z=0;z<high-low+1;z++)//將排序的數組B的 所有元素復制到原始數組arr中
arr[z]=B[z];
}
-----------------------------------------------------Code---------------------------------------------------
效率O（nlogn），歸並的最佳、平均和最糟用例效率之間沒有差異。
適用於排序大列表，基於分治法。

六、快速排序
------------------------------------Code--------------------------------------------
/*快速排序的演算法思想：選定一個樞紐元素，對待排序序列進行分割，分割之後的序列一個部分小於樞紐元素，一個部分大於樞紐元素，再對這兩個分割好的子序列進行上述的過程。*/ void swap(int a,int b){int t;t =a ;a =b ;b =t ;}
int Partition(int [] arr,int low,int high)
{
int pivot=arr[low];//採用子序列的第一個元素作為樞紐元素
while (low < high)
{
//從後往前栽後半部分中尋找第一個小於樞紐元素的元素
while (low < high && arr[high] >= pivot)
{
--high;
}
//將這個比樞紐元素小的元素交換到前半部分
swap(arr[low], arr[high]);
//從前往後在前半部分中尋找第一個大於樞紐元素的元素
while (low <high &&arr [low ]<=pivot )
{
++low ;
}
swap (arr [low ],arr [high ]);//將這個樞紐元素大的元素交換到後半部分
}
return low ;//返回樞紐元素所在的位置
}
void QuickSort(int [] a,int low,int high)
{
if (low <high )
{
int n=Partition (a ,low ,high );
QuickSort (a ,low ,n );
QuickSort (a ,n +1,high );
}
}
----------------------------------------Code-------------------------------------
平均效率O（nlogn），適用於排序大列表。
此演算法的總時間取決於樞紐值的位置；選擇第一個元素作為樞紐，可能導致O（n²）的最糟用例效率。若數基本有序，效率反而最差。選項中間值作為樞紐，效率是O（nlogn）。
基於分治法。

七、堆排序
最大堆：後者任一非終端節點的關鍵字均大於或等於它的左、右孩子的關鍵字，此時位於堆頂的節點的關鍵字是整個序列中最大的。
思想：
(1)令i=l,並令temp＝ kl ;
(2)計算i的左孩子j=2i+1;
(3)若j<＝n－1，則轉(4),否則轉(6);
(4)比較kj和kj+1,若kj+1>kj,則令j＝j＋1，否則j不變；
(5)比較temp和kj，若kj>temp，則令ki等於kj，並令i=j,j=2i+1,並轉(3),否則轉(6)
(6)令ki等於temp，結束。
-----------------------------------------Code---------------------------
void HeapSort(SeqIAst R)

{ //對R[1..n]進行堆排序，不妨用R[0]做暫存單元 int I; BuildHeap(R)； //將R[1-n]建成初始堆for(i=n;i>1；i--) //對當前無序區R[1..i]進行堆排序，共做n-1趟。{ R[0]=R[1]; R[1]=R[i]; R[i]=R[0]; //將堆頂和堆中最後一個記錄交換 Heapify(R,1,i-1); //將R[1..i-1]重新調整為堆，僅有R[1]可能違反堆性質 } } ---------------------------------------Code--------------------------------------

堆排序的時間，主要由建立初始堆和反復重建堆這兩部分的時間開銷構成，它們均是通過調用Heapify實現的。

堆排序的最壞時間復雜度為O(nlgn)。堆排序的平均性能較接近於最壞性能。 由於建初始堆所需的比較次數較多，所以堆排序不適宜於記錄數較少的文件。 堆排序是就地排序，輔助空間為O(1)， 它是不穩定的排序方法。

堆排序與直接插入排序的區別:
直接選擇排序中，為了從R[1..n]中選出關鍵字最小的記錄，必須進行n-1次比較，然後在R[2..n]中選出關鍵字最小的記錄，又需要做n-2次比較。事實上，後面的n-2次比較中，有許多比較可能在前面的n-1次比較中已經做過，但由於前一趟排序時未保留這些比較結果，所以後一趟排序時又重復執行了這些比較操作。
堆排序可通過樹形結構保存部分比較結果，可減少比較次數。

八、拓撲排序
例 ：學生選修課排課先後順序
拓撲排序：把有向圖中各頂點按照它們相互之間的優先關系排列成一個線性序列的過程。
方法：
在有向圖中選一個沒有前驅的頂點且輸出
從圖中刪除該頂點和所有以它為尾的弧
重復上述兩步，直至全部頂點均已輸出（拓撲排序成功），或者當圖中不存在無前驅的頂點（圖中有迴路）為止。
---------------------------------------Code--------------------------------------
void TopologicalSort()/*輸出拓撲排序函數。若G無迴路，則輸出G的頂點的一個拓撲序列並返回OK，否則返回ERROR*/
{
int indegree[M];
int i,k,j;
char n;
int count=0;
Stack thestack;
FindInDegree(G,indegree);//對各頂點求入度indegree[0....num]
InitStack(thestack);//初始化棧
for(i=0;i<G.num;i++)
Console.WriteLine("結點"+G.vertices[i].data+"的入度為"+indegree[i]);
for(i=0;i<G.num;i++)
{
if(indegree[i]==0)
Push(thestack.vertices[i]);
}
Console.Write("拓撲排序輸出順序為：");
while(thestack.Peek()!=null)
{
Pop(thestack.Peek());
j=locatevex(G,n);
if (j==-2)
{
Console.WriteLine("發生錯誤，程序結束。");
exit();
}
Console.Write(G.vertices[j].data);
count++;
for(p=G.vertices[j].firstarc;p!=NULL;p=p.nextarc)
{
k=p.adjvex;
if (!(--indegree[k]))
Push(G.vertices[k]);
}
}
if (count<G.num)
Cosole.WriteLine("該圖有環，出現錯誤，無法排序。");
else
Console.WriteLine("排序成功。");
}
----------------------------------------Code--------------------------------------
演算法的時間復雜度O（n+e）。

⑦ 10個常用演算法

原理：
二分法查找，也稱為折半法，是一種在有序數組中查找特定元素的搜索演算法。

一般步驟：
（1）確定該區間的中間位置K；
（2）將查找的值T與array[k]比較。
若相等，查找成功返回此位置；否則確定新的查找區域，繼續二分查找。每一次查找與中間值比較，可以確定是否查找成功，不成功當前查找區間將縮小一半，遞歸查找即可。

原理：
一種通過重復將問題分解為同類的子問題而解決問題的方法

典型例子：
斐波那契數列
描述： 斐波那契數列 指的是這樣一個數列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368.....自然中的斐波那契數列") 自然中的斐波那契數列，這個數列從第3項開始，每一項都等於前兩項之和。

解決方式：

原理：
在搜索嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就「回溯」返回，嘗試別的路徑。
回溯法是一種選優搜索法，按選優條件向前搜索，以達到目標。
但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術為回溯法，而滿足回溯條件的某個狀態的點稱為「回溯點」。

解決問題一般步驟：
1、 針對所給問題，定義問題的解空間，它至少包含問題的一個（最優）解。

2 、確定易於搜索的解空間結構,使得能用回溯法方便地搜索整個解空間 。

3 、以深度優先的方式搜索解空間，並且在搜索過程中用剪枝函數避免無效搜索。

典型例子：
八皇後問題
描述：在8×8格的國際象棋上擺放八個皇後，使其不能互相攻擊，即任意兩個皇後都不能處於同一行、同一列或同一斜線上，問有多少種擺法。

解決方式： https://blog.csdn.net/weixin_41865447/article/details/80034433

概念：
將雜亂無章的數據元素，通過一定的方法按關鍵字順序排列的過程叫做排序。

分類：
非穩定排序演算法：快速排序、希爾排序、堆排序、直接選擇排序
穩定的排序演算法：基數排序、冒泡排序、直接插入排序、折半插入排序、歸並排序

十個常用排序演算法

利用計算機的高性能來有目的的窮舉一個問題解空間的部分或所有的可能情況，從而求出問題的解的一種方法。

分類：
枚舉演算法、深度優先搜索、廣度優先搜索、A*演算法、回溯演算法、蒙特卡洛樹搜索、散列函數等演算法。

將一個數據轉換為一個標志，這個標志和源數據的每一個位元組都有十分緊密的關系。

很難找到逆向規律

只要符合散列思想的演算法都可以被稱為是Hash演算法

對不同的關鍵字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2)，這種現象稱為 碰撞 。

原理
在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優上加以考慮，他所做出的是在 某種意義上的局部最優解 。
從問題的某一個初始解出發一步一步地進行，根據某個優化測度，每一步都要確保能獲得局部最優解。每一步只考慮一個數據，他的選取應該滿足局部優化的條件。若下一個數據和部分最優解連在一起不再是可行解時，就不把該數據添加到部分解中，直到把所有數據枚舉完，或者不能再添加演算法停止。

一種近似演算法

一般步驟：
1、建立數學模型來描述問題；
2、把求解的問題分成若干個子問題；
3、對每一子問題求解，得到子問題的局部最優解；
4、把子問題的解局部最優解合成原來解問題的一個解。

典型例子：
0/1背包問題
馬踏棋盤
均分紙牌

例題： https://www.cnblogs.com/hust-chen/p/8646009.html

概念：
分治演算法的基本思想是將一個規模為N的問題分解為K個規模較小的子問題，這些子問題相互獨立且與原問題性質相同。求出子問題的解，就可得到原問題的解。即一種分目標完成程序演算法，簡單問題可用二分法完成。

一般步驟：
（1）分解，將要解決的問題劃分成若干規模較小的同類問題；
（2）求解，當子問題劃分得足夠小時，用較簡單的方法解決；
（3）合並，按原問題的要求，將子問題的解逐層合並構成原問題的解。

典型例子：
排序中：歸並排序、堆排序、快速排序；
實例：找偽幣、求最值、棋盤覆蓋

https://ke..com/item/%E5%88%86%E6%B2%BB%E7%AE%97%E6%B3%95/3263297

概念：
用於求解具有某種最優性質的問題。在這類問題中，可能會有許多可行解。每一個解都對應於一個值，我們希望找到具有最優值的解。

動態規劃一般可分為線性動規，區域動規，樹形動規，背包動規四類。

舉例：
線性動規：攔截導彈，合唱隊形，挖地雷，建學校，劍客決斗等；
區域動規：石子合並， 加分二叉樹，統計單詞個數，炮兵布陣等；
樹形動規：貪吃的九頭龍，二分查找樹，聚會的歡樂，數字三角形等；
背包問題：01背包問題，完全背包問題，分組背包問題，二維背包，裝箱問題，擠牛奶（同濟）等；

應用實例：
最短路徑問題 ，項目管理，網路流優化等；

https://ke..com/item/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/529408?fromtitle=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%AE%97%E6%B3%95&fromid=15742703&fr=aladdin

概念：
在一個給定的字元文本內搜尋出自己想要找的一個字元串，平常所用的各種文本編輯器里的ctrl+F大多就是使用的這些字元匹配演算法。

分類：
KMP、BM、Sunday、Horspool、RK

參考：
https://cloud.tencent.com/developer/news/282694
https://blog.csdn.net/paincupid/article/details/81159320

⑧ 在早期的項目管理過程中我們常用的技術方法有哪些

1）專家判斷
2）引導技術

⑨ 哪些JAVA項目開發里會用到演算法比較多

一般用java寫c/s用的演算法比較多
然後大型的項目涉及到性能的時候，演算法也要佔很大一部分
現在web項目 用到了很多框架 很多的演算法就在框架裡面幫你實現了 你只要調用就行
你可以去看看開源框架的源碼

⑩ lvs負載均衡（簡介，三種工作模式，四種常用演算法）

一，lvs簡介

LVS是linux Virtual Server的簡稱，也就是Linux虛擬伺服器，是一個由章文嵩博士發起的自由軟體項目，官方站點是： http://www.linuxvirtualserver.org 。現在LVS已經是Linux標准內核的一部分，在Linux2.4內核以前，使用LVS時必須重新編譯內核以支持LVS功能模塊，但是從Linux2.4內核心之後，已經完全內置了LVS的各個功能模塊，無需給內核打任何補丁，可以直接使用LVS提供的各種功能。使用LVS技術要達到的目標是：通過LVS提供的負載均衡技術和Linux操作系統實現一個高性能，高可用的伺服器群集，它具有良好的可靠性、可擴展性和可操作性。從而以兄棚野低廉的成本實現最優的服務性能。

二，三種工作模式

1、基於NAT的LVS模式負載均衡

也就是網路地址翻譯技術實現虛擬伺服器，當用戶請求到達調度器時，調度器將請求報文的目標地址（即虛擬IP地址）改寫成選定的Real Server地址，同時報文的目標埠也改成選定的Real Server的相應埠，***將報文請求發送到選定的Real Server。在伺服器端得到數據後，Real Server返回數據給用戶時，需要再次經過負載調度器將報文的源地址和源埠改成虛擬IP地址和相應埠，然後把數據發送給用戶，完成整個負載調度過程。可以看出，在NAT方式下，用戶請求和響應報文都必須經過Director Server地址重寫，當用戶請求越來越多時，調度器的處理能力將稱為瓶頸。

2，基於TUN的LVS負載均衡

也就是IP隧道技術實現虛擬伺服器。它的連接調度和管理與VS/NAT方式一樣，只是它的報文轉發方法不同，VS/TUN方式中，調度器採用IP隧道技術將用戶請求轉發到某個Real Server，而這個Real Server將直接響應用戶的請求，不再經過前端調度器，此外，對Real Server的地域位置沒有要求，可以和Director Server位於同一個網段，也可以是獨立的一個網路。因此，在TUN方式中，調度器將只處理用戶的報文請求，集群系統的吞吐量大大提高。

用的很少，圖省略

3，基於DR的LVS負載均衡

也就是用直接路由技術實現虛擬伺服器。它的連接調度和管理與VS/NAT和VS/TUN中的一樣，但它的報文轉發方法又有不同，VS/DR通過改寫請求報文的MAC地址，將請求發送到Real Server，而Real Server將響應直接返回給客戶，免去了VS/TUN中的IP隧道開銷。這種方式是三種負載調度機制中性能最好的，但是必須要求Director Server與Real Server都有一塊網卡連在同一物理網段上。

三，LVS負載均衡調度演算法

上面我們談到，負載調度器是根據各 個伺服器的負載情況，動和或態地選擇一台Real Server響應用戶請求，那麼動態選擇是如何實現呢，其實也就是我們這里要說的負載調度演算法，根據不同的網路服務需求和伺服器配置，IPVS實現了如下 八種負載調度演算法，這里我們詳細講述最常用的四種調度演算法，剩餘的四種調度演算法請參考其它資料。

3.1  輪叫調度（Round Robin）

「輪叫」調度也叫1:1調度，調度器通過羨喊「輪叫」調度演算法將外部用戶請求按順序1:1的分配到集群中的每個Real Server上，這種演算法平等地對待每一台Real Server，而不管伺服器上實際的負載狀況和連接狀態。

3.2  加權輪叫調度（Weighted Round Robin）

「加 權輪叫」調度演算法是根據Real Server的不同處理能力來調度訪問請求。可以對每台Real Server設置不同的調度權值，對於性能相對較好的Real Server可以設置較高的權值，而對於處理能力較弱的Real Server，可以設置較低的權值，這樣保證了處理能力強的伺服器處理更多的訪問流量。充分合理的利用了伺服器資源。同時，調度器還可以自動查詢Real Server的負載情況，並動態地調整其權值。

3.3  最少鏈接調度（Least Connections）

「最少連接」調度演算法動態地將網路請求調度到已建立的鏈接數最少的伺服器上。如果集群系統的真實伺服器具有相近的系統性能，採用「最小連接」調度演算法可以較好地均衡負載。

3.4  加權最少鏈接調度（Weighted Least Connections）

「加權最少鏈接調度」是「最少連接調度」的超集，每個服務節點可以用相應的權值表示其處理能力，而系統管理員可以動態的設置相應的權值，預設權值為1，加權最小連接調度在分配新連接請求時盡可能使服務節點的已建立連接數和其權值成正比。

其它四種調度演算法分別為：基於局部性的最少鏈接（Locality-Based Least Connections）、帶復制的基於局部性最少鏈接（Locality-Based Least Connections with Replication）、目標地址散列（Destination Hashing）和源地址散列（Source Hashing），對於這四種調度演算法的含義，本文不再講述，如果想深入了解這其餘四種調度策略的話，可以登陸LVS中文站點 zh.linuxvirtualserver.org，查閱更詳細的信息。