冒泡排序
原理：
冒泡排序是遍历数组的每一个元素，将相邻的两个元素进行比较，如果符合排序要求则不动，如果不符合要求用三变量交换法将两个元素值进行交换，经过一次又一次的遍历从而达到排序的效果。
备注：
这里用了获取开始结束时间的方法来计算冒泡排序所用的时间，如果数组小于1000几乎没什么变化显示时间应该为0，建议可以稍微换大一点，用同样的数据去比对4种算法的时间，从而看出效率。
import java.util.Arrays;
import java.util.Random;
public class Demo01 {
public static void main(String[] args) {
Random r=new Random();//用来创建随机数
int[] a =new int[10000];//创建一个数组存储数据
for (int i = 0; i < a.length; i++) {
a[i]=r.nextInt(900)+100;//随机获得100-1000以内的数字
}
long startTime=System.currentTimeMillis();//获得当前开始时间
int tmp;
for (int i = 1; i < a.length; i++) {
boolean isChange = true;//插旗用来判断是否进入内层循环
for (int j = 0; j < a.length - i; j++) {
if (a[j] > a[j + 1]) {
tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
isChange = false;
}
}
if (isChange == true) {
break;
}
}
long endTime=System.currentTimeMillis();//获得结束时间
System.out.println(endTime-startTime);//打印排序所用时间。
System.out.println(Arrays.toString(a));//打印数组
}
}
选择排序
原理：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
备注：
是自定义的数组，长度过于短，可以不执行计算时间的操作。
import java.util.Arrays;
public class Demo02 {
public static void main(String[] args) {
int[] a = {10, 2, 88, 92, 78, 59, 8, 14, 27, 6};
long startTime=System.currentTimeMillis();
for (int i = 0; i < a.length - 1; i++) {
int min = a[i];
int tmp = 0;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < min) {
min = a[j];//找到最小值
tmp = j;
}
}
if (min < a[i]) {
a[tmp] = a[i];
a[i] = min;
}
}
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
System.out.println(Arrays.toString(a));
}
}
插入排序
原理：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
- 外层从第二个值开始从前向后，把当前值当作基准值
- 内层从当前值开始，从后向前，一次比较:
- 比当前大的，向后移,比当前值小的，当前值在后方插入，
- 如果一直没有插入，则在首位插入。
备注：
是自定义的数组，长度过于短，可以不执行计算时间的操作。
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
int[] a = {10, 2, 88, 92, 78, 59, 8, 14, 27, 6};
long startTime=System.currentTimeMillis();
for (int i = 1; i < a.length; i++) {
int tmp = a[i];//把当前值当基准值
boolean isInsert = false;
for (int j = i - 1; j >= 0; j--) {
if (a[j] > tmp) {
a[j + 1] = a[j];
} else {
a[j + 1] = tmp;
isInsert = true;
break;
}
}
if (!isInsert) {
a[0] = tmp;
}
}
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime);
System.out.println(Arrays.toString(a));
int[] b=Arrays.copyOf(a,11);
System.out.println(Arrays.toString(b));
Arrays.binarySearch(a,0);
}
}
快速排序
原理：
从数据中挑选一个基准值，这里直接挑选的a[1]就是基准值，然后从第二个元素开始往后遍历，遇到比基准值小的往数组前面从第一位开始放，遇到比数组大的往后面放，从最后一个开始放。每改变一次，start指针往前移动到交换的位置上后一位，end指针移动到交换位置前一位。直到start和end相等时，安排基准值落坑。然后以基准值为界限将数组划分成两块，用递归调用再进行排序，指导数据符合要求。
package _20200422;
import java.util.Arrays;
import java.util.Random;
public class QuickSort {
public static int[] sort(int[] a,int start,int end){
if(start<end){
int tmp=a[start];//给定基准值。
int i=start;
int j=end;
while(i<j){
while (i<j&&tmp<a[j]){
j--;
}
if(i<j){
a[i]=a[j];
i++;
}
while(i<j&&tmp>a[i]){
i++;
}
if(i<j){
a[j]=a[i];
j--;
}
}
a[i]=tmp;
sort(a,start,i-1);
sort(a,j+1,end);
}
return a;
}
public static void main(String[] args) {
Random r=new Random();
int[] a=new int[100000];
for (int i = 0; i < a.length-1; i++) {
a[i]=r.nextInt(1000);
}
long beginTime = System.currentTimeMillis();
a=sort(a,0,a.length-1);
long endTime = System.currentTimeMillis();
System.out.println(endTime - beginTime);
//System.out.println(Arrays.toString(a));
}
}
二分法查找
前提：
升序排列。
步骤：
1、找到中间值
2、中间值与基准值进行比较
2.1基准值与中间值相等，则找到了，break；
2.2基准值比中间值大，开始下标定位中间值begin=mid；
2.3基准值比中间值小，开始下标定位中间值end=mid；
3、如果重复上面的过程也没有办法符合2.1，则基准值不在数组内。
4、如果最后还剩一个找不到，直接跳出循环。
public class BinarySearch {
public static void main(String[] args) {
int[] a={1,3,5,7,9,11};
int b=9;
int end=a.length-1;//数组的结束位置-1,最重要的目的是用来求中间值
boolean isFind=false;//是否找到
for (int begin = 0; begin < end; ) {//如果begin==end，代表数组中已经没有元素了。
int mid=(begin+end/2);
if(b==a[mid]){//2.1基准值与中间值相等，则找到了，break；
System.out.println("在下标为:"+mid+"的位置找到");
isFind=true;
break;
}else if(b>a[mid]){//2.2基准值比中间值大，开始下标定位中间值begin=mid；
begin=mid;
}else {
end=mid;//2.3基准值比中间值小，开始下标定位中间值end=mid；
}
if(end-begin==1){
if(b==a[begin]){
System.out.println("在下标为:"+begin+"的位置找到");
isFind=true;
}else {
break;//如果最后还剩一个找不到，直接跳出循环。
}
}
}
if(!isFind){
System.out.println("没有找到");
}
}
}