冒泡排序 二分查找 快速排序 线性查找

二分查找法(折半查找) 

二分查找法 前提 , 数组中的数据 必须是有序的 !对于一个没有排序的数组, 应先排序 后进行折半查找需要的参数:     1.  最小下标    2.  最大下标    3.  中间下标(随着每次折半,中间下标重新运算)(最小下标+最大下标)/2import java.util.Scanner;public class Demo4{    public static void main(String[] args){        //有序的数组        int[] arr = {2,3,8,9,15,22,33,36,39,45,55,58,60};        Scanner input = new Scanner(System.in);        //用户输入的 , 要寻找的数字        int number = input.nextInt();        int minIndex = 0;//最小下标        int maxIndex = arr.length-1;//最大下标        int centerIndex = (minIndex+maxIndex)/2;//中间下标        while(true){            //拿用户输入的数字 与中间下标再数组中对应的数字进行大小的比较            if(number<arr[centerIndex]){                //表示要找的数据在左半部分                maxIndex = centerIndex-1;            }else if(number>arr[centerIndex]){                //表示要找的数据再右半部分                minIndex = centerIndex+1;            }else{                //既不大于又不小于 ,表示相等, 也就是找到了这个数据, 它的下标是centerIndex                break;            }            //范围缩小后, 继续运算中间下标的值            centerIndex = (minIndex+maxIndex)/2;            //找不到的情况为: 最大下标小于最小下标            if(maxIndex<minIndex){                centerIndex = -1;                break;            }        }        //找到的数据的下标为centerIndex , 如果找不到centerIndex为-1    }}

冒泡排序 重点中的重点

升序排列的口诀:     N个数字来排队    两两相比小靠前,    外层 循环length-1    内层循环length-i-1降序排序的口诀:    N个数字来排队    两两相比大靠前,    外层 循环length-1    内层循环length-i-1------------标准升序排列模版代码:
案例: public class Demo3{    public static void main(String[] args){        int[] arr = {22,11,14,3,2,6,10,22,81,111,155,66};        int temp;        for(int i=0;i<arr.length-1;i++){            for(int j=0;j<arr.length-i-1;j++){                if(arr[j]>arr[j+1]){//降序排列, 只需要 把大于号更改为小于号即可                    //表示左边的数据较大, 需要移动                    //1.    先将j+1下标 备份到temp变量                    temp = arr[j+1];                    //2.    将j+1下标的数据 更改为j下标的数据                    arr[j+1] = arr[j];                    //3.    将备份的数据 , 放到j的位置                    arr[j] = temp;                }            }        }        //通过之前学习的遍历输出操作 进行排序后的输出        for(int i=0;i<arr.length;i++){            System.out.print(arr[i]+" , ");        }    }}

线性查找

循环遍历 查找 从最小下标 到最大下标 , 依次比较, 发现相同 则表示找到数据,   到最后依然没有找到, 则表示数据不存在 * 在一个数组中查找元素的位置 * @param arr 查找数据的数组对象 * @param data 要查找的数据 * @return  查找到的下标. 如果找不到则返回-1 */public static int find(int[] arr,int data) {    for (int i = 0; i < arr.length; i++) {        if(arr[i]==data) {            return i;        }    }    return -1;}

快速排序算法 冒泡改良版 重点

案例:     /** * 快速排序 * @param arr  要排序的数组 * @param l 最小下 标 * @param h 最大下标 */public static void sort(int[] arr,int l,int h) {    int i=l;    int j=h;    //计算中间的下标    int p=(i+h)/2;    //将中间下标的数据 先临时的存储到基准变量上    int temp = arr[p];    /**     * 循环:  从i-->p  然后 从p-->j       *      直到i不再小于j , 则循环结束     */    while(i<j) {        /**         * 循环从i到p去寻找数据 ,看是否有大于等于基准值的数据 , 如果有 则不再循环 i就是找到的位置         */        while(i<p&&arr[i]<temp) {            i++;        }        /**         * 找到的大于等于基准值的数据 存储到之前p的位置         * 然后把p的位置 改为该元素之前的位置         */        if(i<p) {            arr[p] = arr[i];            p = i;        }        /**         * 循环从p到j去寻找数据 ,看是否有小基准值的数据 , 如果有 则不再循环 j就是找到的位置         */        while(p<j&&arr[j]>=temp) {            j--;        }        /**         * 找到的小于基准值的数据 存储到之前p的位置         * 然后把p的位置 改为该元素之前的位置         */        if(p<j) {            arr[p] = arr[j];            p = j;        }    }    //本次左右分好后, 将基准变量放在  i和j和p重叠的位置    arr[p] = temp;    System.out.println(Arrays.toString(arr));    /**     * 再分别对左右两边的部分, 进行再次分大小 , 使用递归     */    if(p-l>1) {        sort(arr,l,p-1);    }    if(h-p>1) {        sort(arr,p+1,h);    }}public static void main(String[] args) {    int[] arr = {20,30,10,5,18,26,55,66,77,15,16};    sort(arr, 0, arr.length-1);    System.out.println(Arrays.toString(arr));}