算法积累_java_插入，选择，冒泡，快速排序

      排序是算法中最基本，也是非常重要的一部分内容，自己在面试互联网公司的时候，基本上都会作为基础题被考查，有时候是手写算法代码，有时候比较各个算法的特点，现在将这些排序算法进行整理，方便自己以后复习，也希望能和大家分享，水平有限，相互交流，在写本篇博文时参考了以下博主的博文，他们才是大神，学习学习：

       博主：真实的归宿    网址链接：  http://blog.csdn.net/hguisu/article/details/7776068
      博主：路漫漫           网址链接：  http://blog.chinaunix.net/uid-21457204-id-3060260.html

      排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

       接下来我就几种常用的，经常被面试提问的几种排序算法进行整理，分别从原理，java代码实现，特点（复杂度和适用场景）整理一下。

   插入排序---直接插入排序

基本思想:
     将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

直接插入排序示例：





       如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

int[] arr={15,45,77,45,32,30,11};
int n=arr.length;
int temp;
for(int i=1;i<n;i++){//进行n-1趟插入
temp=arr[i];//temp记录本趟要进行插入的元素值
int j=i-1;

//
4000
与已排序的数进行逐一比较，大于temp,该数后移
while((j>=0)&&(arr[j]>temp))
{
arr[j+1]=arr[j];
j--;
}
arr[j+1]=temp;
}
for(int i=0;i<n;i++){
System.out.print(arr[i]+" ");
}

   插入排序---希尔排序

基本思想：
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
操作方法：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
希尔排序的示例：



算法实现日后补进。

 
冒泡排序

基本思想：
       在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
冒泡排序的示例：

 

int temp, i, j;
int n = arr.length;
for (i = n - 1; i > 0; i--) {
for (j = 0; j < i; j++) {
if (arr[j + 1] < arr[j]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
for (i = 0; i < n; i++)
System.out.print(arr[i] + " ");

效率：冒泡排序是一种用时间换空间的排序方法，最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序。

[b]快速排序[/b]

基本思想：
1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。
快速排序的示例：
（a）一趟排序的过程：



（b）排序的全过程

//快速排序
static int partition(int n[],int left,int right){//找key位置
int pivot=n[left];
while(left<right){
while((left<right)&&(n[right]>=pivot))
right--;
if(left<right)
n[left++]=n[right];
while((left<right)&&(n[left])<=pivot)
left++;
if(left<right)
n[right--]=n[left];

}
n[left]=pivot;
return left;
}

static void quicksort(int n[],int left,int right)//快速排序，递归
{
int dp;
if(left<right){
dp=partition(n,left,right);
quicksort(n,left,dp-1);
quicksort(n,dp+1,right);
}
}
public static void main(String args[]){//主函数
int[] arr={15,12,33,5,9,154,33,10};
quicksort(arr,0,7);
for(int i=0;i<=7;i++)
System.out.print(arr[i]+" ");
}

选择排序---简单选择排序

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

 


操作方法：
第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

int i,j,min,n,temp;
n=arr.length;
for(i=0;i<n-1;i++){
min=i;
for(j=i+1;j<n;j++){
if(arr[min]>arr[j])
min=j;
}
if(min!=i){
temp=arr[i];
arr[i]=arr[min];
arr[min]=temp;
}
}
for(i=0;i<n;i++){
System.out.print(arr[i]+" ");
}

选择排序---堆排序

     堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：
     堆的定义如下：具有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）

                              


                              


算法实现日后补进。

排序算法分析