㈠ Web前端工程師你知道JavaScript中常用的排序演算法嗎
今天小編要跟大家分享的文章是關於JavaScript中常用的排序演算法。相信很多剛剛從事Web前端工作或者准備面試的小夥伴們對此還不是很了解，下面就讓小編來為大家介紹一下吧！
一、冒泡排序
冒泡排序是我們在編程演算法中，算是比較常用的排序演算法之一，在學習階段，也是最需要接觸理解的演算法，所以我們放在第一個來學習。
演算法介紹：
·___冉舷嗔詰牧礁鱸,如果前一個比後一個大，則交換位置。
·___諞宦職炎畲蟮腦胤諾攪俗詈竺妗
·___捎諉看聞判蜃詈笠桓齠際親畲蟮模災蟀湊詹街1排序最後一個元素不用比較。
冒泡演算法改進：
設置一個標志，如果這一趟發生了交換，則為true。否則為false。如果這一趟沒有發生交換，則說明排序已經完成。代碼如下：
假如數組長度是20，如果只有前十位是無序排列的，後十位是有序且都大於前十位，所以第一趟遍歷排序的時候發生交換的位置必定小於10，且該位置之後的必定有序，我們只需要排序好該位置之前的就可以，因此我們要來標記這個位置就可以了，即可以記錄每次掃描中最後一次交換的位置，下次掃描的時候只要掃描到上次的最後交換位置就行了，因為後面的都是已經排好序的，無需再比較，代碼如下：
每一次循環從兩頭出發算出最大和最小值，代碼如下：
在代碼3的基礎上記錄每次掃描最後一次交換的位置，下次掃描的時候只要掃描到上次的最後交換位置就行，同代碼2，代碼如下：
二、快速排序
演算法介紹：
快速排序是對冒泡排序的一種改進，第一趟排序時將數據分成兩部分，一部分比另一部分的所有數據都要小。然後遞歸調用，在兩邊都實行快速排序。
三、選擇排序
演算法介紹：
選擇排序就是從一個未知數據空間里，選取之最放到一個新的空間
四、插入排序
演算法介紹：
·___擁諞桓瞿媳慌藕眯虻腦乜
·___〕魷亂桓鱸兀諞丫判虻腦匭蛄兄寫雍笙蚯吧_
·___綣雅判虻腦卮笥諶〕齙腦兀蚪浞直鶼蚝笠貧晃
·___鋇秸業揭雅判虻腦刂行∮諢虻扔諶〕齙腦兀〕齙腦胤諾剿暮笠晃
·___馗床街2
插入排序演算法改進-二分法插入排序：
以上就是小編今天為大家分享的JavaScript中常用的排序演算法的文章，文章中介紹的是四種比較基礎的排序方法，JavaScript的排序演算法還有很多，這是我們4種最常見也是最基本的演算法，掌握理解好，在面試和開發中也能從容應對了。想要了解更多Web前端知識記得關注北大青鳥Web培訓官網哦。最後祝願小夥伴們工作順利！
本文轉自前端研究所。
*聲明：內容與圖片均來源於網路（部分內容有修改），版權歸原作者所有，如來源信息有誤或侵犯權益，請聯系我們刪除或授權事宜。
㈡ 只要少量數據的次序出現問題，用什麼排序演算法好
冒泡 時間復雜度為n^2
當少量數據時可以選用
大量數據就應選擇快排
㈢ 排序是在前端排，還是在後端排
這個必須得後端來排序。
第一是有分頁的，如果要排序有分頁的情況下想要前端排序就需要把所有數據全部都取過來，比如我每頁顯示50條，資料庫共總有10000條，那我要把10000條全部取出來，在前端排序，這不是浪費流量浪費cpu么。
第二，你前端排是需要自己寫排序函數，用戶點擊不同列可以根據不同列排序，你這個要寫對應函數，後台就不一樣了，從資料庫里查詢的時候直接可以讓資料庫去做這個排序的事情，甚至是多欄位組合排序，不關sql還是nosql基本都支持排序（mysql，mongodb）
所以排序分頁還是讓後端去做吧
㈣ 數據個數非常小的時候用什麼排序演算法最快
個數很小是什麼概念，如果真的很小的話其實很多演算法的效率是差不多的，
㈤ 常見的幾種數組排序演算法JS實現
排序，從小大，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);
}
}
㈥ 演算法：小數據量用冒泡，大數據量用快排，關於這里的數據量判斷問題
left + CUTOFF > right
是說如果left和right之間個數少於CUTOFF的時候用冒泡,多於用快排
left + CUTOFF如果大於了right說明left和right的差值小於CUTOFF
好好理解下吧寫成這樣可能好理解點,實際是等效的
if(right - left < CUTOFF)
㈦ 為什麼對於小數據量的排序,插入排序是比較好的選擇
因為快啊，其他的排序的演算法復雜度很大，因為排序演算法快慢取決於比較次數，如果項目多了自然比較的就多了，但是項目少的時候比較次數很少，那麼復雜的演算法需要的程序執行時間就比簡單的排序慢些（有時候是這樣的）
㈧ Pascal語言，少量數據(<100)用哪種排序比較好
O（N^2）時間復雜度，
插入、冒泡排序的速度較慢，但參加排序的序列局部或整體有序時，這種排序能達到較快的速度。
反而在這種情況下，快速排序反而慢了。
當n較小時，對穩定性不作要求時宜用選擇排序，對穩定性有要求時宜用插入或冒泡排序。
若待排序的記錄的關鍵字在一個明顯有限范圍內時,且空間允許是用桶排序。
當n較大時，關鍵字元素比較隨機，對穩定性沒要求宜用快速排序。
當n較大時，關鍵字元素可能出現本身是有序的，對穩定性有要求時，空間允許的情況下。
宜用歸並排序。
當n較大時，關鍵字元素可能出現本身是有序的，對穩定性沒有要求時宜用堆排序。
時間復雜性比較
插入排序、冒泡排序、選擇排序的時間復雜性為O(n2)
其它非線形排序的時間復雜性為O(nlog2n)
線形排序的時間復雜性為O(n);
㈨ 對於小規模數據的排序用什麼好
想什麼好就是什麼好