数组的运用
1.通过角标查找对应的元素
需求: 封装一个函数 传入数字1 返回 一 数字2 返回 二....
// 查表法
public static char findArray(int a) {
char[] array = new char[] {'一', '二', '三', '四', '五'};
// 按角标 返回对应字符
return array[a - 1];
}
public static void main(String[] args) {
System.out.println(fun(1));
}
2.通过元素查找该元素在数组中得位置(角标)
需求:封装一个函数 定义一个数组 数组值分别 3,6,11,22,查找22的角标
// 为了让方法的使用性更强,可以把数组也当参数传进来
public static int fun(int a, int[] array) {
int l = -1;
// 遍历查找 元素对应角标
for(int i=0; i < array.length; i++) {
// 有可能你传入的值不在数组中,可能会没有返回值
if(array[i] == a) {
l = i;
}
}
return l;
}
public static void main(String[] args) {
int[] array = new int[] {3, 6, 11, 22};
System.out.println(fun(22,array));
}
数组元素反转
如何交换?
例如: 需求 交换两个整数
int a = 10;
int b = 15;
int temp = 0;
temp = a;
a = b;
b = temp;
数组元素反转(即将数组中的值倒过来)
分析:
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] 相互交换
例: 定义一个长度为5的数组,并将数组元素反转
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));
}
public static void main(String[] args) {
int[] array = new int[] {1, 2, 3, 4, 5};
// 这里做的是一个地址的传递
reverse(array);
}
写一个交换两个整数的方法,无法实现交换,是因为做的只是一个值的快递,并没有给main函数地址,如:
public static void reverseNum(int a, int b) {
int temp = a;
a = b;
b = temp;
}
public static void main(String[] args) {
int a = 10;
int b = 15;
// 这里做的是一个 值的传递
reverseNum(a, b);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
数组排序
冒泡排序
冒泡排序核心思想:相邻两个数进行比较,交换位置
分析:
int[] array = new int[]{3, 2, 5, 1}
3 2 5 1
第一趟 比较完毕,确定一个最大值,放到最后
第一次:2 3 5 1
第二次:2 3 5 1
第三次:2 3 1 5
length - 1 - 0
第二趟
比较完毕,确定一个最大值,放到最后
第一次:2 3 1 5
第二次:2 1 3 5
length - 1 - 1
第三趟
比较完毕,确定一个最大值,放到最后
第一次:1 2 3 5
length - 1 - 2
实例:
int[] array = new int[] {3, 2, 5, 1}
// 外循环相当于比较多少趟,-1代表比较数组长度-1趟
for(int i = 0; i < array.length - 1; i++) {
// 内循环相当于一趟比较多少次,-i相当于每趟都少比一次(注意内循环-1 防止数组越界)
for(int j = 0; j < array.length - 1 - i; j++) {
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));
选择排序
选择排序的核心思想:选择一个数,一次和后面的数比较 换位
分析:
array[0] --- array[1] array[2] array[3]
array[1] --- array[2] array[3]
array[2] --- array[3]
实例:
int[] array = new int[] {3, 2, 1, 5};
// 外循环 -1 相当于 比较长度-1趟
for (int i = 0; i < array.length -1; i++) {
// 内循环 1+i把不需要比较的去除 array[0] 和 array[0]
for (int j = i + 1; j < array.length; j++) {
if(array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
System.out.println(Arrays.toString(array));
折半查找(提高效率的查找)
折半查找前提:在数组中查找,查找这个数在数组中得角标
注意:在有序的数组中查找
例: 查找数组 int[] array = new int[]{3,5,6,9,12,18,22,33} 22的角标
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 = 22;
// 循环结束条件 key == array[mid]
while(key != array[mid]) {
// 比较 如果比中间角标大 挪动小角标
// 比较 如果比中间角标小 挪动大角标
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);