基本排序算法

① java中有多少种排序算法，分别是什么

计数排序，大小堆排序，冒泡排序，选择排序，shell排序，快速排序，归并排序

② 常见排序算法有哪些

常用的排序算法有：冒泡排序、选择排序、堆排序、SHELL排序、快速排序、归并排序、磁盘排序等等。但是每种排序算法都是各有优缺点。如果需要进一步研究各种算法的性能的话，那么就必须学习计算机算法和复杂性这门课程。

③ 常用的排序算法都有哪些

排序算法 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类
在计算机科学所使用的排序算法通常被分类为：
计算的复杂度（最差、平均、和最好表现），依据串行（list）的大小（n）。一般而言，好的表现是O。(n log n)，且坏的行为是Ω(n2)。对于一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。
记忆体使用量（以及其他电脑资源的使用）
稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串行中R出现在S之前，在排序过的串行中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。选择排序包含shaker排序和堆排序（heapsort）。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：
(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改变)
不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。
排列算法列表
在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。
稳定的
冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体
原地归并排序 — O(n2)
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体
不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）
不实用的排序算法
Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。
Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体
Bead sort — O(n) or O(√n), 但需要特别的硬体
Pancake sorting — O(n), 但需要特别的硬体
排序的算法
排序的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序，他们对空间的要求不高，但是时间效率却不稳定；而后面三种排序相对于简单排序对空间的要求稍高一点，但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。
插入排序
冒泡排序
选择排序
快速排序
堆排序
归并排序
基数排序
希尔排序
插入排序
插入排序是这样实现的：
首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。
从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。
重复2号步骤，直至原数列为空。
插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。
冒泡排序
冒泡排序是这样实现的：
首先将所有待排序的数字放入工作列表中。
从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
重复2号步骤，直至再也不能交换。
冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。
选择排序
选择排序是这样实现的：
设数组内存放了n个待排数字，数组下标从1开始，到n结束。
i=1
从数组的第i个元素开始到第n个元素，寻找最小的元素。
将上一步找到的最小元素和第i位元素交换。
如果i=n－1算法结束，否则回到第3步
选择排序的平均时间复杂度也是O(n²)的。
快速排序
现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。
堆排序
堆排序与前面的算法都不同，它是这样的：
首先新建一个空列表，作用与插入排序中的"有序列表"相同。
找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。
重复2号步骤，直至原数列为空。
堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。
看起来似乎堆排序与插入排序有些相像，但他们其实是本质不同的算法。至少，他们的时间复杂度差了一个数量级，一个是平方级的，一个是对数级的。
平均时间复杂度
插入排序 O(n2)
冒泡排序 O(n2)
选择排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
归并排序 O(n log n)
基数排序 O(n)
希尔排序 O(n1.25)
冒泡排序
654
比如说这个，我想让它从小到大排序，怎么做呢？
第一步：6跟5比，发现比它大，则交换。564
第二步：5跟4比，发现比它大，则交换。465
第三步：6跟5比，发现比它大，则交换。456

④ 排序法都有哪些

一、插入排序(InsertionSort)
1.基本思想：
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
2.排序过程：
【示例】：
[初始关键字][49]38659776132749
J=2(38)[3849]659776132749
J=3(65)[384965]9776132749
J=4(97)[38496597]76132749
J=5(76)[3849657697]132749
J=6(13)[133849657697]2749
J=7(27)[13273849657697]49
J=8(49)[1327384949657697]

1. ProcereInsertSort(VarR:FileType);
   
2. //对R[1..N]按递增序进行插入排序,R[0]是监视哨//
   
3. Begin
   
4. forI:=2ToNDo//依次插入R[2],...,R[n]//
   
5. begin
   
6. R[0]:=R;J:=I-1;
   
7. WhileR[0]<R[J]Do//查找R的插入位置//
   
8. begin
   
9. R[J+1]:=R[J];//将大于R的元素后移//
   
10. J:=J-1
    
11. end
    
12. R[J+1]:=R[0];//插入R//
    
13. end
    
14. End;//InsertSort//

复制代码二、选择排序
1.基本思想：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
2.排序过程：
【示例】：
初始关键字[4938659776132749]
第一趟排序后13［38659776492749]
第二趟排序后1327［659776493849]
第三趟排序后132738[9776496549]
第四趟排序后13273849[49976576]
第五趟排序后1327384949[979776]
第六趟排序后132738494976[7697]
第七趟排序后13273849497676[97]
最后排序结果1327384949767697

1. ProcereSelectSort(VarR:FileType);//对R[1..N]进行直接选择排序//
   
2. Begin
   
3. forI:=1ToN-1Do//做N-1趟选择排序//
   
