常用排序算法 java
比较常见的几种排序：
1.冒泡排序，时间复杂度O（n^2）
2.插入排序，时间复杂度O（n^2）
3.希尔排序，由于是跳跃式的，采用Sedgewick增量序列，猜想时间复杂度O（n^4/3）
4.归并排序，时间复杂度O（nlogn）
//冒泡排序 public class test1 { public static void main(String[] args) { int[] arr=new int[]{6,5,4,3,2,1,0,-1}; arr=bubbleSort(arr,arr.length); for(int i=0;i<arr.length;i++) { System.out.print(arr[i]); } } public static int[] bubbleSort(int[] arr,int n) { for(int j=0;j<n;j++) { for (int i=0;i<n-j-1 ;i++ ) { if (arr[i]>arr[i+1]) { int temp=arr[i]; arr[i]=arr[i+1]; arr[i+1]=temp; } } } return arr; } }
//插入排序 public class InsertSort { public static void main(String[] args) { int[] arr=new int[]{6,5,4,3,2,1,0,-1}; arr=insertSort(arr,arr.length); for(int i=0;i<arr.length;i++) { System.out.print(arr[i]); } } public static int[] insertSort(int[] arr,int n) { for(int i=1;i<n;i++) { int current=arr[i]; for(int j=i;j>0&¤t<arr[j-1];j--) { arr[j]=arr[j-1]; arr[j-1]=current; } } return arr; } }
//希尔排序 public class ShellSort { public static void main(String[] args) { int[] arr=new int[]{1,2,3,4,5,6,7,9,8}; arr=shellSort(arr,arr.length); for(int i=0;i<arr.length;i++) { System.out.print(arr[i]); } } public static int[] shellSort(int[] arr,int n) { int si=0; int d=0; //采用Sedgewick增量序列 int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0}; //找出补超过数组长度的增量序列最大值 for(si=0;Sedgewick[si]>n;si++) {} //增量序列由不超过数组长度的最大值减小到1 for(d=Sedgewick[si];d>0;d=Sedgewick[++si]) { for(int i=d;i<n;i=i+d) { int current=arr[i]; for(int j=i;j>0&¤t<arr[j-d];j=j-d) { arr[j]=arr[j-d]; arr[j-d]=current; } } } return arr; } }
//归并排序 public class MergeSort { public static void main(String[] args) { int[] arr=new int[] {9,8,7,6,5,4,3,2,1}; int n=arr.length; arr=mergeSort(arr,n); for(int i=0;i<arr.length;i++) System.out.print(arr[i]+" "); } //将两个有序数组合并函数 public static void merge(int[] arr,int l,int r,int rightEnd) { int numElements=rightEnd-l+1; int[] temp=new int[arr.length]; int leftEnd=r-1; int i=l; while(l<=leftEnd&&r<=rightEnd) { if(arr[l]<=arr[r]) temp[i++]=arr[l++]; else temp[i++]=arr[r++]; } while(l<=leftEnd) temp[i++]=arr[l++]; while(r<=rightEnd) temp[i++]=arr[r++]; for (int j=0;j<numElements;j++,rightEnd--) arr[rightEnd]=temp[rightEnd]; } //用递归的归并排序 public static void merge_Sort(int[] arr,int l,int rightEnd) { int center=(l+rightEnd)/2; if(l<rightEnd) { merge_Sort(arr,l,center); merge_Sort(arr,center+1,rightEnd); merge(arr,l,center+1,rightEnd); } } //用和其他排序方法统一的接口形式 public static int[] mergeSort(int[] arr,int n) { merge_Sort(arr,0,n-1); return arr; } }
======================================================================================================================================================
快速排序：
快速排序是选定一个基准数（怎么选自己决定，可以选数组第一个元素，数组最后一个元素，或者数组第一个和最后一个及中间数三者的中位数），经过左右两边与基准数比较，最后基准数左边都是小于等于它的，右边都是大于或等于它的。也就是说，基准数找到位置后就不会改变它在数组中的位置。不像快速排序，如果新加入的数比已经排好的数小，贼原先排好的数都要往后挪一位，这是很费时间的。
快速排序的平均时间复杂度为O(nlogn)，最坏情况下时间复杂度为O(n^2)
public class test1 { public static void main(String[] args) { QuickSort qs=new QuickSort(); int[] arr=new int[] {9,8,7,6,5,4,9,3,2,1}; arr=qs.quick_Sort(arr,arr.length-1); for(int i=0;i<arr.length;i++) System.out.print(arr[i]+" "); } } class QuickSort { public void quickSort(int[] arr,int left,int right){ //如果低位数等于或大于高位数，不作处理 if(left>=right) return; int pivot=media3(arr,left,right); int low=left; int high=right; //当低位数比高位数小时跳出循环 while(low<high) { while(pivot<=arr[high]&&low<high) high--; while(pivot>=arr[low]&&low<high) low++; if(low<high) { int temp=arr[low]; arr[low]=arr[high]; arr[high]=temp; } } //将基准数放到正确的位置上 arr[left]=arr[low]; arr[low]=pivot; //递归调用快速排序 quickSort(arr,left,low-1); quickSort(arr,low+1,right); } //找出数组中左，中，右三个数的中位数，并把它放在数组左位上 public int media3(int[] arr,int left,int right) { int center=(left+right)/2; if(arr[left]>arr[center]) swap(arr,left,center); if(arr[left]>arr[right]) swap(arr,left,right); if(arr[center]>arr[right]) swap(arr,center,right); swap(arr,left,center); return arr[left]; } //交换数组中两个数的位置 public void swap(int[] arr,int a,int b) { int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; } public int[] quick_Sort(int arr[],int n) { quickSort(arr,0,arr.length-1); return arr; } }
