面试时的Java数据结构与算法Word格式.docx
《面试时的Java数据结构与算法Word格式.docx》由会员分享，可在线阅读，更多相关《面试时的Java数据结构与算法Word格式.docx（23页珍藏版）》请在冰豆网上搜索。
return;
for（inti=0;
i）{
for（intj=arr.length-1;
j>
i;
j--）{
if（arr[j]]）{
swap（arr,j-1,j）;
}
publicstaticvoidswap（int[]arr,inti,intj）{
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
选择排序
选择排序的思想其实和冒泡排序有点类似，都是在一次排序后把最小的元素放到最前面。
但是过程不同，冒泡排序是通过相邻的比较和交换。
而选择排序是通过对整体的选择。
举个栗子，对5,3,8,6,4这个无序序列进行简单选择排序，首先要选择5以外的最小数来和5交换，也就是选择3和5交换，一次排序后就变成了3,5,8,6,4.对剩下的序列一次进行选择和交换，最终就会得到一个有序序列。
其实选择排序可以看成冒泡排序的优化，因为其目的相同，只是选择排序只有在确定了最小数的前提下才进行交换，大大减少了交换的次数。
选择排序的时间复杂度为O（n^2）。
简单选择排序算法的实现
publicclassSelectSort{
publicstaticvoidselectSort（int[]arr）{
intminIndex=0;
i//只需要比较n-1次
minIndex=i;
for（intj=i+1;
j//从i+1开始比较，因为minIndex默认为i了，i就没必要比了。
if（arr[j]arr[minIndex]）{
minIndex=j;
if（minIndex!
=i）{//如果minIndex不为i，说明找到了更小的值，交换之。
swap（arr,i,minIndex）;
插入排序
插入排序不是通过交换位置而是通过比较找到合适的位置插入元素来达到排序的目的的。
相信大家都有过打扑克牌的经历，特别是牌数较大的。
在分牌时可能要整理自己的牌，牌多的时候怎么整理呢？
就是拿到一张牌，找到一个合适的位置插入。
这个原理其实和插入排序是一样的。
举个栗子，对5,3,8,6,4这个无序序列进行简单插入排序，首先假设第一个数的位置时正确的，想一下在拿到第一张牌的时候，没必要整理。
然后3要插到5前面，把5后移一位，变成3,5,8,6,4.想一下整理牌的时候应该也是这样吧。
然后8不用动，6插在8前面，8后移一位，4插在5前面，从5开始都向后移一位。
注意在插入一个数的时候要保证这个数前面的数已经有序。
简单插入排序的时间复杂度也是O（n^2）。
简单插入排序算法实现
publicclassInsertSort{
publicstaticvoidinsertSort（int[]arr）{
for（inti=1;
i//假设第一个数位置时正确的；
要往后移，必须要假设第一个。
intj=i;
inttarget=arr[i];
//待插入的
//后移
while（j>
0&
target]）{
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）。
实现快速排序算法
publicclassQuickSort{
//一次划分
publicstaticintpartition（int[]arr,intleft,intright）{
intpivotKey=arr[left];
intpivotPointer=left;
while（leftright）{
while（left=pivotKey）
right--;
while（leftpivotKey）
left++;
swap（arr,left,right）;
//把大的交换到右边，把小的交换到左边。
swap（arr,pivotPointer,left）;
//最后把pivot交换到中间
returnleft;
publicstaticvoidquickSort（int[]arr,intleft,intright）{
if（left>
=right）
intpivotPos=partition（arr,left,right）;
quickSort（arr,left,pivotPos-1）;
quickSort（arr,pivotPos+1,right）;
publicstaticvoidsort（int[]arr）{
quickSort（arr,0,arr.length-1）;
publicstaticvoidswap（int[]arr,intleft,intright）{
inttemp=arr[left];
arr[left]=arr[right];
arr[right]=temp;
其实上面的代码还可以再优化，上面代码中基准数已经在pivotKey中保存了，所以不需要每次交换都设置一个temp变量，在交换左右指针的时候只需要先后覆盖就可以了。
这样既能减少空间的使用还能降低赋值运算的次数。
优化代码如下：
/**
*划分
*@paramarr
*@paramleft
*@paramright
*@return
//把小的移动到左边
arr[right]=arr[left];
//把大的移动到右边
arr[left]=pivotKey;
//最后把pivot赋值到中间
*递归划分子序列
总结快速排序的思想：
冒泡+二分+递归分治，慢慢体会。
。
堆排序
堆排序是借助堆来实现的选择排序，思想同简单的选择排序，以下以大顶堆为例。
注意：
如果想升序排序就使用大顶堆，反之使用小顶堆。
原因是堆顶元素需要交换到序列尾部。
首先，实现堆排序需要解决两个问题：
如何由一个无序序列键成一个堆？
如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？
第一个问题，可以直接使用线性数组来表示一个堆，由初始的无序序列建成一个堆就需要自底向上从第一个非叶元素开始挨个调整成一个堆。
第二个问题，怎么调整成堆？
首先是将堆顶元素和最后一个元素交换。
然后比较当前堆顶元素的左右孩子节点，因为除了当前的堆顶元素，左右孩子堆均满足条件，这时需要选择当前堆顶元素与左右孩子节点的较大者（大顶堆）交换，直至叶子节点。
我们称这个自堆顶自叶子的调整成为筛选。
从一个无序序列建堆的过程就是一个反复筛选的过程。
若将此序列看成是一个完全二叉树，则最后一个非终端节点是n/2取底个元素，由此筛选即可。
49,38,65,97,76,13,27,49序列的堆排序建初始堆和调整的过程如下：
堆排序算法的实现，以大顶堆为例。
publicclassHeapSort{
*堆筛选，除了start之外，start~end均满足大顶堆的定义。
*调整之后start~end称为一个大顶堆。
*@paramarr待调整数组
*@paramstart起始指针
*@paramend结束指针
publicstaticvoidheapAdjust（int[]arr,intstart,intend）{
inttemp=arr[start];
for（inti=2*start+1;
//左右孩子的节点分别为2*i+1,2*i+2
//选择出左右孩子较小的下标
if（i]）{
i++;
if（temp>
=arr[i]）{
break;
//已经为大顶堆，=保持稳定性。
arr[start]=arr[i];
//将子节点上移
start=i;
//下一轮筛选
arr[start]=temp;
//插入正确的位置
publicstaticvoidheapSort（int[]arr）{
//建立大顶堆
for（inti=arr.length/2;
i>
=0;
i--）{
heapAdjust（arr,i,arr.length-1）;
for（inti=arr.length-1;
swap（arr,0,i）;
heapAdjust（arr,0,i-1）;
希尔排序
希尔排序是插入排序的一种高效率的实现，也叫缩小增量排序。
简单的插入排序中，如果待排序列是正序时，时间复杂度是O（n），如果序列是基本有序的，使用直接插入排序效率就非常高。
希尔排序就利用了这个特点。
基本思想是：
先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。
从上述排序过程可见，希尔排序的特点是，子序列的构成不是简单的逐段分割，而是将某个相隔某个增量的记录组成一个子序列。
如上面的例子，第一堂排序时的增量为5，第二趟排序的增量为3。
由于前两趟的插入排序中记录的关键字是和同一子序列中的前一个记录的关键字进行比较，因此关键字较小的记录就不是一步一步地向前挪动，而是跳跃式地往前移，从而使得进行最后一趟排序时，整个序列已经做到基本有序，只要作记录的少量比较和移动即可。
因此希尔排序的效率要比直接插入排序高。
希尔排序的分析是复杂的，时间复杂度是所取增量的函数，这涉及一些数学上的难题。
但是在大量实验的基础上推出当n在某个范围内时，时间复杂度可以达到O（n^1.3）。
希尔排序算法实现
publicclassShellSort{
*希尔排序的一趟插入
*@paramarr待排数组
*@paramd增量
publicstaticvoidshellInsert（int[]arr,intd）{
for（inti=d;
intj=i-d;
//记录要插入的数据
while（j>
=0&
arr[j]>
temp）{//从后向前，找到比其小的数的位置
arr[j+d]=arr[j];
//向后挪动
j-=d;
}
if（j!
=i-d）//存在比其小的数
arr[j+d]=temp;
publicstaticvoidshellSort（int[]arr）{
intd=arr.length/2;
while（d>
=1）{
shellInsert（arr,d）;
d/=2;
归并排序
归并排序是另一种不同的排序方法，因为归并排序使用了递归分治的思想，所以理解起来比较容易。
其基本思想是，先递归划分子问题，然后合并结果。
把待排序列看成由两个有序的子序列，然后合并两个子序列，然后把子序列看成由两个有序序列。
倒着来看，其实就是先两两合并，然后四四合并。
最终形成有序序列。
空间复杂度为O（n），时间复杂度为O（nlogn）。
归并排序算法的实现
publicclassMergeSort{
publicstaticvoidmergeSort（int[]arr）{
mSort（arr,0,arr.length-1）;
*递归分治
*@paramleft左指针
*@paramright右指针
publicstaticvoidmSort（int[]arr,intleft,intright）{
intmid=（left+right）/2;
mSort（arr,left,mid）;
//递归排序左边
mSort（arr,mid+1,right）;
//递归排序右边
merge（arr,left,mid,right）;
//合并
*合并两个有序数组
*@paramarr待合并数组
*@parammid中间指针
publicstaticvoidmerge（int[]arr,intleft,intmid,intright）{
//[left,mid][mid+1,right]
int[]temp=newint[right-left+1];
//中间数组
inti=left;
intj=mid+1;
intk=0;
while（iright）{
if（arr[i]arr[j]）{
temp[k++]=arr[i++];
else{
temp[k++]=arr[j++];
while（imid）{
while（jright）{
for（intp=0;
p）{
arr[left+p]=temp[p];
计数排序
如果在面试中有面试官要求你写一个O（n）时间复杂度的排序算法，你千万不要立刻说：
这不可能！
虽然前面基于比较的排序的下限是O（nlogn）。
但是确实也有线性时间复杂度的排序，只不过有前提条件，就是待排序的数要满足一定的范围的整数，而且计数排序需要比较多的辅助空间。
其基本思想是，用待排序的数作为计数数组的下标，统计每个数字的个数。
然后依次输出即可得到有序序列。
计数排序算法实现
publicclassCountSort{
publicstaticvoidcountSort（int[]arr）{
intmax=max（arr）;
int[]count=newint[max+1];
Arrays.fill（count,0）;
count[arr[i]]++;
for（intj=0;
j）{
arr[k++]=i;
publicstaticintmax（int[]arr）{
intmax=Integer.MIN_VALUE;
for（intele:
rr）{
if（ele>
max）
max=ele;
returnmax;
桶排序
桶排序算是计数排序的一种改进和推广，但是网上有许多资料把计数排序和桶排序混为一谈。
其实桶排序要比计数排序复杂许多。
桶排序的基本思想：
假设有一组长度为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
假如待排序列K=
升级会员 