冒泡排序、选择和插入排序、二分法查找

冒泡排序

最近了解到了新的排序方式，之前也就会冒泡排序并且在学C的时候已经很熟悉了，我们还是来看下吧!

/* 这里有两个参数，一个int类型数组，显然是用于接收要进行排序的数组
还有一个boolean类型的flag 用于判断是进行升序排序还是降序*/

public static void bubbleSort(int [] arr, boolean flag){
int length = arr.length;
for(int i=0; i<length - 1; i++){
for(int j=0; j<length - 1 - 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; i<length; i++){
System.out.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; i<arr.length; i++){
insert = arr[i];
j = i - 1;
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]

应注意的是当数组中出现多个查询的数字时不能全部查询到，只能查询到其中一个的位置。