2.插入排序:稳定,时间复杂度 O(n^2)
3.冒泡排序:稳定,时间复杂度 O(n^2)
4.堆排序:不稳定,时间复杂度 O(nlog n)
5.归并排序:稳定,时间复杂度 O(nlog n)
6.快速排序:不稳定,时间复杂度 最理想 O(nlogn) 最差时间O(n^2)
7.希尔排序:不稳定,时间复杂度 平均时间 O(nlogn) 最差时间O(n^s) 1<s<2
二分法查找:
package test_yhl.thread; public class MinAbsTest{ private static int findLocation(int[] testInt, int value) { int left = 0; int right = testInt.length-1; int LocationValue = 0; while(left<= right) {//= int middle = (right+left)/2;//+,放在while里面 if (value < testInt[middle]) { right = middle-1;//-1 }else if(value > testInt[middle]){ left = middle+1;//+1 } else{ LocationValue= middle; break;//break; } } return LocationValue; } public static void main(String[] args) throws InterruptedException{ int[] testInt = new int[]{3,10,29,43,48,74,86,300};//new int[]{} System.out.println(findLocation(testInt,300)); } }
插入排序:
http://blog.csdn.net/booirror/article/details/45339387
两层循环,第一层顺序循环,第二层在未排序序列从后向前比较置换值,直到未排序序列最后值置替换为此次值。
插入排序原理:它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序核心:假设第一个元素排好,之后的元素对排好的部分从后向前比较并逐一移动。
package test_yhl.thread; import java.util.Arrays; public class MinAbsTest{ public static void main(String[] arg) { int[] testInts = new int[]{6,7,112,7,12,34}; int y = 0;// y在for外 for (int x=0; x<testInts.length; x++) { int tem = testInts[x]; //必须定义临时testInts[x] for (y=x; y>0 && tem < testInts[y-1]; y--) { testInts[y] = testInts[y-1];//[y] [y-1] } testInts[y] = tem;// [y] } System.out.println(Arrays.toString(testInts)); } }
8 2 4 9 3 6 首先我们考虑数字2,假设后面的数字不存在(手中只有一张8,又抓来了2),那么显然2应该放在8的前面。
2 8 4 9 3 6 又抓来了一张4,现在大家都知道应该怎么办了吧?
2 4 8 9 3 6 又来了个9,没错,正好不用换顺序
2 4 8 9 3 6 同样的道理,考虑3该放的位置,显然放在2和4的中间
2 3 4 8 9 6 最后一个也是一样,最后得到从小到大的序列
2 3 4 6 8 9 完成排序
选择排序:
从左到右边一个一个区比较,左边已排序越来越多,右边未排序越来越少
package test_yhl.thread; import java.util.Arrays; public class MinAbsTest{ static int z; public static void main(String[] arg) { int[] a = new int[]{16,7,338,12,34,112}; int n=a.length; int i,j,k; for(i=0; i<n; i++){ k=i; for(j=i+1; j<n;j++){ if(a[k] > a[j]){// [k] [j] k=j; } } if(a[k]!=a[i]) { int tem = a[i]; a[i] = a[k]; a[k] = tem; } } System.out.printf(Arrays.toString(a)); } }
冒泡排序:
原理:比较两个相邻的元素,将值大的元素交换至右端。
package test_yhl.thread; import java.util.Arrays; public class MinAbsTest{ static int z; public static void main(String[] arg) { int[] a = new int[]{-13,-32,-8,5512,6,34,7,338,112}; int i,j; for(i =0;i<a.length-1;i++) { for(j=0; j<a.length-1-i; j++) { // -1-i if(a[j]>a[j+1]) { //如果是绝对值排序 if(Math.abs(a[j])>Math.abs(a[j+1])) { int tem = a[j]; a[j] = a[j+1]; a[j+1] = tem; } } } System.out.println(Arrays.toString(a)); } }
归并排序:
https://www.cnblogs.com/chengxiao/p/6194356.html
package org.xdemo.example.SpringActivemq.service.consumer; import java.util.Arrays; public class ConsumerTest { public static void main(String[] args) throws Exception { int []arr = {9,8,7,6,5,4,3,2,1}; int []temp = new int[arr.length];//在排序前,先建好一个长度等于原数组长度的临时数组,避免递归中频繁开辟空间 sort(arr,0,arr.length-1,temp); System.out.println(Arrays.toString(arr)); } private static void sort(int[] arr,int left,int right,int []temp){ if(left<right){ int mid = (left+right)/2; sort(arr,left,mid,temp);//左边归并排序,使得左子序列有序 sort(arr,mid+1,right,temp);//右边归并排序,使得右子序列有序 merge(arr,left,mid,right,temp);//将两个有序子数组合并操作 } } private static void merge(int[] arr,int left,int mid,int right,int[] temp){ int i = left;//左序列指针 int j = mid+1;//右序列指针 int t = 0;//临时数组指针 while (i<=mid && j<=right){ // <= if(arr[i]<=arr[j]){ temp[t++] = arr[i++]; }else { temp[t++] = arr[j++]; } } while(i<=mid){//将左边剩余元素填充进temp中 <= temp[t++] = arr[i++]; } while(j<=right){//将右序列剩余元素填充进temp中<= temp[t++] = arr[j++]; } t = 0; //将temp中的元素全部拷贝到原数组中 while(left <= right){ //<= arr[left++] = temp[t++]; } } }
堆排序:
https://www.cnblogs.com/jingmoxukong/p/4303826.html
https://www.cnblogs.com/chengxiao/p/6129630.html