A. 幾種常用的排序演算法比較
排序，從小大，0坐標的在下面，即排序後小的在下面，大的在上面。
1，冒泡Bubble：從第0個開始，一直往上，與相鄰的元素比較，如果下面的大，則交換。
Analysis：
Implementation：
void BubbleSort(int *pData, int iNum)
2，插入Insertion：與打撲克牌時整理牌很想像，假定第一張牌是有序的，從第二張牌開始，拿出這張牌來，往下比較，如果有比這張牌大的，則把它撥到上一個位置，直到找到比手上的這張更小的（或到頂了），
則把手上的這張牌插入到這張更小的牌的後面。
Analysis：
Implementation：
void InsertionSort(int *list, int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = list[i];
j = i - 1;
while ((j >= 0) && (list[j] > temp))
{
list[j+1] = list[j];
j--;
}
list[j+1] = temp;
}
}
3，選擇Selection：從所有元素中找到最小的放在0號位置，從其它元素（除了0號元素）中再找到最小的，放到1號位置，......。
Analysis：
Implementation：
void SelectionSort(int data[], int count)
{
int i, j, min, temp;
for (i = 0; i < count - 1; i++)
{
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{
min = j;
}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}
4，快速Quick：先拿出中間的元素來（值保存到temp里），設置兩個索引（index or pointer），一個從0號位置開始往最大位置尋找比temp大的元素；一個從最大號位置開始往最小位置尋找比temp小的元素，找到了或到頂了，則將兩個索引所指向的元素
互換，如此一直尋找交換下去，直到兩個索引交叉了位置，這個時候，從0號位置到第二個索引的所有元素就都比temp小，從第一個索引到最大位置的所有元素就都比temp大，這樣就把所有元素分為了兩塊，然後採用前面的辦法分別排序這兩個部分。總的來
說，就是隨機找一個元素（通常是中間的元素），然後把小的放在它的左邊，大的放右邊，對左右兩邊的數據繼續採用同樣的辦法。只是為了節省空間，上面採用了左右交換的方法來達到目的。
Analysis：
Implementation：
void QuickSort(int *pData, int left, int right)
{
int i, j;
int middle, iTemp;
i = left;
j = right;
middle = pData[(left + right) / 2]; //求中間值
do
{
while ((pData[i] < middle) && (i < right)) //從左掃描大於中值的數
i++;
while ((pData[j] > middle) && (j > left)) //從右掃描小於中值的數
j--;
if (i <= j) //找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
} while (i <= j); //如果兩邊掃描的下標交錯，就停止（完成一次）
//當左邊部分有值(left<j)，遞歸左半邊
if(left < j)
QuickSort(pData, left, j);
//當右邊部分有值(right>i)，遞歸右半邊
if(right > i)
QuickSort(pData, i, right);
}
5，希爾Shell：是對Insertion Sort的一種改進，在Insertion Sort中，從第2個位置開始取出數據，每次都是與前一個（step/gap==1）進行比較。Shell Sort修改為，在開始時採用較大的步長step，
從第step位置開始取數據，每次都與它的前step個位置上的數據進行比較（如果有8個數據，初始step==4，那麼pos(4)與pos(0)比較，pos(0)與pos(-4)，pos(5)與pos(1)，pos(1)與pos(-3)，
...... pos(7)與pos(3)，pos(3)與pos(-1)），然後逐漸地減小step，直到step==1。step==1時，排序過程與Insertion Sort一樣，但因為有前面的排序，這次排序將減少比較和交換的次數。
Shell Sort的時間復雜度與步長step的選擇有很大的關系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相對比較簡單，它適合
於數據量在5000以下並且速度並不是特別重要的場合。它對於數據量較小的數列重復排序是非常好的。
Analysis：
Implementation：
template<typename RandomIter, typename Compare>
void ShellSort(RandomIter begin, RandomIter end, Compare cmp)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;
diff_t size = std::distance(begin, end);
diff_t step = size / 2;
while (step >= 1)
{
for (diff_t i = step; i < size; ++i)
{
value_type key = *(begin+i);
diff_t ins = i; // current position
while (ins >= step && cmp(key, *(begin+ins-step)))
{
*(begin+ins) = *(begin+ins-step);
ins -= step;
}
*(begin+ins) = key;
}
if(step == 2)
step = 1;
else
step = static_cast<diff_t>(step / 2.2);
}
}
template<typename RandomIter>
void ShellSort(RandomIter begin, RandomIter end)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
ShellSort(begin, end, std::less<value_type>());
}
6，歸並Merge：先將所有數據分割成單個的元素，這個時候單個元素都是有序的，然後前後相鄰的兩個兩兩有序地合並，合並後的這兩個數據再與後面的兩個合並後的數據再次合並，充分前面的過程直到所有的數據都合並到一塊。
通常在合並的時候需要分配新的內存。
Analysis：
Implementation：
void Merge(int array[], int low, int mid, int high)
{
int k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;
for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
{
if(array[begin1]<=array[begin2])
{
temp[k] = array[begin1++];
}
else
{
temp[k] = array[begin2++];
}
}
if(begin1 <= end1) //若第一個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
}
if(begin2 <= end2) //若第二個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
}
memcpy(array+low, temp, (high-low+1)*sizeof(int));//將排序好的序列拷貝回數組中
free(temp);
}
void MergeSort(int array[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first+last)/2;
MergeSort(array, first, mid);
MergeSort(array, mid+1,last);
Merge(array,first,mid,last);
}
}
B. 推薦一些演算法比較好的書
劉汝佳的《演算法藝術與信息學競賽》，這本書很適合搞演算法競賽的看。
《演算法導論》這本書就不用多說了，經典
Udi Manber 的《Introction to Algorithms: A Creative Approach》中文名《演算法引論：一種創造性方法》
當然還有很多書，上面三本我有幸看過
C. 那些演算法比較好用
你問的問題很難計算
D. 演算法的速度如何比較呢
看嵌套循環語句的次數啊。其實現在電腦速度這么快基本上看不出演算法的優劣。應該看演算法本身的編寫。嵌套的循環語句越多演算法越慢。
E. 論文中演算法比較是和最新的演算法比嗎
要原創，找國淘論文寫作
每一種（類）醜陋的現象都會或多或少造成社會的損失。有些損失是明顯的，人們不齒、唾棄；但一些損失在較長的時間段後才會出現，許多人看不到這種想像的危害，那就要揭示，這要求寫作者既具有深邃的目光，透過現象看本質，又具有先知先覺的本領。
（這種一味的送去，造成物質的枯竭。）雖然有人說，掘起地下的煤來，就足夠全世界幾百年之用。但是，幾百年之後呢？幾百年之後，我們當然是化為魂靈，或上天堂，或落了地獄，但我們的子孫是在的，所以還應該給他們留下一點禮品。要不然，則當佳節大典之際，他們拿不出東西來，只好磕頭賀喜，討一點殘羹冷炙做獎賞。這種獎賞，不要誤解為「拋來」的東西，這是「拋給」的，說得冠冕些，可以稱之為「送來」，我在這里不想舉出實例。
F. 幾種常見的查找演算法之比較
二分法平均查找效率是O(logn)，但是需要數組是排序的。如果沒有排過序，就只好先用O（nlogn)的預處理為它排個序了。而且它的插入比較困難，經常需要移動整個數組，所以動態的情況下比較慢。
哈希查找理想的插入和查找效率是O(1)，但條件是需要找到一個良好的散列函數，使得分配較為平均。另外，哈希表需要較大的空間，至少要比O(n)大幾倍，否則產生沖突的概率很高。
二叉排序樹查找也是O(logn)的，關鍵是插入值時需要做一些處理使得它較為平衡（否則容易出現輕重的不平衡，查找效率最壞會降到O(n)），而且寫起來稍微麻煩一些，具體的演算法你可以隨便找一本介紹數據結構的書看看。當然，如果你用的是c語言，直接利用它的庫類型map、multimap就可以了,它是用紅黑樹實現的，理論上插入、查找時間都是O(logn)，很方便，不過一般會比自己實現的二叉平衡樹稍微慢一些。
G. 比較兩個演算法的不同
l=l+0/s的位置不一樣，第公式是o和s的值發生了變化。第二個公式，os的值還沒發生變化。
H. 比較演算法優缺點：
1.先來先服務先來先服務（FCFS, First Come First Serve）是最簡單的調度演算法，按先後順序進行調度。1. 定義按照作業提交或進程變為就緒狀態的先後次序，分派CPU；當前作業或進程佔用CPU，直到執行完或阻塞，才出讓CPU（非搶占方式）。在作業或進程喚醒後（如I/O完成），並不立即恢復執行，通常等到當前作業或進程出讓CPU。2.適用場景比較有利於長作業，而不利於短作業。有利於CPU繁忙的作業，而不利於I/O繁忙的作業。
2. 輪轉法輪轉法(Round Robin)是讓每個進程在就緒隊列中的等待時間與享受服務的時間成正比例。1. 定義將系統中所有的就緒進程按照FCFS原則，排成一個隊列。每次調度時將CPU分派給隊首進程，讓其執行一個時間片。時間片的長度從幾個ms到幾百ms。在一個時間片結束時，發生時鍾中斷。調度程序據此暫停當前進程的執行，將其送到就緒隊列的末尾，並通過上下文切換執行當前的隊首進程。進程可以未使用完一個時間片，就出讓CPU（如阻塞）。2. 時間片長度的確定時間片長度變化的影響過長－>退化為FCFS演算法，進程在一個時間片內都執行完，響應時間長。過短－>用戶的一次請求需要多個時間片才能處理完，上下文切換次數增加，響應時間長。對響應時間的要求：T(響應時間)=N(進程數目)*q(時間片)就緒進程的數目：數目越多，時間片越小系統的處理能力：應當使用戶輸入通常在一個時間片內能處理完，否則使響應時間，平均周轉時間和平均帶權周轉時間延長。
3. 多級反饋隊列演算法多級反饋隊列演算法(Round Robin with Multiple Feedback)是輪轉演算法和優先順序演算法的綜合和發展。1. 定義設置多個就緒隊列，分別賦予不同的優先順序，如逐級降低，隊列1的優先順序最高。每個隊列執行時間片的長度也不同，規定優先順序越低則時間片越長，如逐級加倍。新進程進入內存後，先投入隊列1的末尾，按FCFS演算法調度；若按隊列1一個時間片未能執行完，則降低投入到隊列2的末尾，同樣按FCFS演算法調度；如此下去，降低到最後的隊列，則按「時間片輪轉」演算法調度直到完成。僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。2.優點為提高系統吞吐量和縮短平均周轉時間而照顧短進程。為獲得較好的I/O設備利用率和縮短響應時間而照顧I/O型進程。不必估計進程的執行時間，動態調節3. 幾點說明I/O型進程：讓其進入最高優先順序隊列，以及時響應I/O交互。通常執行一個小時間片，要求可處理完一次I/O請求的數據，然後轉入到阻塞隊列。計算型進程：每次都執行完時間片，進入更低級隊列。最終採用最大時間片來執行，減少調度次數。I/O次數不多，而主要是CPU處理的進程。在I/O完成後，放回優先I/O請求時離開的隊列，以免每次都回到最高優先順序隊列後再逐次下降。為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。
4. 優先順序法優先順序演算法（Priority Scheling）是多級隊列演算法的改進，平衡各進程對響應時間的要求。適用於作業調度和進程調度，可分成搶先式和非搶先式。1. 靜態優先順序作業調度中的靜態優先順序大多按以下原則確定：由用戶自己根據作業的緊急程度輸入一個適當的優先順序。由系統或操作員根據作業類型指定優先順序。系統根據作業要求資源情況確定優先順序。進程的靜態優先順序的確定原則：按進程的類型給予不同的優先順序。將作業的情態優先順序作為它所屬進程的優先順序。2. 動態優先順序進程的動態優先順序一般根據以下原則確定：根據進程佔用有CPU時間的長短來決定。根據就緒進程等待CPU的時間長短來決定。
5．短作業優先法短作業優先（SJF, Shortest Job First）又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進，其目標是減少平均周轉時間。1. 定義對預計執行時間短的作業（進程）優先分派處理機。通常後來的短作業不搶先正在執行的作業。2. SJF的特點(1) 優點：比FCFS改善平均周轉時間和平均帶權周轉時間，縮短作業的等待時間；提高系統的吞吐量；(2) 缺點：對長作業非常不利，可能長時間得不到執行；未能依據作業的緊迫程度來劃分執行的優先順序；難以准確估計作業（進程）的執行時間，從而影響調度性能。3. SJF的變型「最短剩餘時間優先」SRT(Shortest Remaining Time)（允許比當前進程剩餘時間更短的進程來搶占）「最高響應比優先」HRRN(Highest Response Ratio Next)（響應比R = (等待時間 + 要求執行時間) / 要求執行時間，是FCFS和SJF的折衷）6. 最高響應比優先法最高響應比優先法(HRN，Highest Response_ratio Next)是對FCFS方式和SJF方式的一種綜合平衡。FCFS方式只考慮每個作業的等待時間而未考慮執行時間的長短，而SJF方式只考慮執行時間而未考慮等待時間的長短。因此，這兩種調度演算法在某些極端情況下會帶來某些不便。HRN調度策略同時考慮每個作業的等待時間長短和估計需要的執行時間長短，從中選出響應比最高的作業投入執行。響應比R定義如下： R =(W+T)/T = 1+W/T其中T為該作業估計需要的執行時間，W為作業在後備狀態隊列中的等待時間。每當要進行作業調度時，系統計算每個作業的響應比，選擇其中R最大者投入執行。這樣，即使是長作業，隨著它等待時間的增加，W / T也就隨著增加，也就有機會獲得調度執行。這種演算法是介於FCFS和SJF之間的一種折中演算法。由於長作業也有機會投入運行，在同一時間內處理的作業數顯然要少於SJF法，從而採用HRN方式時其吞吐量將小於採用SJF 法時的吞吐量。另外，由於每次調度前要計算響應比，系統開銷也要相應增加。
I. 怎麼判斷比較各種演算法的好壞
首先，這個演算法必須是正確的
其次，好的演算法應該是友好的，便於人們理解和交流，並且是機器可執行的。
這個演算法還需要足夠健壯，即當輸入的數據非法或不合理時，也能適當的做出正確的反應或進行相應的處理
最後它還必須擁有高效率和低存儲量要求。
也就是樓上幾位說的時間復雜度和空間復雜度
占的地方越小，算得越快的演算法才是好演算法。
J. 幾種常用加密演算法比較
對稱加密演算法用來對敏感數據等信息進行加密，常用的演算法包括：
des（data
encryption
standard）：數據加密標准，速度較快，適用於加密大量數據的場合。
3des（triple
des）：是基於des，對一塊數據用三個不同的密鑰進行三次加密，強度更高。
aes（advanced
encryption
standard）：高級加密標准，是下一代的加密演算法標准，速度快，安全級別高；