冒泡排序、选择和插入排序、二分法查找
冒泡排序
最近了解到了新的排序方式，之前也就会冒泡排序并且在学C的时候已经很熟悉了，我们还是来看下吧!
/* 这里有两个参数，一个int类型数组，显然是用于接收要进行排序的数组
还有一个boolean类型的flag 用于判断是进行升序排序还是降序*/
public static void bubbleSort(int [] arr, boolean flag){
int length = arr.length;
for(int i=0; i1; i++){
for(int j=0; j1 - i; j++){
// 内层执行一次就少一次循环，因为循环一次就确定了一个值得位置
if(flag){ // 进行升序排序
if(arr[j] > arr[j + 1]){
swap(arr,j,j+1);// 这里是换位置
}
}else{ // 进行降序排序
if(arr[j] < arr[j + 1]){
swap(arr,j,j+1);// 这里是换位置
}}}
printArray(arr); //每轮打印
}
}
public static void printArray(int [] arr){
int length = arr.length;
System.out.println();
for(int i=0; iout.print(arr[i] + " ");
}
System.out.println();
} 在main方法里执行时
int ff []={2,5,2,4,7,3,1};
bubbleSort(ff,true);执行排序情况为：
//这是升序排序 -------如果为降序排序则找依次找最小值
2,5,2,4,7,3,1 //原始数据
2 2 4 5 3 1 7 // 第一轮找到最大值 7
2 2 4 3 1 5 7 // 第二轮找到除7外最大值 5
2 2 3 1 4 5 7 // 第一轮找到除7和5外最大值 4
2 2 1 3 4 5 7 // 依次进行
2 1 2 3 4 5 7 // .
1 2 2 3 4 5 7 // .所以可以看出冒泡排序的执行原理和具体的排序过程。依次找最大值（最小值）升序（降序）。
选择排序
这是最近看到的一种排序方法，我觉得有必要了解下原理。
public static void selectSort(int [] arr){
int length = arr.length;
for(int i=0;i<length - 1; i++){
int min = i;
for(int j=i+1; j<length; j++){
if(arr[min] > arr[j]){
// 当前最小的数a[min]如果大于arr[j],就换位置并且将最小数变为arr[j]
min = j;
}
}
printArray(arr);
if(min != i){
swap(arr,i,min);// 换位置
}
}
}还是在main方法里面执行
int ff []={2,5,2,4,7,3,1};
selectSort(ff);执行过程：
// 这是升序排序
// 2,5,2,4,7,3,1 原始数据
// 第一次循环 最小值为原始数据第一位数2，从第一位开始比较
//2>1（第一位后最小值） 所以就第一个2与最后的1换位置，最小值变为1，其他不变
1 5 2 4 7 3 2
// 第二次循环 最小值为上排序第一位数1，从第二位开始比较
//5>2 所以5与2换位置，最小值变为2，其他不变
1 2 5 4 7 3 2
// 第三次循环 最小值为上排序第二位数2，从第三位开始比较
//5>2 所以5与2换位置，最小值变为2，其他不变
1 2 2 4 7 3 5
// 第四次循环 最小值为上排序第三位数2，从第四位开始比较
//4>3 所以4与3换位置，最小值变为3，其他不变
1 2 2 3 7 4 5
// 依次。。
1 2 2 3 4 7 5
1 2 2 3 4 5 7 选择排序的过程就是上面情况，看出原理了么！
插入排序
再来看下 插入排序又是怎样的。
public static void insertSort(int[] arr){
int i,j;
int insert;
for(i=1; i1;
while(j >= 0 && insert < arr[j]){
arr[j+1] = arr[j];
j --;
}
arr[j+1] = insert;
printArray(arr);
}
} 同样在main方法里执行
int ff []={2,5,2,4,7,3,1};
insertSort(ff);结果为：
2 5 2 4 7 3 1 // 第一次打印，也是原始数据 ,
2<5 true换位置 --从第二位5开始判断
2 2 5 4 7 3 1 // 第二次打印，调整，并且 2<2<5
4<5 true换位置 --从第三位5开始判断
2 2 4 5 7 3 1 // 第三次打印，调整，并且 2<2<4<5
7<5 false不变 --从第四位5开始判断
2 2 4 5 7 3 1 // 第四次打印，调整，并且 2<2<4<5<7
3<7 true 换位置 --从第四位5开始判断
3<5 true 换位置
3<4 true 换位置
2<3 false 停止判断
2 2 3 4 5 7 1 // 第五次打印，调整，并且 2<2<3<4<5<7
//依次。。
1 2 2 3 4 5 7同样是对数组int ff []={2,5,2,4,7,3,1};进行排序
我们来看看三种方式排序的各自的原理：
插入排序 —————– 选择排序———————-冒泡排序
2 5 2 4 7 3 1 --1 5 2 4 7 3 2 --2 2 4 5 3 1 7
2 2 5 4 7 3 1 --1 2 5 4 7 3 2 --2 2 4 3 1 5 7
2 2 4 5 7 3 1 --1 2 2 4 7 3 5 --2 2 3 1 4 5 7
2 2 4 5 7 3 1 --1 2 2 3 7 4 5 --2 2 1 3 4 5 7
2 2 3 4 5 7 1 --1 2 2 3 4 7 5 --2 1 2 3 4 5 7
1 2 2 3 4 5 7 --1 2 2 3 4 5 7 --1 2 2 3 4 5 7最近也认识了一种新的查找方法
二分法查找
比如
int arr[]={1,4,3,6,9,8,7,0,2,5};要在这样的数里查找数字为 2 的下标位置，安我们方法就是
for(int i=0;i<arr.length;i++){
if(arr[i]==2){
return i;
}else{
return -1;
}
}如果数据足够大，上万的数据查询量。这样办法当然也可以，但是不够高效，这样一种高效的数据查询的办法
// 这里的 int x 参数是所查询的数
public static int erFen( int arr[],int x){
int min = 0;
int max = arr.length - 1;
while (min <= max) {
int middle = (min + max) / 2;
if (x < arr[middle]) {
max = middle - 1;
} else if (x > arr[middle]) {
min = middle + 1;
} else {
return middle;
}
}
return -1;
}因为使用二分法查询的前提是数组有有序的，也就是说先要将数组进行排序，才能使用二分法查询
所以
selectSort(arr); // 使用插入排序方法 进行排序
// 排序结果为： 0 1 2 3 4 5 6 7 8 9
// 查询数字为 2
System.out.println(erFen(arr,2));
// 结果为： 2 所在位置为数组arr排序后下标为2 即arr[2]
应注意的是当数组中出现多个查询的数字时不能全部查询到，只能查询到其中一个的位置。