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

冒泡排序

最近了解到了新的排序方式，之前也就会冒泡排序并且在学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]

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