4. begin
   
5. K:=I;
   
6. ForJ:=I+1ToNDo//在当前无序区R[I..N]中选最小的元素R[K]//
   
7. begin
   
8. IfR[J]<R[K]ThenK:=J
   
9. end;
   
10. IfK<>IThen//交换R和R[K]//
    
11. beginTemp:=R;R:=R[K];R[K]:=Temp;end;
    
12. end
    
13. End;//SelectSort//

复制代码三、冒泡排序(BubbleSort)
1.基本思想：
两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
2.排序过程：
设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
【示例】：
4913131313131313
3849272727272727
6538493838383838
9765384949494949
7697654949494949
1376976565656565
2727769776767676
4949497697979797

1. ProcereBubbleSort(VarR:FileType)//从下往上扫描的起泡排序//
   
2. Begin
   
3. ForI:=1ToN-1Do//做N-1趟排序//
   
4. begin
   
5. NoSwap:=True;//置未排序的标志//
   
6. ForJ:=N-1DownTo1Do//从底部往上扫描//
   
7. begin
   
8. IfR[J+1]<R[J]Then//交换元素//
   
9. begin
   
10. Temp:=R[J+1];R[J+1:=R[J];R[J]:=Temp;
    
11. NoSwap:=False
    
12. end;
    
13. end;
    
14. IfNoSwapThenReturn//本趟排序中未发生交换，则终止算法//
    
15. end
    
16. End;//BubbleSort//

复制代码四、快速排序（QuickSort）
1.基本思想：
在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。
2.排序过程：
【示例】：
初始关键字[4938659776132749］
第一次交换后
［2738659776134949］
第二次交换后
［2738499776136549］
J向左扫描，位置不变，第三次交换后
［2738139776496549］
I向右扫描，位置不变，第四次交换后
［2738134976976549］
J向左扫描
［2738134976976549］
（一次划分过程）

初始关键字
［4938659776132749］
一趟排序之后
［273813］49［76976549］
二趟排序之后
［13］27［38］49［4965］76［97］
三趟排序之后1327384949［65］7697
最后的排序结果1327384949657697
各趟排序之后的状态

1. ProcereParttion(VarR:FileType;L,H:Integer;VarI:Integer);
   
2. //对无序区R[1,H]做划分，I给以出本次划分后已被定位的基准元素的位置//
   
3. Begin
   
4. I:=1;J:=H;X:=R;//初始化，X为基准//
   
5. Repeat
   
6. While(R[J]>=X)And(I<J)Do
   
7. begin
   
8. J:=J-1//从右向左扫描，查找第1个小于X的元素//
   
9. IfI<JThen//已找到R[J]〈X//
   
10. begin
    
11. R:=R[J];//相当于交换R和R[J]//
    
12. I:=I+1
    
13. end;
    
14. While(R<=X)And(I<J)Do
    
15. I:=I+1//从左向右扫描，查找第1个大于X的元素///
    
16. end;
    
17. IfI<JThen//已找到R>X//
    
18. begin R[J]:=R;//相当于交换R和R[J]//
    
19. J:=J-1
    
20. end
    
21. UntilI=J;
    
22. R:=X//基准X已被最终定位//
    
23. End;//Parttion//

复制代码

1. ProcereQuickSort(VarR:FileType;S,T:Integer);//对R[S..T]快速排序//
   
2. Begin
   
3. IfS<TThen//当R[S..T]为空或只有一个元素是无需排序//
   
4. begin
   
5. Partion(R,S,T,I);//对R[S..T]做划分//
   
6. QuickSort(R,S,I-1);//递归处理左区间R[S,I-1]//
   
7. QuickSort(R,I+1,T);//递归处理右区间R[I+1..T]//
   
8. end;
   
9. End;//QuickSort//

复制代码五、堆排序(HeapSort)
1.基本思想：
堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
2.堆的定义:N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性：
Ki≤K2iKi≤K2i+1(1≤I≤[N/2])


堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
3.排序过程：
堆排序正是利用小根堆（或大根堆）来选取当前无序区中关键字小（或最大）的记录实现排序的。我们不妨利用大根堆来排序。每一趟排序的基本操作是：将当前无序区调整为一个大根堆，选取关键字最大的堆顶记录，将它和无序区中的最后一个记录交换。这样，正好和直接选择排序相反，有序区是在原记录区的尾部形成并逐步向前扩大到整个记录区。
【示例】：对关键字序列42，13，91，23，24，16，05，88建堆

1. ProcereSift(VarR:FileType;I,M:Integer);
   
2. //在数组R[I..M]中调用R，使得以它为完全二叉树构成堆。事先已知其左、右子树(2I+1<=M时)均是堆//
   
3. Begin
   
4. X:=R;J:=2*I;//若J<=M,R[J]是R的左孩子//
   
5. WhileJ<=MDo//若当前被调整结点R有左孩子R[J]//
   
6. begin
   
7. If(J<M)AndR[J].Key<R[J+1].KeyThen
   
8. J:=J+1//令J指向关键字较大的右孩子//
   
9. //J指向R的左、右孩子中关键字较大者//
   
10. IfX.Key<R[J].KeyThen//孩子结点关键字较大//
    
11. begin
    
12. R:=R[J];//将R[J]换到双亲位置上//
    
13. I:=J;J:=2*I//继续以R[J]为当前被调整结点往下层调整//
    
14. end;
    
15. Else
    
16. Exit//调整完毕，退出循环//
    
17. end
    
18. R:=X;//将最初被调整的结点放入正确位置//
    
19. End;//Sift//

复制代码

1. ProcereHeapSort(VarR:FileType);//对R[1..N]进行堆排序//
   
2. Begin
   
3. ForI:=NDivDownto1Do//建立初始堆//
   
4. Sift(R,I,N)
   
5. ForI:=NDownto2do//进行N-1趟排序//
   
6. begin
   
7. T:=R[1];R[1]:=R;R:=T;//将当前堆顶记录和堆中最后一个记录交换//
   
8. Sift(R,1,I-1)//将R[1..I-1]重成堆//
   
9. end
   
10. End;//HeapSort//

复制代码六、几种排序算法的比较和选择
1.选取排序方法需要考虑的因素：
(1)待排序的元素数目n；
(2)元素本身信息量的大小；
(3)关键字的结构及其分布情况；
(4)语言工具的条件，辅助空间的大小等。
2.小结：
(1)若n较小(n<=50)，则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多，因而当记录本身信息量较大时，用直接选择排序较好。
(2)若文件的初始状态已按关键字基本有序，则选用直接插入或冒泡排序为宜。
(3)若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。
快速排序是目前基于比较的内部排序法中被认为是最好的方法。
(4)在基于比较排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程，由此可以证明：当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlog2n)的时间。

这句话很重要它告诉我们自己写的算法是有改进到最优当然没有必要一直追求最优
(5)当记录本身信息量较大时，为避免耗费大量时间移动记录，可以用链表作为存储结构。

⑤ 排序算法有哪些

1.插入排序—直接插入排序(Straight Insertion Sort)
2. 插入排序—希尔排序（Shell`s Sort）
3. 选择排序—简单选择排序（Simple Selection Sort）
4. 选择排序—堆排序（Heap Sort）
5. 交换排序—冒泡排序（Bubble Sort）
6. 交换排序—快速排序（Quick Sort）
7. 归并排序（Merge Sort）
8. 桶排序/基数排序(Radix Sort)

⑥ 排序算法有多少种

排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。
排序就是把集合中的元素按照一定的次序排序在一起。一般来说有升序排列和降序排列2种排序，在算法中有8中基本排序：
(1)冒泡排序；
(2)选择排序；
(3)插入排序；
(4)希尔排序；
(5)归并排序；
(6)快速排序；
(7)基数排序；
(8)堆排序；
(9)计数排序；
(10)桶排序。
插入排序
插入排序算法是基于某序列已经有序排列的情况下，通过一次插入一个元素的方式按照原有排序方式增加元素。这种比较是从该有序序列的最末端开始执行，即要插入序列中的元素最先和有序序列中最大的元素比较，若其大于该最大元素，则可直接插入最大元素的后面即可，否则再向前一位比较查找直至找到应该插入的位置为止。插入排序的基本思想是，每次将1个待排序的记录按其关键字大小插入到前面已经排好序的子序列中，寻找最适当的位置，直至全部记录插入完毕。执行过程中，若遇到和插入元素相等的位置，则将要插人的元素放在该相等元素的后面，因此插入该元素后并未改变原序列的前后顺序。我们认为插入排序也是一种稳定的排序方法。插入排序分直接插入排序、折半插入排序和希尔排序3类。
冒泡排序
冒泡排序算法是把较小的元素往前调或者把较大的元素往后调。这种方法主要是通过对相邻两个元素进行大小的比较，根据比较结果和算法规则对该二元素的位置进行交换，这样逐个依次进行比较和交换，就能达到排序目的。冒泡排序的基本思想是，首先将第1个和第2个记录的关键字比较大小，如果是逆序的，就将这两个记录进行交换，再对第2个和第3个记录的关键字进行比较，依次类推，重复进行上述计算，直至完成第(n一1)个和第n个记录的关键字之间的比较，此后，再按照上述过程进行第2次、第3次排序，直至整个序列有序为止。排序过程中要特别注意的是，当相邻两个元素大小一致时，这一步操作就不需要交换位置，因此也说明冒泡排序是一种严格的稳定排序算法，它不改变序列中相同元素之间的相对位置关系。
选择排序
选择排序算法的基本思路是为每一个位置选择当前最小的元素。选择排序的基本思想是，基于直接选择排序和堆排序这两种基本的简单排序方法。首先从第1个位置开始对全部元素进行选择，选出全部元素中最小的给该位置，再对第2个位置进行选择，在剩余元素中选择最小的给该位置即可；以此类推，重复进行“最小元素”的选择，直至完成第(n-1)个位置的元素选择，则第n个位置就只剩唯一的最大元素，此时不需再进行选择。使用这种排序时，要注意其中一个不同于冒泡法的细节。举例说明：序列58539．我们知道第一遍选择第1个元素“5”会和元素“3”交换，那么原序列中的两个相同元素“5”之间的前后相对顺序就发生了改变。因此，我们说选择排序不是稳定的排序算法，它在计算过程中会破坏稳定性。
快速排序
快速排序的基本思想是:通过一趟排序算法把所需要排序的序列的元素分割成两大块，其中，一部分的元素都要小于或等于另外一部分的序列元素，然后仍根据该种方法对划分后的这两块序列的元素分别再次实行快速排序算法，排序实现的整个过程可以是递归的来进行调用，最终能够实现将所需排序的无序序列元素变为一个有序的序列。
归并排序
归并排序算法就是把序列递归划分成为一个个短序列，以其中只有1个元素的直接序列或者只有2个元素的序列作为短序列的递归出口，再将全部有序的短序列按照一定的规则进行排序为长序列。归并排序融合了分治策略，即将含有n个记录的初始序列中的每个记录均视为长度为1的子序列，再将这n个子序列两两合并得到n/2个长度为2(当凡为奇数时会出现长度为l的情况)的有序子序列；将上述步骤重复操作，直至得到1个长度为n的有序长序列。需要注意的是，在进行元素比较和交换时，若两个元素大小相等则不必刻意交换位置，因此该算法不会破坏序列的稳定性，即归并排序也是稳定的排序算法。

⑦ 排序法的排序法的基本步骤

排序法是根据一些特定的标准（例如工作的复杂程度、对组织的贡献大小等对各个职位的相对价值）进行整体比较，进而将职位按照相对价值的高低排列出一个次序。其基本步骤是：
1、对排序的标准达成共识。虽然排序法是对岗位的整体价值进行评价而排序，但也需要参与评估的人员对什么样的“整体价值”更高达成共识，如责任更大，知识技能更高，工作更加复杂，环境因素恶劣等。
2、选定参与排序的职位。如果公司较小可以选取全部职位进行排序。
3、评定人员根据事先确定评判标准，对公司同类岗位的重要性逐一作出评判，最重要的排在第一位，次要的、再次要的顺次往下排列。
4、将经过所有评定人员评定的每个岗位的结果加以汇总，得到序号和。然后将序号和除以评定人数，得到每一岗位的平均序数。最后，按平均序数的大小，由小到大评定出各岗位的相对价值的次序。

⑧ vb三种基本排序算法

三种基本排序算法（与哪种编程语言无关）：
冒泡排序算法、选择排序算法、插入排序算法

⑨ 排序算法是怎样的

一、背景介绍

在计算机科学与数学中，排序算法（Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。

最常用到的排序方式是数字顺序以及字典顺序。

有效的排序算法在一些算法（例如搜寻算法与合并算法）中是重要的， 如此这些算法才能得到正确解答。

排序算法也用在处理文字资料以及产生人类可读的输出结果。

基本上，排序算法的输出必须遵守下列两个原则：

1、输出结果为递增序列（递增是针对所需的排序顺序而言）；

2、输出结果是原输入的一种排列、或是重组；

虽然排序算法是一个简单的问题，但是从计算机科学发展以来，在此问题上已经有大量的研究。 更多的新算法仍在不断的被发明。

二、知识剖析

查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。 所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。

一般在面试中最常考的是快速排序和冒泡排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。除此之外，还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。

三、常见的几种算法：

冒泡算法、选择排序、插入排序、希尔排序、归并排序、快速排序

算法的特点：

1、有限性：一个算法必须保证执行有限步之后结束。

2、确切性： 一个算法的每一步骤必须有确切的定义。

3、输入：一个算法有零个或多个输入，以刻画运算对象的初始情况，所谓零个输入是指算法本身给定了初始条件。

4、输出：一个算法有一个或多个输出。没有输出的算法毫无意义。

5、可行性：算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。