Java数组中数组的运用与数组排序、折半查找

    注: array.length 代表数组长度 length代表的就是长度

数组的运用

 1.通过角标 查找对应的元素

 例如:封装一个函数 传入数字1 返回 一 数字2 返回二...

    public static void main(String[] args) {
        System.out.println(fun(3));
    }
    public static char fun(int index) {//定义一个函数(方法)
        char[] array = new char[] {'一', '二', '三', '四', '五'};//定义一个数组 
        // 按角标返回对应的字符
        return array[index - 1];
        //由于 数组的角标是从0开始的 
        如果不减1 那么传入一个1 返回的可能就是二 了
    }

    2.通过元素 查找该元素在数组中的位置(角标)

    例如:
    封装一个函数 定义一个数组 数组值 
    分别为 3,6,11,22 
    传入11 
    查找对应的位置

    public static void main(String[] args) {

    int[] array = new int[] {3, 6, 11, 22};//定义一个数组
    int index = fun(22, array);//定义一个变量 接收这个方法
    System.out.println(index);//输出角标为多少
    }

    //为了让方法的使用性更强,可以把数组也当参数传进来
    public static int fun(int index, int[] array) {//定义一个有参数 有返回值的函数
        //定义变量 保存角标
        int a = -1;
        for (int i = 0; i < array.length; i++) { //遍历查找 元素对应角标
            //有可能你传入的值 不在数组中 可能会没有返回值
            if (array[i] == index) {
                //如果找到对应的值 就保存一下
                a = i;
            }
        }
        return a;//返回一个a
    }

数组元素的反转

    数组元素的反转 也就是 将数组中的值 倒过来
    例如:
    1 2 3 4 5 反转成为 5 4 3 2 1

    如果要将数组中的值倒过来 那么就代表
    第一个值和最后一个换
    第二个值和倒数第二个换
    第三个值和倒数第三个换
    ...
    也就是
    array[0] 和 array[length - 1] 换
    array[1] 和 array[length - 1 - 1] 换
    array[2] 和 array[length - -1 - 2] 换
    从这里我们分析出:
    array[i] 和 array[length - 1 - i]换

    那么换几次呢? 
    例如 1 2 3 4 5 
    1 和 5 换 
    2 和 4 换
    例如 1 2 3 4 5 6 7
    1 和 7 换
    2 和 6 换
    3 和 5 换
    从而得出 需要交换 length / 2 整数次

    那么 如何交换

    这时 我们可以利用中间值来交换

    例如:
    //交换两个整数
    int a = 5;
    int b = 10;
    int mid = 0;
    mid = a;
    a = b;
    b = mid

    来达到交换的目的

    例如:
    反转数组 1 2 3 4 5

    public static void main(String[] args) {
    int[] array = new int[] {1, 2, 3, 4, 5};//定义数组
        //这里做的是一个 地址 的传递
        reverse(array);
        //遍历数组的方法
        System.out.println(Arrays.toString(array));//打印数组的方法
    }

    public static void reverse(int[] array1) {
        //交换的次数
        int num = array1.length / 2;
        for (int i = 0; i < num; i++) {//遍历查找
            //数组元素 交换
            int temp = 0;
            temp = array1[i];
            array1[i] = array1[array1.length - 1 - i];
            array1[array1.length - 1 - i] = temp;
        }
    }

    那么 可以用方法反转数组 可不可以用方法反转整数呢?

    例如:

    public static void main(String[] args) {

        int x = 10;
        int y = 5;
        // 这里做的是 一个 值 的传递
        reverseNum(x, y);
        System.out.println("x = " + x);
        System.out.println("y = " + y);
        }
        public static void reverseNum(int a, int b) {
        int temp = a;
        a = b;
        b = temp;

    }

    将这段代码输入并运行时 发现并不能反转 

    因为数组保存的是一个地址  main函数中定义的地址 
    而reverse(array)这一步代表 
    将main函数中数组的地址 转递给 reverse 方法
    所以 main函数 和reverse 可以调用相同地址的数组
    所以可以进行反转
    而reverseNum这个方法中 并没有什么可以和main函数共同使用的
    当 reverseNum 这个方法调用完以后 就出栈了
    然后再继续进行main函数的调用
    所以这两个整数 并不能反转

