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(
c7e5
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);