㈠ 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);
㈨ 对于小规模数据的排序用什么好
想什么好就是什么好