冒泡，选择，二分

1.冒泡排序：顾名思义，就像气泡一样浮出水面，最上面肯定是大的起泡，放在数组中就是，每次比较出来最大的数字然后进行排序。eg:{3，7，4，2，6，1}
第一次{
第一次比较{3，7，4，2，6，1}
第二次比较{3，4，7，2，6，1}
第三次比较{3，4，2，7，6，1}
第四次比较{3，4，2，6，7，1}
第五次比较{3，4，2，6，1，7}
7是最大的已经浮现，所以不用比较了。
}
第二次{
比较的数字是{3，4，2，6，1}

---

第一次比较{3，4，2，6，1}
第二次比较{3，2，4，6，1}
第三次比较{3，2，4，6，1}
第四次比较{3，2，4，1，6}
6是最大的已经浮现，所以不用比较
}
第三次{
比较的数字是{3，2，4，1}

---

第一次比较{2，3，4，1}
第二次比较{2，3，4，1}
第三次比较{2，3，1，4}
4是最大的已经浮现，所以不用比较
}
第四次{
比较的数字是{2，3，1}

---

第一次比较{2，3，1}
第二次比较{·2，1，3}
3是最大的已经浮现，所以不用比较
}

---

第五次{
比较的数字是{2，1}
第一次比较{1，2}
2浮现，结束比较
}
最终得出来的是（1，2，3，4，6，7）
六个数字比较了外层循环五次，内层从5，4，3，2，1递减。
下面是冒泡排序代码块：

 public static void getMaoPao(int[] array){
        int temp=0;//定义临时变量为了后续交换数组。
        int count=0;//看看比较了多少次
        for (int i = array.length-1; i>0; i--) {//冒泡排序外层循环
            for (int j = 0; j <i ; j++) {//冒泡排序内层循环控制次数
                count++;//只要进入就进行比较了。
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("冒泡排序共比较了"+count);

    }

2.选择排序算法：第一种方式：循环一次找出参与比较的这对数据中最小的，拿着这个最小的值与最前面的数据交换位置。
选择排序比冒泡排序的效率高。高在交换位置的次数上。选择排序的交换是有意义的。
eg{3，1，6，2，5}
第一次循环结果：{1，3，6，2，5}此时找出最小值1
参与下一轮比较的是{3，6，2，5}
第二次循环结果：{2，6，3，5}此时找出最小值2
参与下一轮比较的是{6，3，5}
第三次循环的结果是:{3,6,5}此时找出最小值是3
参与下一轮比较的是{6，5}
第四轮循环的结果是{5，6}此时找出最小值是5；循环结束
得到结果{1，2，3，5，6}
代码如下：

/**
 * @author weijisheng
 * @create 2021-07-17 16:06
 */
public class XuanZhePaiXu {
    public static void main(String[] args) {
        int[] array = {10, 5, 3};
//        getMinNumbere(array);
        getResultByChoice(array);
    }

    public static void getResultByChoice(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            int min=i;
            for (int j = i+1; j <array.length ; j++) {
                if (array[j]<array[min]){
                    min=j;
                }
                if (min!=i){
                    //array[min]最小的数据
                    //array[i]最前面的数据
                    int temp;
                    temp=array[min];
                    array[min]=array[i];
                    array[i]=temp;
                }

            }
        }
        for (int i = 0; i < array.length; i++) {//排序之后输出
            System.out.print(array[i]);
        }
    }

第二种方式：
选中数组的某个元素，与其后面的元素依次进行两两比较，将较大的数据放在后面，依次从前到后选中每个元素，直至所有元素按要求完成排序，
-如果有n个元素，总共要比较n-1轮。
每一轮比较完毕，下一轮的比较就会少一个数据参与。

3.二分法查找：

1. 二分法查找建立在排序的基础之上。
2. 二分法查找效率要高于"一个挨着一个"的这种查找方式。
3. 二分法查找原理？
   2，5，6，9，10，12
   目标找出10的下标
   （0+5）/2------>2 中间元素的下标arr[2]中间元素的下标就是2
   arr[2]=6<10,说明被查找的元素在6的右边。
   此时下标就变成了（3+5）/2----->4，中间元素的下标就是4
   arr[4]=10，找出10的下表是4.
   二分查找代码如下，必须是排好，并且是正序

package 数组各种有意思的排序算法;

/**
 * @author weijisheng
 * @create 2021-07-15 15:58
 */
public class ErFenChaZhao {
    public static void main(String[] args) {
//要求：求出数组的某个值对应的下标
        int[] a={1,2,3,4,5,6,7,8,9};
        System.out.println(getIndexOfErFen(a, 8));
    }
    public static int getIndexOfErFen(int[] array,int desc){
        int begin=0;//开始元素下标
        int end=array.length-1;//结束元素下标
        while(begin<=end){//从下面看，begin一直在变大，end一直在变小
            int middle=(begin+end)/2;
            if(array[middle]==desc){
                return middle;//中间元素等于查询目标的值
            }else if (array[middle]>desc){//中间元素的值大于目标元素，说明目标元素在左边
                //如果目标元素在左边的话，起始下标不用动，只需要改变末尾元素的下标就可以
                end=middle-1;
            }else if (array[middle]<desc){
                begin=middle+1;
            }
        }
        return -1;
    }
}