数组的操作

##数组逆序
练习题
1、猜数字游戏。存取5个随机的1~20之间的数据
int tmp = arr[k];
arr[k] = arr[k + 1];
arr[k + 1] = tmp;
}
}
}
for(int tmp:arr) System.out.print(tmp+" “);
System.out.println();
int target = 33;
int pos=-1;
int m1 = 0;
int m2 = arr.length - 1;
boolean flag=false;
while (m1 <= m2) {
pos = (m1 + m2) / 2;
if (arr[pos] > target) {
m2 = pos - 1;
} else if (arr[pos] < target) {
m1 = pos + 1;
} else {
flag=true;
break;
}
}
if(flag)
System.out.println(pos+”::“+arr[pos]);
else
System.out.println(“找不到”);
}
}
static void reverse(int[] arr){
int start=0;
int end=arr.length-1;
while(start<end){
int tmp=arr[start];
arr[start]=arr[end];
arr[end]=tmp;
start++;
end–;
}
}
public class Test2 {
public static void main(String[] args) {
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
2、有一个整数数组，其中存放着序列1、3、5、7、11、13、15、17、19，请将该序列倒序存放并输出
int tmp = (int) (Math.random() * 20 + 1);
if(exists(arr, tmp)) {
i–;
}else {
arr[i]=tmp;
}
}
System.out.println(Arrays.toString(arr));
int target = -1;
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println(“请输入所猜想的数值”);
target = sc.nextInt();
boolean bb = exists(arr, target);
if (bb) {
System.out.println(“猜对了!”);
break;
} else {
System.out.println(“请继续努力”);
}
}
sc.close();
}
public static boolean exists(int[] arr, int target) {
if (target < 1 || target > 20)
return false;
boolean res = false;
for (int tmp : arr) {
if (tmp == target) {
res = true;
break;
}
}
return res;
}
}
public class Test3 {
// 有一个整数数组，其中存放着序列1、3、5、7、11、13、15、17、19，请将该序列倒序存放
并输出
public static void main(String[] args) {
int[] arr = new int[] { 1, 3, 5, 7, 11, 13, 15, 17, 19 };
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr) {
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];
}
}
}
3、编写一个程序，提示用户输入学生数量后，再依次输入姓名和成绩，按照成绩的降序来打印学生的姓
名
public class Test4 {
//编写一个程序，提示用户输入学生数量后，再依次输入姓名和成绩，按照成绩的降序来打印学生的姓
名
public static void main(String[] args) {
System.out.println(“输入学生数量”);
Scanner sc = new Scanner(System.in);
int len = sc.nextInt();
String[] names = new String[len];
int[] scores = new int[len];
for (int i = 0; i < names.length; i++) {
names[i]=inputName(sc);
scores[i]=inputScore(sc);
}
sort(names, scores);
for (int i = 0; i < names.length; i++) {
System.out.println(“第” + (i + 1) + “名学生：” + names[i] + “,成绩
为:” + scores[i]);
}
}
public static String inputName(Scanner sc) {
System.out.println(“姓名：”);
String tmp=”";
while (true) {
tmp= sc.next();
if(tmp.length()>20 || tmp.length()<6) {
System.out.println(“输入数据不合法，请重新输入”);
}else
break;
}
return tmp;
}
public static int inputScore(Scanner sc) {
System.out.println(“成绩：”);
int tmp=0;
while(true) {
tmp=sc.nextInt();
if(tmp>100 || tmp<0) {
System.out.println(“输入数据不合法，请重新输入”);
}else
break;
}
return tmp;
}
public static void sort(String[] names, int[] scores) {
for (int i = 1; i < names.length; i++) {
for (int k = 0; k < names.length - i; k++) {
if (scores[k] < scores[k + 1]) {
int tmp = scores[k];
scores[k] = scores[k + 1];
scores[k + 1] = tmp;
String stmp = names[k];
names[k] = names[k + 1];
names[k + 1] = stmp;
4、编写一个程序，能够读入10个整数，并且存储其中互不相同的数，最后将这10个数输出
5、数组{1、3、9、5、6、7、1、5、4、8}使用二分法查找元素8的位置
6、编写一个程序，读入数目确定的考试分数，判断有多少个分数高于等于平均分，输入一个附属标志表
示输入结束，假设最高分为100。可以假设最多100个成绩
7、编写一个程序生成0-9之间的100个随机整数，并且显示每一个数的出现个数
8、编写一个程序求出整数数组{1、2、4、5、10、100、2}中最小元素的下标。如果这样的元素个数大
于1，则返回下标最小的数的下标
9、判断存在连续三个奇数的数组。给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是
奇数的情况：如果存在，请返回 true ；否则，返回 false 。
示例 1：
输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况。
示例 2：
输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
多维数组
二维数组：实质就是存储是一维数组。
数组定义： 数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];
}
}
}
}
}

//编写一个程序，能够读入10个整数，并且存储其中互不相同的数，最后将这10个数输出
public class Test5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i]=sc.nextInt();
}
String ss=“”;
for(int tmp:arr) {
if(ss.indexOf(“”+tmp)<0)
ss+=tmp+“,”;
}
sc.close();
System.out.println(Arrays.toString(arr));
System.out.println(ss);
}
}
##稀疏数组
稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是指无效数据量远大于有效数据量的数
组。
稀疏数组有很多的使用场景，比如五子棋（思路：单数为黑棋，双数为白棋；数字从小到大可记录下棋
顺序），棋盘很大，但是一盘下完后，大部分的位置都是没有棋字的。这是可以使用稀疏数组存储，使
用时也可以还原成初始的二维数组
实现思路
记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序规模
编码实现
创建一个二维数组 11*11 ，值0表示没有棋子，1表示黑棋，2表示白棋
转化为稀疏数组，首先获取有效值的个数，再遍历二维数组，将非0的值存放到稀疏数组
int[][] arr=[
[1,2,3],
[4,5],
[6,7,8,9,10]
];
int[][] a = new int[11][11];
a[1][2] = 1;
a[2][3] = 2;
System.out.println(“原数组为：”);
for (int[] x : a) {
for (int i : x) {
System.out.print(i + “\t”);
}
System.out.println();
}
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (a[i][j] != 0) sum ++;
}
读取稀疏数组还原数组的值
}
//创建稀疏数组
int[][] b = new int[sum+1][3];
b[0][0] = 11;
b[0][1] = 11;
b[0][2] = sum;
int count = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j] != 0){
count++;
b[count][0] = i;
b[count][1] = j;
b[count][2] = a[i][j];
}
}
}
// 稀疏数组为
for (int i = 0; i < b.length; i++)
System.out.println(b[i][0] + “\t” + b[i][1] + “\t” + b[i][2] + “\t”);
int[][] c = new int[b[0][0]][b[0][1]];
for (int i = 1; i <b.length ; i++)
c[b[i][0]][b[i][1]] = b[i][2];
System.out.println(“还原数组为：”);
for (int[] i: c) {
for (int j:i) System.out.print(j + “\t”);
System.out.println();
}