今天第一次面试，发现自己练最简单的几种排序都弄不清楚，自然是挂了，错失了一个绝好的实习的机会。痛定思痛，我决定从最基本的东西开始，好好学习、总结。
1 选择排序
一种最简单的排序，每次都是找到最小的那个元素，放到最左边。交换次数和比较次数比起来可以忽略，因此算法的时间效率大部分取决于比较次数。
不管原来数组的顺序是怎样的，比较次数不变，都是N^2/2次比较，时间复杂度为O(n^2)
2..1插入排序
实现方法是，索引左边的元素都是有序的，每次循环都先区右边的一个，按大小插入左边的序列里面。
关键代码：
for(int i=1;i<N,;i++){
for(int j=i;j>0&&a[j]<a[j-1];j--)
exch(a,j,j-1);
}
}平均需要(N^2/4)次比较以及(N^2/4)次交换。最坏情况(N^2/2)次比较以及(N^2/2)次交换,最好情况下N--1次比较，0交换
2.2 希尔排序
基本思想就是https://v.qq.com/x/page/d0512rtano3.html
不能比这个三分钟的视频更形象了，语言太苍白无力了。
void ShellSort(int a[], int n)
{ int i, j, gap;
for (gap = n / 2; gap > 0; gap /= 2)
for (i = gap; i < n; i++)
for (j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
swap(a,j,j+gap);
}
3.冒泡排序
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列
的顶端。
冒泡排序算法的运作如下:
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
-
for (int i = 0; i < score.length -1; i++){ //最多做n-1趟排序
5 for(int j = 0 ;j < score.length - i - 1; j++){ //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
6 if(score[j] < score[j + 1]){ //把小的值交换到后面
7 int temp = score[j];
8 score[j] = score[j + 1];
9 score[j + 1] = temp;
10 }
11 }
在右边界加index，减少不必要的循环次数。
void Bubble_1 ( int r[], int n) {
int i= n -1; //初始时,最后位置保持不变
while ( i> 0) {
int pos= 0; //每趟开始时,无记录交换
for (int j= 0; j< i; j++)
if (r[j]> r[j+1]) {
pos= j; //记录交换的位置
int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
}
i= pos; //为下一趟排序作准备
}
} 复杂度O(n^2)
4.选择排序
不用多说 复杂度O(n^2)
简单选择排序的改进——二元选择排序
简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：
5堆排序(参考http://blog.csdn.net/hguisu/article/details/7776068/)
即：将两个有序的数组归并成一个更大的有序数组。
堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足
时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：
（a）大顶堆序列：（96, 83,27,38,11,09)
(b) 小顶堆序列：（12，36，24，85，47，30，53，91）
初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。
因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。
首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：
1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。
2）将根结点与左、右子树中较小元素的进行交换。
3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.
4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.
5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。
称这个自根结点到叶子结点的调整过程为筛选。如图：
再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。
1）n 个结点的完全二叉树，则最后一个结点是第
个结点的子树。
2）筛选从第个结点为根的子树开始，该子树成为堆。
3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。
如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）
具体代码实现：
//堆排序
public void heapSort(int[] arr){
int length = arr.length;
for(int i=(arr.length-1)/2;i>=0;i--)
buildHeap(arr,length, i);
while(length>0){
System.out.println(arr[0]);
arr[0]=arr[length-1];
length--;
buildHeap(arr, length,0);
}
}
//建立初始堆
public void buildHeap(int[] arr,int length,int i){
int k1=2*i+1,k2=i*2+2;
if(k1>length-1&&k2>length-1) return;
int a1 = Integer.MAX_VALUE;
int a2 = Integer.MAX_VALUE;
if(k1<=length-1) a1=arr[k1];
if(k2<=length-1) a2=arr[k2];
if(arr[i]<=a1&&arr[i]<=a2) return;
if(a1<a2){
swap(arr, i, k1);
buildHeap(arr, length, k1);
}else{
swap(arr, i, k2);
buildHeap(arr, length, k2);
}
}
6快速排序
基本思想：
1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。
实现代码：
//快速排序
public void quickSort(int[] arr,int low ,int high){
if(low<high){
int begin = quickSortCore(arr, low, high);
quickSort(arr, low, begin-1);
quickSort(arr, begin+1, high);
}
}
public int quickSortCore(int[] arr,int low ,int high){
int key = low;
while(low<high){
while(low<high&&arr[key]<=arr[high]) high--;
swap(arr, key, high);
key = high;
while(low<high&&arr[low]<=arr[key]) low++;
swap(arr, low, key);
key = low;
}
return key;
}改进：为了减少递归次数，为快排设置一个数组长度最小值。当小于最小值时，最后用一下插入排序。代码：
public void quickSort(int[] arr,int low ,int high){
if(high-low>4){
int begin = quickSortCore(arr, low, high);
quickSort(arr, low, begin-1);
quickSort(arr, begin+1, high);
}
for(int i=1;i<arr.length;i++){
for(int j=i;j>=1&&arr[j]<arr[j-1];j--){
swap(arr,j,j-1);
}
}}
7归并排序
public void mergeSort(int[] arr){
if(arr==null||arr.length==0)
return;
int length = arr.length;
int[] dp = new int[length];
mergeS(arr,0,length-1,dp);
}
private void mergeS(int[] arr, int first, int last, int[] dp) {
if(first<last){
int mid = (first+last)/2;
mergeS(arr, first, mid, dp);
mergeS(arr, mid+1, last, dp);
mergeArray(arr,first,mid,last,dp);
}
}
private void mergeArray(int[] arr, int first, int mid, int last, int[] dp) {
int k1 = first;
int k2 = mid+1;
int index = 0;
while(k1<=mid&&k2<=last){
if(arr[k1]<arr[k2])
dp[index++]=arr[k1++];
else {
dp[index++]=arr[k2++];
}
}
while(k1<=mid)
dp[index++]=arr[k1++];
while(k2<=last)
dp[index++]=arr[k2++];
for(int i=0;i<index;i++)
arr[first+i]=dp[i];
}原理讲解http://www.iqiyi.com/v_19rrhzzy84.html
最后参考博客：http://blog.csdn.net/hguisu/article/details/7776068
总结
各种排序的稳定性，时间复杂度和空间复杂度总结：
我们比较时间复杂度函数的情况：
时间复杂度函数O(n)的增长情况
所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说：
(1)平方阶(O(n2))排序
各类简单排序:直接插入、直接选择和冒泡排序；
(2)线性对数阶(O(nlog2n))排序
快速排序、堆排序和归并排序；
(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序
(4)线性阶(O(n))排序
基数排序，此外还有桶、箱排序。
说明：
当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；
而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；
原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性：
排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。
稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序
选择排序算法准则：
每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。
选择排序算法的依据
影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：
1．待排序的记录数目n的大小；
2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；
3．关键字的结构及其分布情况；
4．对排序稳定性的要求。
设待排序元素的个数为n.
1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序 ： 如果内存空间允许且要求稳定性的，
归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。
2） 当n较大，内存空间允许，且要求稳定性 =》归并排序
3）当n较小，可采用直接插入或直接选择排序。
直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。
直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序
5）一般不使用或不直接使用传统的冒泡排序。
6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
1、关键字可分解。
2、记录的关键字位数较少，如果密集更好
3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。
1506
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
