Java数组及数组排序、查找

角标找对应元素

举例：

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

代码：

//  封装函数
public static char findArray(int index) {
    //  声明一个char数组
    char[] array = new char[] {'一', '二', '三', '四', '五'};
    //  按角标 返回对应的字符
    return array[index - 1];
}

    //  main函数中调用封装函数指令
    char c = findArray(3);
    System.out.println(c);

元素找对应角标

举例：

需求: 定义一个数组 数组值分别 为：3,6,11,22 输入11查找对应的位置；

代码：

//  封装函数
public static int findIndex(int i, int[] array) {
    //  遍历数组 元素对应的角标
    for (int j = 0; j < array.length; j++) {
    //  有可能 你传入的值 不在数组中 可能没有返回值
    if(array[j] == i) {
        //  如果找到对应位置 就保存一下
            return j;
        }
    }
    //  如果函数执行到这步 就说明 上面没有找到对应角标 直接返回-1；
    return -1 ;
}

// 在main函数的测试方法
int[] array = new int[]{3, 6, 11, 22};
    int index = findIndex(12, array);
    if(index == -1) {                
        System.out.println("数组中无这个值，无法找到对应位置");
    }

数组反转

举例：

需求：操作原数组 使原数组反转

分析：

1.反转次数：length/2 （整数）次
2.交换规律：第一个和最后一个数交换 依次换......
  array[0] 和 array[length - 1 - 0]
  array[1] 和 array[length - 1 - 1]
  array[2] 和 array[length - 1 - 2]
  总结：
  array[i] 和 array[length - 1 - i] 相互交换
 3.实现交换：利用中间值来交换

代码：

//  构造函数
public static void reverse(int[] array) {       
    for (int i = 0; i < array.length/2; i++) {
        int temp = array[i];
        array[i] = array[array.length - 1 - i];
        array[array.length - 1 - i] = temp;
        }
        //  遍历数组的方法
        System.out.println(Arrays.toString(array));
    }
}

    //  测试
    int[] array = new int[]{1, 2, 3 ,4};
    //  这里做的是一个 地址的传递
    reverse(array);

举例：

需求：封装一个函数 交换数组 x 和 y 角标的值

代码：

//  构造函数
public static void changeArray(int x, int y, int[] array) {
    int temp = array[x];
    array[x] = array[y];
    array[y] = temp;
}

    //  测试函数
    int[] array = new int[]{1, 2, 3, 4};
    changeArray(3, 2, array);
    System.out.println(Arrays.toString(array));

冒泡排序

核心：相邻两个数进行比较 交换位置

举例：

需求：对含有以下元素：3, 2, 5, 1的数组 进行冒泡排序

代码：

int[] array = new int[]{3, 2, 5, 1};
//  1.把双层循环结构搭建出来
/*
 *  注意:
 *  内循环 -1 防止数组越界
 *  外循环 -1 代表 5个数 比价4趟 比较数组长度-1趟
 *  内循环 -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]) {
            //  交换
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
}
//  打印数组
System.out.println(Arrays.toString(array));

选择排序

核心：选择一个数依次和后面的数比较 换位

举例：

需求：对含有以下元素：3, 2, 5, 1的数组 进行选择排序

代码：

int[] array = new int[]{3, 2, 5, 1};
//  1.写循环构架
for (int i = 0; i < array.length - 1; i++) {            
    for (int j = 1 + i; j < array.length; j++) {
        /*  外循环 -1 5个数比4趟 比较长度-1趟
         *  内循环 1 + i 把不需要比较去除 array[0] 和array[0]
         *               每一次确定一个数
         */
        //  2.比较 交换
        if (array[i] > array[j]) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }               
    }
}
System.out.println(Arrays.toString(array));

举例：

需求:
    1.随机数[1,100]的数
    2.让用户输入一个数
    3.输入的这个数 和 随机出来这个数 比较
    4.告诉用户 猜的 是大 还是小了
    5.循环猜 一直到 猜中为止

代码：

//  随机数
int num =(int)(Math.random() * 100 + 1);
//  提示用户输入
System.out.println("我随机了一个数 看你能不能猜到 请输入：");
Scanner scanner = new Scanner(System.in);
//  循环猜
while (true) {
    //  循环接收输入的数
    String string = scanner.nextLine();
    //  字符串转数字
    int newNum = Integer.parseInt(string);
    if(newNum > num) {
        System.out.println("你猜的数 有点大");
    }else if (newNum < num) {
        System.out.println("你猜的数 有点小");
    }else {
        System.out.println("哈哈 恭喜你猜中了");
        //  结束当前的循环
        break;
    }
}
System.out.println("电脑随机数的是：" + num);

折半查找

优点：提高查找效率
注意：在有序的数组中 查找

举例：

需求：在含有以下元素：3, 5, 6, 9, 12, 18, 22, 33的数组中 查找 22 对应的角标

分析：

1.明确所要用到的所有变量
2.确定执行循环的条件： array[mid] != key;

代码：

int[] array = new int[]{3, 5, 6, 9, 12, 18, 22, 33};
int min = 0;
int max = array.length - 1;
int mid = (max + min) / 2;
//  要查找的值
int key = 12;
/*
 * 循环查找
 * array[mid] != key;
 */
while (array[mid] != key) {
    //  比较 如果比较中间角标大 挪动小角标
    //  如果比中间角标小 挪动大角标
    if (key > array[mid]) {
        min = mid + 1;
    } else if (key < array[mid]) {
        max = mid - 1;
    }
    //  挪动完角标后 还要进行折半操作
    mid = (max + min) / 2;
    //  当最大角标 小于 最小角标的时候 说明数组没有这个数
    if (max < min) {
        //  进到这里 说明 没这个数 停止循环
        mid = -1;
        break;
    }
}
System.out.println("这个数的角标是：" + mid);