数组排序之冒泡排序

    冒泡排序其实就是按照什么思想去排序(例如:升序或者降序)

    核心排序思想: 相邻两个数 进行比较 交换位置

    例如:
    一个数组中的元素为: 3 2 5 1 
    将这个数组进行冒泡排序

    因为是相邻两个数 进行比较 交换
    也就是说

    第一次 2 3 5 1 第一个和第二个比较后 交换
    第二次 2 3 5 1 第二个和第三个比较  这时第二个已经被交换 变成 3 而 3 < 5 所以不交换
    第三次 2 3 1 5 第三个和第四个比较 这时已经确定了一个最大值 而且放到了数组的最后

    但是这时数组还没有完成比较 交换 我们称 上面的步骤为 第一趟

    那么 第二趟:
    第一次 2 3 1 5 第一个和第二个比较 2 < 3 所以不交换
    第二次 2 1 3 5 第二个和第三个比较 3 > 1 所以交换
    由于 5 已经确定为最大值 所以 第三个和第四个已经不用比较
    这时也确定了倒数第二大的数放在倒数第二个位置

    第三趟
    第一次 1 2 3 5 第一个和第二个比较 2 > 1 所以交换
    这时也确定了倒数第三大的数放在倒数第三个位置


    例如:
    将数组 3 5 4 7 1 9 2 8 进行冒泡排序
    public static void main(String[] args) {
        int temp = 0;
        int[] array = new int[] {3, 5, 4, 7, 1, 9, 2, 8};
        //  1.把双层循环结构搭出来
        //  注意 内循环 -1 防止数组越界
        //  外循环 - 1 代表比较数组长度 - 1 趟 (5个数 比较4趟)
        //  内循环 - i 相当于 每一趟 都少比一次
        //  外循环 相当于 比较多少趟
        //  内循环 相当于  一趟 比较多少次
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                //  2.相邻 两个数比较 交换
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
//      打印数组的方法
        System.out.println(Arrays.toString(array));
        }

数组排序之选择排序

    选择排序核心思想:
    选择一个数 依次和后面的数 比较 换位(一般选择第一个数)

    例如:
    将数组 3 5 1 4 进行选择排序

    第一趟
    第一次 3 5 1 4 第一个和第二个比
    第二次 1 5 3 4 第一个和第三个比
    第三次 1 5 3 4 第一个和第四个比
    确定了最小值在第一位
    第二趟
    第一次 1 3 5 4 第二个和第三个比
    第二次 1 3 5 4 第二个和第四个比
    确定了第二小在第二位
    第三趟 1 3 4 5 第三个和第四个比
    确定第三小在第三位

    public static void main(String[] args) {
        int[] array = new int[] {3, 5, 1, 4};//定义一个数组
        int temp = 0;//定义一个变量 用于 元素交换
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                //外循环 - 1 相当于 比较 长度 - 1 趟(5个数 就比较 4 趟)
                //内循环 1 + i  相当于 把不需要比较的去除 (array[0] 和 array[0])
                //                   每一次 确定一个数
                if (array[i] > array[j]) {//由于
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

折半查找

    折半查找的前提是 :
    在一个有序的数组中查找 一个数在数组中的角标
    注意: 要在有序的数组中 查找

    例如:
    查找 数组元素为 3 5 6 9 12 18 22 33 55 中22的角标
    public static void main(String[] args) {
        int[] array = new int[] {3 , 5, 6, 9, 12, 18, 22, 33, 55};
        // 把 要用到的变量 全部声明一遍
        // 声明最大 最小 中间角标
        int min = 0;//最小角标
        int max = array.length - 1;//最大角标 由于角标从0开始 所以最大角标是长度 -1
        int mid = (array.length - 1) / 2;
        // 要查找的值
        int key = 22;
        /*
         * 循环查找
         * array[mid] != key
         */
        while (key != array[mid]) {
            //比较 如果比中间角标大 挪动 最小角标
            //    如果比中间角标小 挪动 最大角标
            if (key > array[mid]) {
                min = mid + 1;
            }else if (key < array[mid]) {
                max = mid - 1;
            }
            // 挪动完角标后 还要进行折半操作
            mid = (min + max) / 2;
            //当最大角标 小于 最小角标的时候 说明 数组中 没有这个数
            if (max < min) {
                //进到这里 说明 没这个数 就停止循环
                mid = -1;
                break;
            }
        }
        System.out.println("这个数的角标是: " + mid );
    }

                                                                  Day.3