关键词：
前言
查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对于这些排序可能会要求比较各自的优劣、各种算法的思想及其使用场景。还有要会分析算法的时间和空间复杂度。通常查找和排序算法的考察是面试的开始，如果这些问题回答不好，估计面试官都没有继续面试下去的兴趣都没了。所以想开个好头就要把常见的排序算法思想及其特点要熟练掌握，有必要时要熟练写出代码。
接下来我们就分析一下常见的排序算法及其使用场景。限于篇幅，某些算法的详细演示和图示请自行寻找详细的参考。
冒泡排序
冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得名。举个栗子，对5,3,8,6,4这个无序序列进行冒泡排序。首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5,3,8,4,6。同理4和8交换，变成5,3,4,8,6,3和4无需交换。5和3交换，变成3,5,4,8,6,3.这样一次冒泡就完了，把最小的数3排到最前面了。对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。
实现代码：
public class SelectSort
public static void selectSort(int[] arr)
if (arr == null || arr.length == 0)
return;
int minIndex = 0;
for (int i = 0; i < arr.length - 1; i++) //只需要比较n-1次
minIndex = i;
for (int j = i + 1; j < arr.length; j++) //从i+1开始比较，因为minIndex默认为i了，就没必要比了
if (arr[j] < arr[minIndex])
minIndex = j;
if (minIndex == i) //如果minIndex不为i，说明找到了更小的筒，交换之。
swap(arr, i, minIndex);
public static void swap(int[] arr, int i, int j)
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
插入排序
插入排序不是通过交换位置而是通过比较找到合适的位置插入元素来达到排序的目的的。相信大家都有过打扑克牌的经历，特别是牌数较大的。在分牌时可能要整理自己的牌，牌多的时候怎么整理呢？就是拿到一张牌，找到一个合适的位置插入。这个原理其实和插入排序是一样的。举个栗子，对5,3,8,6,4这个无序序列进行简单插入排序，首先假设第一个数的位置时正确的，想一下在拿到第一张牌的时候，没必要整理。然后3要插到5前面，把5后移一位，变成3,5,8,6,4.想一下整理牌的时候应该也是这样吧。然后8不用动，6插在8前面，8后移一位，4插在5前面，从5开始都向后移一位。注意在插入一个数的时候要保证这个数前面的数已经有序。简单插入排序的时间复杂度也是O(n^2)。
实现代码：
public class InsertSort
public static void insertSort(int[] arr)
if (arr == null || arr.length == 0)
return;
for (int i = 1; i < arr.length; i++) //假设第一个数位置是正确的;要往后移·必须要假设第一个
int j = i;
int target = arr[i]; //待插入的
//后移
while (j > 0 && target < arr[j - 1])
arr[j] = arr[j - 1];
j--;
//插入
arr[j] = target;
快速排序
快速排序一听名字就觉得很高端，在实际应用当中快速排序确实也是表现最好的排序算法。冒泡排序虽然高端，但其实其思想是来自冒泡排序，冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端，而快速排序是比较和交换小数和大数，这样一来不仅把小数冒泡到上面同时也把大数沉到下面。
举个栗子：对5,3,8,6,4这个无序序列进行快速排序，思路是右指针找比基准数小的，左指针找比基准数大的，交换之。
5,3,8,6,4 用5作为比较的基准，最终会把5小的移动到5的左边，比5大的移动到5的右边。
5,3,8,6,4 首先设置i,j两个指针分别指向两端，j指针先扫描（思考一下为什么？）4比5小停止。然后i扫描，8比5大停止。交换i,j位置。
5,3,4,6,8 然后j指针再扫描，这时j扫描4时两指针相遇。停止。然后交换4和基准数。
4,3,5,6,8 一次划分后达到了左边比5小，右边比5大的目的。之后对左右子序列递归排序，最终得到有序序列。
上面留下来了一个问题为什么一定要j指针先动呢？首先这也不是绝对的，这取决于基准数的位置，因为在最后两个指针相遇的时候，要交换基准数到相遇的位置。一般选取第一个数作为基准数，那么就是在左边，所以最后相遇的数要和基准数交换，那么相遇的数一定要比基准数小。所以j指针先移动才能先找到比基准数小的数。
快速排序是不稳定的，其时间平均时间复杂度是O(nlgn)。
实现代码：
public class QuickSort
public static void sort(int[] arr)
if (arr == null || arr.length == 0)
return;
quickSort(arr, 0, arr.length - 1);
public static void quickSort(int[] arr, int left, int right)
if (left >= right)
return;
int pivotPos = partition(arr, left, right);
quickSort(arr, left, pivotPos - 1);
quickSort(arr, pivotPos + 1, right);
//一次划分
public static int partition(int[] arr, int left, int right)
int pivotKey = arr[left];
int pivotPointer = left;
while (left < right)
while (left < right && arr[right] >= pivotKey)
right--;
while (left < right && arr[left] <= pivotKey)
left++;
swap(arr, left, right); //把大的交换到右边，把小的交换到左边。
swap(arr, pivotPointer, left); //最后把pivot交换到中间
return left;
public static void swap(int[] arr, int left, int right)
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
其实上面的代码还可以再优化，上面代码中基准数已经在pivotKey中保存了，所以不需要每次交换都设置一个temp变量，在交换左右指针的时候只需要先后覆盖就可以了。这样既能减少空间的使用还能降低赋值运算的次数。优化代码如下：
public static int partition(int[] arr, int left, int right)
int pivotKey = arr[left];
int pivotPointer = left;
while (left < right)
while (left < right && arr[right] >= pivotKey)
right--;
// 去除swap方法
arr[left] = arr[right]; //小的移动到左边
while (left < right && arr[left] <= pivotKey)
left++;
arr[right] = arr[left]; //大的移动到右边
arr[left] = pivotKey;
return left;
总结快速排序的思想：冒泡+二分+递归分治，慢慢体会。。。
堆排序
堆排序是借助堆来实现的选择排序，思想同简单的选择排序，以下以大顶堆为例。注意：如果想升序排序就使用大顶堆，反之使用小顶堆。原因是堆顶元素需要交换到序列尾部。
首先，实现堆排序需要解决两个问题：
1. 如何由一个无序序列键成一个堆？
2. 如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？
第一个问题，可以直接使用线性数组来表示一个堆，由初始的无序序列建成一个堆就需要自底向上从第一个非叶元素开始挨个调整成一个堆。
第二个问题，怎么调整成堆？首先是将堆顶元素和最后一个元素交换。然后比较当前堆顶元素的左右孩子节点，因为除了当前的堆顶元素，左右孩子堆均满足条件，这时需要选择当前堆顶元素与左右孩子节点的较大者（大顶堆）交换，直至叶子节点。我们称这个自堆顶自叶子的调整成为筛选。
从一个无序序列建堆的过程就是一个反复筛选的过程。若将此序列看成是一个完全二叉树，则最后一个非终端节点是n/2取底个元素，由此筛选即可。举个栗子：
49,38,65,97,76,13,27,49序列的堆排序建初始堆和调整的过程如下：
实现代码：
/**
* 堆排序算法的突現，以大顶堆为例
*/
public class HeapSort
/**
* 堆筛选，除了start之外，start-end均満足大顶堆的定义，凋整之后start-end称为一个大顶堆。
*
* @param arr 待凋整数組
* @param start 起始指針
* @param end 結束指針
*/
public static void heapAdjust(int[] arr, int start, int end)
int temp = arr[start];
for (int i = 2 * start + 1; i <= end; i *= 2)
//左右孩子的节点分別内2*i+1,2*i+2
//选择出左右孩子较小的下标
if (i < end && arr[i] < arr[i + 1])
i++;
if (temp >= arr[i])
break; //已经为大顶堆，保持穏定性。
arr[start] = arr[i]; //将子节点上移
start = i; //下一轮篩迭
arr[start] = temp; //插入正确的位置
public static void heapSortl(int[] arr)
if (arr == null || arr.length == 0)
return;
//建立大顶堆
for (int i = arr.length / 2; i >= 0; i--)
heapAdjust(arr, i, arr.length - 1);
for (int i = arr.length - 1; i >= 0; i--)
swap(arr, 0, i);
heapAdjust(arr, 0, i - 1);
public static void swap(int[] arr, int i, int j)
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
希尔排序
希尔排序是插入排序的一种高效率的实现，也叫缩小增量排序。简单的插入排序中，如果待排序列是正序时，时间复杂度是O(n)，如果序列是基本有序的，使用直接插入排序效率就非常高。希尔排序就利用了这个特点。基本思想是：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。
举个栗子：
从上述排序过程可见，希尔排序的特点是，子序列的构成不是简单的逐段分割，而是将某个相隔某个增量的记录组成一个子序列。如上面的例子，第一堂排序时的增量为5，第二趟排序的增量为3。由于前两趟的插入排序中记录的关键字是和同一子序列中的前一个记录的关键字进行比较，因此关键字较小的记录就不是一步一步地向前挪动，而是跳跃式地往前移，从而使得进行最后一趟排序时，整个序列已经做到基本有序，只要作记录的少量比较和移动即可。因此希尔排序的效率要比直接插入排序高。
希尔排序的分析是复杂的，时间复杂度是所取增量的函数，这涉及一些数学上的难题。但是在大量实验的基础上推出当n在某个范围内时，时间复杂度可以达到O(n^1.3)。
实现代码：
public class ShellSort
/**
* 希尔排序的一趟插入
*
* @param arr 待排数组
* @param d 增量
*/
public static void shellInsert(int[] arr, int d)
for (int i = d; i < arr.length; i++)
int j = i - d;
int temp = arr[i];
while (j >= 0 && arr[j] > temp) //从后向前， 找到此其小的数的位置
arr[j + d] = arr[j]; //向后挪动j-=d;
if (j != i - d) //存在比其小的数
arr[j + d] = temp;
public static void shellSort(int[] arr)
if (arr == null || arr.length == 0)
return;
int d = arr.length / 2;
while (d >= 1)
shellInsert(arr, d);
d /= 2;
归并排序
归并排序是另一种不同的排序方法，因为归并排序使用了递归分治的思想，所以理解起来比较容易。其基本思想是，先递归划分子问题，然后合并结果。把待排序列看成由两个有序的子序列，然后合并两个子序列，然后把子序列看成由两个有序序列。。。。。倒着来看，其实就是先两两合并，然后四四合并。。。最终形成有序序列。空间复杂度为O(n)，时间复杂度为O(nlogn)。
举个栗子：
实现代码：
public class MergeSort
public static void mergeSort(int[] arr)
mSort(arr, 0, arr.length - 1);
/**
* 递归分治
*
* @param left 左指針
* @param right 右指針
* @param. arr 待排数組*
*/
public static void mSort(int[] arr, int left, int right)
if (left >= right)
return;
int mid = (left + right) / 2;
mSort(arr, left, mid); //递归排序左边
mSort(arr, mid + 1, right); //递归排序右边
merge(arr, left, mid, right); //合并;
/**
* 合并兩个有序数組
*
* @param arr 待合并数組
* @param left 左指針
* @param mid 中间指針
* @param right 右指針
*/
public static void merge(int[] arr, int left, int mid, int right)
//[left, mid] [mid+1, right]
int[] temp = new int[right - left + 1]; //中间数組
int i = left;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= right)
if (arr[i] <= arr[j])
temp[k++] = arr[i++];
else
temp[k++] = arr[j++];
while (i <= mid)
temp[k++] = arr[i++];
while (j <= right)
temp[k++] = arr[j++];
for (int p = 0; p < temp.length; p++)
arr[left + p] = temp[p];
计数排序
如果在面试中有面试官要求你写一个O(n)时间复杂度的排序算法，你千万不要立刻说：这不可能！虽然前面基于比较的排序的下限是O(nlogn)。但是确实也有线性时间复杂度的排序，只不过有前提条件，就是待排序的数要满足一定的范围的整数，而且计数排序需要比较多的辅助空间。其基本思想是，用待排序的数作为计数数组的下标，统计每个数字的个数。然后依次输出即可得到有序序列。
实现代码：
桶排序
桶排序算是计数排序的一种改进和推广，但是网上有许多资料把计数排序和桶排序混为一谈。其实桶排序要比计数排序复杂许多。
对桶排序的分析和解释借鉴这位兄弟的文章（有改动）：http://hxraid.iteye.com/blog/647759
桶排序的基本思想：
假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函数 ，将待排序列的关键字k映射到第i个桶中(即桶数组B的下标 i) ，那么该关键字k就作为B[i]中的元素(每个桶B[i]都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出B[0]….B[M]中的全部内容即是一个有序序列。bindex=f(key) 其中，bindex 为桶数组B的下标(即第bindex个桶), k为待排序列的关键字。桶排序之所以能够高效，其关键在于这个映射函数，它必须做到：如果关键字k1<k2，那么f(k1)<=f(k2)。也就是说B(i)中的最小数据都要大于B(i-1)中最大数据。很显然，映射函数的确定与数据本身的特点有很大的关系。
举个栗子：
假如待排序列K= 49、 38 、 35、 97 、 76、 73 、 27、 49 。这些数据全部在1—100之间。因此我们定制10个桶，然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中，并在每个非空的桶中进行快速排序后得到如图所示。只要顺序输出每个B[i]中的数据就可以得到有序序列了。
桶排序分析：
桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，希尔排序中的子序列，归并排序中的子问题，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。
对N个关键字进行桶排序的时间复杂度分为两个部分：
(1) 循环计算每个关键字的桶映射函数，这个时间复杂度是O(N)。
(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序，其时间复杂度为 ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。
很显然，第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此，我们需要尽量做到下面两点：
(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。
(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。当然，做到这一点很不容易，数据量巨大的情况下，f(k)函数会使得桶集合的数量巨大，空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。
对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：
O(N)+O(M(N/M)log(N/M))=O(N+N(logN-logM))=O(N+NlogN-N*logM)
当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。
总结： 桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。此外，桶排序是稳定的。
实现代码：
基数排序
基数排序又是一种和前面排序方式不同的排序方式，基数排序不需要进行记录关键字之间的比较。基数排序是一种借助多关键字排序思想对单逻辑关键字进行排序的方法。所谓的多关键字排序就是有多个优先级不同的关键字。比如说成绩的排序，如果两个人总分相同，则语文高的排在前面，语文成绩也相同则数学高的排在前面。。。如果对数字进行排序，那么个位、十位、百位就是不同优先级的关键字，如果要进行升序排序，那么个位、十位、百位优先级一次增加。基数排序是通过多次的收分配和收集来实现的，关键字优先级低的先进行分配和收集。
举个栗子：
实现代码：
总结
在前面的介绍和分析中我们提到了冒泡排序、选择排序、插入排序三种简单的排序及其变种快速排序、堆排序、希尔排序三种比较高效的排序。后面我们又分析了基于分治递归思想的归并排序还有计数排序、桶排序、基数排序三种线性排序。我们可以知道排序算法要么简单有效，要么是利用简单排序的特点加以改进，要么是以空间换取时间在特定情况下的高效排序。但是这些排序方法都不是固定不变的，需要结合具体的需求和场景来选择甚至组合使用。才能达到高效稳定的目的。没有最好的排序，只有最适合的排序。
下面就总结一下排序算法的各自的使用场景和适用场合。
1. 从平均时间来看，快速排序是效率最高的，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。而后者相比较的结果是，在n较大时归并排序使用时间较少，但使用辅助空间较多。
2. 上面说的简单排序包括除希尔排序之外的所有冒泡排序、插入排序、简单选择排序。其中直接插入排序最简单，但序列基本有序或者n较小时，直接插入排序是好的方法，因此常将它和其他的排序方法，如快速排序、归并排序等结合在一起使用。
3. 基数排序的时间复杂度也可以写成O(d*n)。因此它最使用于n值很大而关键字较小的的序列。若关键字也很大，而序列中大多数记录的最高关键字均不同，则亦可先按最高关键字不同，将序列分成若干小的子序列，而后进行直接插入排序。
4. 从方法的稳定性来比较，基数排序是稳定的内排方法，所有时间复杂度为O(n^2)的简单排序也是稳定的。但是快速排序、堆排序、希尔排序等时间性能较好的排序方法都是不稳定的。稳定性需要根据具体需求选择。
5. 上面的算法实现大多数是使用线性存储结构，像插入排序这种算法用链表实现更好，省去了移动元素的时间。具体的存储结构在具体的实现版本中也是不同的。
附：基于比较排序算法时间下限为O(nlogn)的证明：
基于比较排序下限的证明是通过决策树证明的，决策树的高度Ω（nlgn），这样就得出了比较排序的下限。
首先要引入决策树。 首先决策树是一颗二叉树，每个节点表示元素之间一组可能的排序，它予以京进行的比较相一致，比较的结果是树的边。 先来说明一些二叉树的性质，令T是深度为d的二叉树，则T最多有2^片树叶。 具有L片树叶的二叉树的深度至少是logL。 所以，对n个元素排序的决策树必然有n!片树叶（因为n个数有n!种不同的大小关系），所以决策树的深度至少是log(n!)，即至少需要log(n!)次比较。 而 log(n!)=logn+log(n-1)+log(n-2)+…+log2+log1 >=logn+log(n-1)+log(n-2)+…+log(n/2) >=(n/2)log(n/2) >=(n/2)logn-n/2 =O(nlogn) 所以只用到比较的排序算法最低时间复杂度是O(nlogn)。
面试中的排序算法总结(代码片段)
...多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官... 查看详情
代码面试最常用的10大算法
摘要：面试也是一门学问，在面试之前做好充分的准备则是成功的必须条件，而程序员在代码面试时，常会遇到编写算法的相关问题，比如排序、二叉树遍历等等。在程序员的职业生涯中，算法亦算是一门基础课程，尤其是在面... 查看详情
面试中的排序算法总结
...多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官... 查看详情
代码最常用的10大算法
摘要：面试也是一门学问，在面试之前做好充分的准备则是成功的必须条件，而程序员在代码面试时，常会遇到编写算法的相关问题，比如排序、二叉树遍历等等。在程序员的职业生涯中，算法亦算是一门基础课程，尤其是在面... 查看详情
算法总结(代码片段)
...多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官... 查看详情
java面试题常见算法总结(代码片段)
常见算法1、7种常见排序算法1.1、冒泡排序1.2、简单选择排序1.3、直接插入排序1.4、希尔排序1.5、归并排序1.6、快速排序1.7、堆排序1、7种常见排序算法7种常见排序算法的时间复杂度、辅助空间以及稳定性对照表。排序算法平均... 查看详情
排序算法大汇总(代码片段)
...本最常用的算法，也是各大上市公司经常会被问道的面试知识点之一，不同的排序算法在不同的场景或应用中会有不同的表现，我们需要对各种排序算法熟练才能将它应用到实际应用中，才能更好的发挥他们的优... 查看详情
总结：大厂面试常考手撕代码——javascript排序算法（冒泡排序选择排序插入排序快速排序）(代码片段)
文章目录1.冒泡排序2.选择排序3.插入排序4.快速排序1.冒泡排序//冒泡排序letarr=[2,4,1,6,3]functionbubbled(arr)for(leti=0;i<arr.length-1;i++)//【！！注意】这里不是j=i，因为回回都必须重头遍历，才能不漏一个... 查看详情
常见的排序算法总结(代码片段)
...中，经常会被问到是否了解常见的算法，所以，如果想在面试过程中有个良好的表现，对常见的排序算法有一定的了解是必须的。 七种常见排序算法总结第一类：交换排序1、冒泡排序原理说明：（1）比较相邻的元素，如果... 查看详情
js排序算法总结：基数排序(代码片段)
目的：掌握基数排序 的 基本思想与过程、代码实现、时间复杂度1、基本思想与过程：（只针对数字） （1）首先确定基数为10，数组的长度也就是10.每个数都会在这10个数中寻找自己的位置。 （2）不同于BinSort会... 查看详情
10大排序算法的实现(java语言)(代码片段)
10大排序算法的实现(Java语言)1-冒泡排序算法思想：每次扫描待排序的元素,相邻元素满足排序条件，则交换,每一趟排序使最大(或最小)元素放置到末尾，经过n-1次扫描完成排序，最坏情况是扫描后交换,最好情况是... 查看详情
挖掘算法中的数据结构：排序算法总结和索引堆及优化（堆结构）(代码片段)
...排序算法总结索引堆及其优化堆结构衍生的问题挖掘算法中的数据结构 查看详情
数组中的排序分析及奇偶排序-算法数据结构面试分享(代码片段)
数组中的排序分析及奇偶排序我们之前在课本上学习过一般的排序方法，如冒泡，快排，插入，归并。其中时间复杂度有O(N),和O(Nlogn),以及O(N2）的。今天我们在这里看一些特定情况下的排序，并否所有的排序都是基于大小的，有... 查看详情
面试系列之排序算法总结(c/c++版本)(代码片段)
冒泡排序/*冒泡排序是一种流行但低效的算法，它的作用是反复交换相邻的未按次序排列的元素*/#include<stdio.h>voidExchange(int&a,int&b)//使用位运算，秀一秀自己的实力a=a^b;b=a^b;a=a^b;voidBubbleSort(inta[],intlen)//... 查看详情
面试系列之排序算法总结(c/c++版本)(代码片段)
冒泡排序/*冒泡排序是一种流行但低效的算法，它的作用是反复交换相邻的未按次序排列的元素*/#include<stdio.h>voidExchange(int&a,int&b)//使用位运算，秀一秀自己的实力a=a^b;b=a^b;a=a^b;voidBubbleSort(inta[],intlen)//... 查看详情
排序算法总结(代码片段)
...循环n-1次，使用顺序查找法，判断arr[i]在序列arr[0]~arr[i-1]中的位置，然后将arr[i]插入序列arr[0]~arr[i]中，得到arr[0]~arr[i]的有序序列，继续循环，最终得到长度为n的有序序列arr[n]。 演示：无序数组p[]=51,22,56,81,17,23,90,16;&n 查看详情
200道大数据面试常考leetcode算法题--数组篇02（python带代码解析）(代码片段)
...往期16-20数组篇01大家好，继续为大家推荐200道大数据面试常考Leetcode算法题，这期为--数组篇，附带解析，都是从Leetcode官网总结大神们的解法（在这里感谢大神的帮助，我只是个搬运工！）每篇更... 查看详情
算法面试中的时间复杂度分析(代码片段)
例子：有一个字符串数组，首先将数组中每一个字符串按照字母序排序，之后再将整个字符串按照字典序排序。整个操作的时间复杂度？答：假设最长的字符串长度是s，数组中有n个字符串。对每个字符串进行排序:slogs，共有n个... 查看详情