8大排序算法的java实现--做个人收藏
排序算法分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因为数据量太大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。这里只讨论内部排序，常见的内部排序算法有：插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、及基数排序。
1、插入排序
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序的数据，在已排序序列中从后往前扫描，找到相应位置并插入。算法步骤如下：
- 将第一个待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成未排序序列；
- 从头到尾一次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置，即满足有序的顺序，若相等，则插入到这个相等元素的后面。
插入排序java代码：
1 public class InsertSort { 2 public static void insertSort(int []data){ 3 for(int i=0;i<data.length-1;i++){ 4 int temp=data[i+1]; 5 int j=i; 6 while(j>-1&&data[j]>temp){ 7 data[j+1]=data[j]; 8 j--; 9 } 10 data[j+1]=temp; 11 } 12 } 13 public static void main(String[] args) { 14 // TODO Auto-generated method stub 15 int data[]=new int[]{12,5,44,11,50,9}; 16 insertSort(data); 17 for(int i:data){ 18 System.out.println(i); 19 } 20 } 21 22 }
2、希尔排序
希尔排序也称为递减增量排序算法，是插入排序的一种改进，其思想是：先将整个待排序的序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。算法步骤如下：
- 选择一个增量序列t1,t2,...,tk，其中ti>tj，tk=1；
- 增量序列个数为k，对序列进行k趟插入排序;
- 每趟排序，根据对应的增量ti，将待排序序列分割成若干长度为m得子序列，然后对各子序列进行直接插入排序，当ti为1时，是对“基本有序”的整个序列排序。
希尔排序实现：
1 public class SellSort { 2 public static void sellSort(int []data){ 3 int []step=new int[]{6,3,1}; 4 int i,j,k; 5 for(int s:step){ 6 for(i=0;i<s;i++){ 7 for(j=i;j<data.length-s;j+=s){ 8 k=j; 9 int temp=data[j+s]; 10 while(k>-1&&data[k]>temp){ 11 data[k+s]=data[k]; 12 k-=s; 13 } 14 data[k+s]=temp; 15 } 16 } 17 } 18 } 19 public static void main(String[] args) { 20 // TODO Auto-generated method stub 21 int []data=new int[]{12,5,44,11,50,9,23,32}; 22 sellSort(data); 23 for(int i:data){ 24 System.out.println(i); 25 } 26 } 27 28 }
3、选择排序
选择排序是一种简单直观的排序算法，基本思想是：对待排序序列进行扫描，每次找到最小（大）的元素，然后和未排序序列的首元素进行交换，直到所有的待排序序列都是有序的为止。算法步骤如下：
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
- 再从剩余未排序序列中继续寻找最小（大）元素，然后放到已排序序列的末尾；
- 重复第二步，直到所有元素排序完毕。
选择排序实现代码：
1 public class SelectSort { 2 3 public static void selectSort(int []data){ 4 for(int i=0;i<data.length;i++){ 5 int minIndex=i;//每次记录值最小的下标 6 int temp; 7 for(int j=i+1;j<data.length;j++){ 8 if(data[j]<data[minIndex]) minIndex=j; 9 } 10 temp=data[i]; 11 data[i]=data[minIndex]; 12 data[minIndex]=temp; 13 } 14 } 15 public static void main(String[] args) { 16 // TODO Auto-generated method stub 17 int []data=new int[]{12,5,44,11,50,9}; 18 selectSort(data); 19 for(int i:data){ 20 System.out.println(i); 21 } 22 } 23 24 }
4、堆排序
堆排序是利用堆这种数据结构所设计的一种排序算法。这个堆所满足的性质是：子结点的键值总是不小于（不大于）它的父结点。算法基本步骤如下：
- 把未排序序列创建成为一个堆；
- 把堆首（为最大（小）值）和堆尾互换；
- 堆的规模减1，调整堆；
- 重复，直到所有元素排序完成。
堆排序实现：
1 public class HeapSort { 2 //初始化数组为最大堆 3 private static void initCreateHeap(int []data){ 4 for(int i=data.length/2-1;i>=0;i--){ 5 adjHeap(data,data.length,i); 6 } 7 } 8 //调整结点data[h],使之满足最大堆，n为data中剩余未排序的元素的个数 9 private static void adjHeap(int []data,int n,int h){ 10 int i=h; 11 int l=2*i+1; 12 int temp=data[i]; 13 boolean flag=true; 14 while(l<n&&flag){ 15 if(l+1<n&&data[l]<data[l+1]) l++; 16 if(temp>data[l]){ 17 flag=false; 18 }else{ 19 data[i]=data[l]; 20 data[l]=temp; 21 i=l; 22 l=2*i+1; 23 } 24 } 25 } 26 public static void heapSort(int []data){ 27 initCreateHeap(data); 28 for(int i=data.length-1;i>0;i--){ 29 int temp=data[i]; 30 data[i]=data[0]; 31 data[0]=temp; 32 adjHeap(data,i,0); 33 } 34 } 35 public static void main(String[] args) { 36 // TODO Auto-generated method stub 37 int []data=new int[]{12,5,44,11,50,9,23,32}; 38 heapSort(data); 39 for(int i:data){ 40 System.out.println(i); 41 } 42 } 43 44 }
5、冒泡排序
冒泡排序的基本思想是遍历未排序序列，把相邻的元素调整为有序，这样每次都会有最大（小）的元素出现在未排序序列的末尾，就跟冒泡泡一样，把这些元素有序地排出来了。算法步骤：
- 比较相邻的元素。如果不满足有序序列，就交换它们；
- 对每一对相邻元素都做同样的工作，从头到尾，最后末尾元素会是最大的数；
- 未排序的元素个数减1，重复以上工作。
算法实现代码：
1 public class BubbleSort { 2 public static void bubbleSort(int []data){ 3 boolean flag=false;//标志位，如果有序可以提前结束循环 4 for(int i=0;i<data.length;i++){ 5 if(flag) break; 6 flag=true; 7 for(int j=0;j<data.length-1-i;j++){ 8 if(data[j]>data[j+1]){ 9 int temp=data[j]; 10 data[j]=data[j+1]; 11 data[j+1]=temp; 12 flag=false; 13 } 14 } 15 } 16 } 17 public static void main(String[] args) { 18 // TODO Auto-generated method stub 19 int []data=new int[]{12,5,44,11,50,9}; 20 bubbleSort(data); 21 for(int i:data){ 22 System.out.println(i); 23 } 24 } 25 26 }
6、快速排序
快速排序的算法使用分治的策略来进行排序的，对于按从小到大的排序具体的实现步骤如下：
- 从数据序列中选出一个元素当基准
- 把比基准小的所有元素放到基准之前，把所有比基准大的元素放到基准之后，这样就把序列划分为以基准为分界的两个分区，基准之前分区的所有元素都比基准小，基准之后的分区的所有元素都比基准大；
- 两个分区递归的重复以上步骤，直到分区的元素个数小于1。
快速排序实现;
1 public class QuickSort { 2 public static void quickSort(int []data,int s,int e){ 3 int i=s,j=e; 4 int temp=data[s]; 5 while(i<j){ 6 while(i<j){ 7 if(data[j]<temp) { 8 data[i]=data[j]; 9 i++; 10 break; 11 } 12 j--; 13 } 14 while(i<j){ 15 if(data[i]>temp) { 16 data[j]=data[i]; 17 j--; 18 break; 19 } 20 i++; 21 } 22 } 23 data[i]=temp; 24 if(s<i)quickSort(data,s,i-1); 25 if(j<e)quickSort(data,j+1,e); 26 } 27 public static void main(String[] args) { 28 // TODO Auto-generated method stub 29 int []data=new int[]{12,5,44,11,50,9}; 30 quickSort(data,0,data.length-1); 31 for(int i:data){ 32 System.out.println(i); 33 } 34 } 35 36 }
7、归并排序
归并排序是建立在归并操作上的一种有效的排序算法，也在采用分治的策略，算法步骤如下;
- 申请空间，使其大小为两个有序序列的和，该空间用来存放合并后的序列；
- 设定指针分别指向有序序列的起始位置；
- 比较两个指针所指向的元素，选择适当的加入合并空间，并移动指针；
- 重复第3步，直到某一指针到达序列尾；
- 将另一序列剩下的元素直接复制到合并序列末尾。
归并算法实现代码：
1 public class MergeSort { 2 //一次归并，k为归并子数组的长度，temp保存归并的中间结果 3 private static void merge(int []data,int []temp,int k){ 4 int l1=0,l2,u1,u2; 5 int n=data.length; 6 int i,j,m=0; 7 8 while(l1+k<=n-1){ 9 u1=l1+k-1; 10 l2=u1+1; 11 u2=(l2+k>n)?n-1:l2+k-1; 12 13 for(i=l1,j=l2;i<=u1&&j<=u2;){ 14 if(data[i]<data[j]){ 15 temp[m++]=data[i++]; 16 }else{ 17 temp[m++]=data[j++]; 18 } 19 } 20 //若子数组1还有剩余的数据，则直接加入temp数组 21 while(i<=u1){ 22 temp[m++]=data[i++]; 23 } 24 //若子数组2还有剩余的数据，则直接加入temp数组 25 while(j<=u2){ 26 temp[m++]=data[j++]; 27 } 28 l1=u2+1; 29 } 30 //将剩余的只够一组的数据加进来 31 for(i=l1;i<n;){ 32 temp[m++]=data[i++]; 33 } 34 35 } 36 public static void mergeSort(int []data){ 37 int []temp=new int[data.length]; 38 int k=1; 39 while(k<data.length){ 40 merge(data,temp,k); 41 for(int j=0;j<data.length;j++) data[j]=temp[j]; 42 k*=2; 43 } 44 45 } 46 public static void main(String[] args) { 47 // TODO Auto-generated method stub 48 int []data=new int[]{12,5,44,11,50,9,23,32,27}; 49 mergeSort(data); 50 for(int i:data){ 51 System.out.println(i); 52 } 53 } 54 55 }
8、基数排序
基数排序也叫做桶排序，是一种非比较型的整数排序算法，基本思想是将整数按位切割成不同的数字，然后放到不同的桶里面，然后根据桶的规则有序输出。实现步骤如下：
- 初始化d个桶，d为序列中数字的进制；
- 按照关键字最低位数值依次放入桶中，然后分别按照桶号顺序元素进桶先后次序收集数据元素，这样就得到一个新的排列，这个过程称为一次基数排序；
- 然后分别按照次地位直到最高位的顺序进行一次基数排序，进行m次基数排序后就会得到有序序列，这里的m是整数序列的最高位数。
基数排序代码：
1 public class RadixSort { 2 private static void radixSort(int []data,int m,int d){ 3 int i,j,k,power=1; 4 int n=data.length; 5 Queue []q=new LinkedList[d]; 6 7 //初始化队列数组 8 for(i=0;i<d;i++){ 9 q[i]=new LinkedList(); 10 } 11 //进行m次桶排序 12 for(i=0;i<m;i++){ 13 for(j=0;j<n;j++){ 14 k=data[j]/power-(data[j]/(power*d))*d;//取得每个数第i位的值 15 q[k].add(data[j]); 16 } 17 for(k=0,j=0;j<d;j++){ 18 while(!q[j].isEmpty()){ 19 data[k++]=(Integer)q[j].remove(); 20 } 21 } 22 power*=d; 23 } 24 } 25 26 public static void main(String[] args) { 27 // TODO Auto-generated method stub 28 int []data=new int[]{710,841,342,45,686,6,429,134,68,264}; 29 int m=3,d=10;//关键字是m位d进制的 30 radixSort(data,m,d); 31 for(int i:data){ 32 System.out.println(i); 33 } 34 } 35 36 }
================================================================================================================================================
以上排序算法归纳：
