09_数组操作练习题
1. 找出数组中指定元素第一次出现的下标位置
//1.找出数组中指定元素第一次出现的下标位置
public class Test1 {
public static void main(String[] args) {
//目标数组
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//指定元素
int num = 8;
/*
用于存储目标数据在数组中第一次出现的下标位置
初始化为 -1
如果找到目标数据后 下标 index 会被重新赋值
如果找不到目标数据 下标 index = -1 是一个非法下标 可以判断数据不存在
*/
int index = -1;
//循环遍历数组
for (int i = 0; i < arr.length; i++) {
//判断数组的元素是否指定的元素
if (arr[i] == num) {
index = i;
//得到指定元素下标后结束循环
break;
}
}
if (index != -1) {
System.out.println("目标数据下标：" + index);
} else {
System.out.println("没有目标数据");
}
}
}
运行结果如下图
2. 找出数组中指定元素最后一次出现的下标位置
//2. 找出数组中指定元素最后一次出现的下标位置
public class Test2 {
public static void main(String[] args) {
//目标数组
int[] arr = {1, 2, 8, 4, 8, 6, 7, 8, 9, 10};
//指定元素
int num = 8;
//定义一个变量用来存储指定元素最后一次出现的下标位置
int index = -1;
//倒序循环遍历数组
for (int i = arr.length - 1; i >= 0; i--) {
//判断数组的每一个元素是否是用户指定的元素 更新index的值
if (arr[i] == num) {
index = i;
break;
}
}
//如果 index != -1 表明数组中存在指定元素
if (index != -1) {
System.out.println("目标数据下标：" + index);
} else {
System.out.println("没有目标数据");
}
}
}
运行结果如下图
3. 数组元素逆序☆
要求:
原数组:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
逆序之后:
arr ===> {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
分析:
1. 数据需要首尾交换
2. 首尾交换 ==> 递进操作
3. 交换数据的次数 ==> 元素个数 / 2
//3. 数组元素逆序☆
public class Test3 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6,8};
//使用for循环 把数组的首尾元素值进行交换
for (int i = 0; i < arr.length / 2; i++) {
arr[i] = arr[i] + arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = arr[i] - arr[arr.length - 1 - i];
arr[i] = arr[i] - arr[arr.length - 1 - i];
}
//循环遍历数组 输出所有元素
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
运行结果如下图
4. 复制数组数据到新数组☆
//4. 复制数组数据到新数组☆
//使用尾插法
public class Test4 {
public static void main(String[] args) {
//源数据数组
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6,8};
//新数组
int[] newArray = new int[arr.length];
/*
定义一个变量
1、记录每一次存储数据的下标位置
2、统计当前数组中有多少个元素
*/
int count = 0;
//使用for循环 把 arr 中的元素按顺序依次赋值给 newArray
for (int i = 0; i < arr.length; i++) {
newArray[count] = arr[i];
count++;
}
//循环遍历数组 输出所有元素
for (int i = 0; i < newArray.length; i++) {
System.out.println(newArray[i]);
}
}
}
运行结果如下图
5. 找出数组中的最大值下标位置
目标数组:
int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 10};
//5. 找出数组中的最大值下标位置
public class Test5 {
public static void main(String[] args) {
//目标数组
int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8,10};
int index = 0;
//循环遍历数组找到最大值下标位置
for (int i = 1; i < arr.length; i++) {
if (arr[i] > arr[index]) {
index = i;
}
}
//控制台打印最大值下标
System.out.println("最大值下标为：" + index);
}
}
运行结果如下图
6. 找出数组中的最小值下标位置
目标数组:
int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8, 10};
//6. 找出数组中的最小值下标位置
public class Test6 {
public static void main(String[] args) {
int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8,10};
int index = 0;
//循环遍历数组找到最小值下标位置
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr[index]) {
index = i;
}
}
//控制台打印最小值下标
System.out.println(index);
}
}
运行结果如下图
7. 找出数组中指定下标元素☆
目标数组:
int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8, 10};
/*
【重点】执行下标合法性判定！！！
指定下标在合法范围以内，如果超出合法范围，提示用户操作错误！！！
*/
//7. 找出数组中指定下标元素☆
//下标不正确时给出错误反馈
public class Test7 {
public static void main(String[] args) {
int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8,10};
//指定下标
int index = 6;
//用户指定下标合法性判断
if (index < 0 || index > arr.length - 1) {
System.out.println("用户提供的下标不合法");
/*
终止方法运行 因为当前没有返回值
所以 return 之后没有任何东西
*/
return;
}
System.out.println(arr[index]);
}
}
运行结果如下图
8. 在数组中指定下标开始，到指定下标结束，获取数据存储到新数组中
目标数组:
int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8, 10};
指定开始下标 2 指定结束下标 6
最终的新数组数据存储情况
{5, 7, 19, 2};
问题:
1. 新数组的容量如何得到?
结束下标位置 - 开始下标位置
2. 用户指定的下标位置是否存在隐患?
最基本的以下条件【必须学会】
begin 是开始下标 end 是结束下标
1. begin > end 开始下标大于结束下标 【错误】
2. begin > arr.length - 1 开始下标大于最大有效下标 【错误】
3. end > arr.length - 1 结束下标大于最大有效下标 【错误】
4. begin < 0 开始下标小于 0 【错误】
5，end < 0 结束下标小于 0 【错误】
简化版条件牵制的情况
1. begin > end 开始下标大于结束下标 【错误】
2. begin < 0 开始下标小于 0 【错误】
3. end > arr.length - 1 结束下标大于最大有效下标 【错误】
if (begin > end || begin < 0 || end > arr.length - 1) {
}
//获取数组从指定下标开始 到 指定下标的前一位结束 之间的数据存入新数组
//导包
import java.util.Arrays;
public class Test8 {
public static void main(String[] args) {
//源数据数组
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
//指定开始下标
int begin = 2;
//指定结束下标
int end = 6;
//判断下标数据合法性
if (begin > end || begin < 0 || end > arr.length - 1) {
System.out.println("用户提供的下标不合法");
/*
终止方法运行 因为当前没有返回值
所以 return 之后没有任何东西
*/
return;
}
//计算新数组容量
int newCapacity = end - begin;
//新数组用来存储获取到的元素
int[] newArray = new int[newCapacity];
//定义新数组下标变化
int count = 0;
for (int i = begin; i < end; i++) {
newArray[count++] = arr[i];
}
//Arrays.toString()把数组转换成String类型输出
System.out.println(Arrays.toString(newArray));
}
}
运行结果如下图
9. 在数组指定下标位置添加元素☆
目标数组:
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
注意:
1. 0 无效元素，仅占位使用
2. 插入数据下标的位置必须在合法范围以内
例如：
添加指定元素 20 到下标为 5 的位置
{1, 3, 5, 7, 9, 20, 11, 13, 15, 17};
//9. 在数组指定下标位置添加元素☆
import java.util.Arrays;
public class Test9 {
public static void main(String[] args) {
//此处 0 是无效元素 仅做占位使用
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17,0};
//要添加的元素
int num = 20;
//指定下标位置
int index = 5;
//判断指定下标位置合法性
if (index < 0 || index > arr.length - 1) {
System.out.println("提供的下标数据不合法");
//指定下标位置非法 终止程序
return;
}
//循环遍历数组空出指定下标位置
for (int i = arr.length - 1; i > index; i--) {
/*
arr[i] = arr[i] + arr[i - 1];
arr[i - 1] = arr[i] - arr[i - 1];
arr[i] = arr[i] - arr[i - 1];
*/
arr[i] = arr[i - 1];
}
//指定下标位置添加元素
arr[index] = num;
//Arrays.toString()把数组转换成String类型输出
System.out.println(Arrays.toString(arr));
}
}
运行结果如下图
10. 删除数组中指定下标元素内容☆
目标数组:
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
注意:
1. 0 是无效元素，仅占位使用
2. 删除之后，要求数组元素向前移动
3. 删除数据下标的位置必须在合法范围以内
例如:
删除指定下标 5 的元素
{1, 3, 5, 7, 9, 13, 15, 17, 19, 0}
//10. 删除数组中指定下标元素内容☆
import java.util.Arrays;
public class Test10 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17,19};
//指定下标位置
int index = 5;
//判断指定下标位置合法性
if (index < 0 || index > arr.length - 1) {
System.out.println("提供的下标数据不合法");
//指定下标位置非法 终止程序
return;
}
/*
用户通过指定下标删除元素内容，对于删除的元素并不知道数据内容
如果可以获取被删除的数据，在已知下标位置的情况下，后期可以给予用户撤销操作
*/
int temp = arr[index];
//使用 for 循环把数组元素前移
for (int i = index; i < arr.length - 1; i++) {
/*
arr[i] = arr[i] + arr[i + 1];
arr[i + 1] = arr[i] - arr[i + 1];
arr[i] = arr[i] - arr[i + 1];
*/
arr[i] = arr[i + 1];
}
//删除元素后 末尾补 0 为无效元素 做占位使用
arr[arr.length - 1] = 0;
//Arrays.toString()把数组转换成String类型输出
System.out.println(Arrays.toString(arr));
System.out.println("被删除的数据为:" + temp);
}
}
运行结果如下图
11. 找出数组中指定元素的所有下标位置☆
目标数组:
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};
要求:
1. 目标数据下标位置存储到另一个数组中
例如：
目标数据 1
存储下标的数组中内容 {0, 3, 6}
2. 时间和空间效率问题
如果准备的新数组和原数组容量一致，空间效率低，时间效率高
如果根据当前目标数据个数准备数组，空间效率高，时间效率低
3. 完整的思路
创建一个新数组容量与原数组一致。
//11. 找出数组中指定元素的所有下标位置☆
import java.util.Arrays;
public class Test11 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};
//指定元素
int num = 1;
//思路1 空间效率低，时间效率高
int[] indexArray = new int[arr.length];
//定义新数组下标从0开始存储数据
int count = 0;
//循环遍历数组找出指定元素的所有下标位置
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
//尾插法
indexArray[count++] = i;
}
}
//根据 count 情况判断是否有对应数据存在
if (count != 0) {
for (int i = 0; i < count; i++) {
System.out.println(indexArray[i]);
}
} else {
System.out.println("查无数据");
}
/*
//思路2 空间效率高 时间效率低
//利用循环计数统计目标数的个数
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
count++;
}
}
//判断是否需要创建数组
if (0 == count) {// 0 == count 常量在前 错误响应更快 容错率更高
System.out.println("查无数据");
return;
}
//需要创建数组
int[] indexArray = new int[count];
count = 0;
//使用循环存储下标位置
for (int i = 0; i < arr.length; i++) {
if (num == arr[i]) {
indexArray[count++] = i;
}
}
//展示数据
for (int i = 0; i < count; i++) {
System.out.println(indexArray[i]);
}
*/
}
}
运行结果如下图
12. 使用新元素替换指定元素☆
目标数组:
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5}
例如:
使用 10 替换 1 ==> {10, 3, 5, 10, 3, 5, 10, 3, 5};
//12. 使用新元素替换指定元素☆
import java.util.Arrays;
public class Test12 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};
//Arrays.toString() 把数组转换成 String 类型输出
System.out.println(Arrays.toString(arr));
//定义两个变量 一个对应原数据 一个对应新数据
int oldNum = 1;
int newNum = 10;
//循环遍历数组
for (int i = 0; i < arr.length; i++) {
//判断是否是指定元素 找出指定元素下标位置
if (arr[i] == oldNum) {
//新元素替换指定元素
arr[i] = newNum;
}
}
//Arrays.toString() 把数组转换成 String 类型输出
System.out.println(Arrays.toString(arr));
}
}
运行结果如下图
13. 选择排序算法推演☆
目标数组:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
13.1 找出数组中最大值和下标为0的元素交换位置☆
13.2 接上一题:找出数组中剩余最大值和下标为1的元素交换位☆
13.3 接上一题:找出数组中剩余最大值和下标为2的元素交换位☆
1. 找极值
找出最大值所在下标位置
2. 换位置
和指定位置数据交换
//选择排序算法
import java.util.Arrays;
public class Test13 {
public static void main(String[] args) {
//目标数组
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
System.out.println(Arrays.toString(arr));
//外层循环控制下标
for (int i = 0; i < arr.length - 1; i++) {
int index = i;
//内层循环控制比较次数
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] > arr[index]) {
index = j;
}
}
//判断 当最大值下标不等于被交换元素的下标时 交换两个元素
if (i != index) {
arr[i] = arr[i] + arr[index];
arr[index] = arr[i] - arr[index];
arr[i] = arr[i] - arr[index];
}
}
//打印数组
System.out.println(Arrays.toString(arr));
}
}
运行结果如下图
671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
