数组

最新推荐文章于 2021-11-27 07:00:00 发布
最新推荐文章于 2021-11-27 07:00:00 发布
阅读量253 收藏 2
点赞数 1
分类专栏： java 数组 习题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45887924/article/details/104326714
版权
java 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
数组
4 篇文章 0 订阅
订阅专栏
习题
4 篇文章 0 订阅
订阅专栏

数组

数组是一个对象，在计算机中存入堆内存。

数组的定义

数组是在堆内存中开辟的一片空间大小相等且地址连续的存储空间。
在程序中出现大量数据时，我们创建变量，十分麻烦，所以我们使用数组对数据进行存储。
注意：
1、数组中所存储的数据是必须保证类型一致。
2、数组在堆内存中，是对象
3、数组通过下标来访问数组元素，数组下标从0开始
4、数组变量存放的是数组在堆内存中的首地址
5、数组通过下标访问元素地址计算公式为：被访问元素的地址=首地址+下标*数据类型大小
6、数组被定义之后长度就不可改变
7、创建时必须规定元素内容或者数组大小

数组的三种创建方式

1、数据类型[] 数组名=new 数据类型[数组长度]
2、数据类型[] 数组名=new 数据类型[] {1，2，3，4}
3、数据类型[] 数组名={1，2，3，4}
注意： 当有一个[]时表示这是一个一维数组，当有两个[]时，表示这是一个二维数组

数组常见错误

ArrayIndexOutOfBoundsException 数组角标越界
这时候注意如果是循环，那么看自己的循环退出条件，如果使用的是<=那么后面的数组长度就需要-1，如果使用的是<那么数组长度不-1
NullPointerException 空指针异常
表示空指针异常，即数组变量指向了nul

数组的遍历

我们通常使用for循环来遍历数组

class Number{
	public static void main(String[] args){
		int[] a={1,2,3,4,5,6};
		for(int i=0;i<6;i++){
			System.out.println(a[i]);
		}
	}
}

运行结果

1
2
3
4
5
6

数组的赋值

import java.util.Scanner;
class Number{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		int[] a=new int[6];
		for(int i=0;i<6;i++){
			a[i]=scanner.nextInt();
		}
	}
}

数组查找

线性查找

从第一个元素开始到最后一个元素结束，从头到尾依次遍历一遍。

//使用线性查找，找出数组1，2，3，4，5，6中的4，并返回下标
class Number{
	public static void main(String[] args){
		int[] a={1,2,3,4,5,6};
		for(int i=0;i<6;i++){
			if(a[i]==4){
				System.out.println(i);
			}
		}
	}
}

时间复杂度为O(n)

二分查找

利用二分树的原理进行查找
条件： 数组必须是有序的
原理：取数组中间的数和所要查找的数进行比较，如果所要查的数等于数组最中间的数那直接输出，如果所要查的数大于数组中间的数那么数组中间的数的前面的数就不需要考虑了，将后面的数看为一个新数组继续进行这样的操作，反之亦然。
在这里插入图片描述

class Search{
    public static void main(String[] args){
        //二分查找
        binarySearch();
    }
    public static void binarySearch(){
       
        int[]arr={12,17,21,32,38,41,46,49,50,50,51,59,60};
        int key=46;
        int index=-1;
        int min_index=0;
        int max_index=arr.length-1;
        int mid_index=(min_index+max_index)/2;
        while(arr[mid_index]!=key){
            if(key<arr[mid_index]){
                max_index=mid_index-1;
            }
            if(arr[mid_index]<key){
                min_index=mid_index+1;
            }
            if(min_index>max_index){
                index=-1;
                break;
            }
            mid_index=(min_index+max_index)/2;
        }
        System.out.println(mid_index);

    }
}

时间复杂度为:O(log2 n)

二维数组

有两个维度的数组
二维数组的定义：
int[][] arr=new int[i][j]
int[][] arr={{1,2 3},{2,3,4},{6,7,8}}
int[][] arr=new int[][]{{1,2 3},{2,3,4},{6,7,8}}
访问二维数组的元素是根据元素的行角标和列角标来访问的

二维数组的存储

在计算机中只要是数组就是一维存储，对于二维数组而言，二维数组是一个以一维数组为元素的一维数组在这里插入图片描述

二维数组注意

矩阵一定是二维数组，但是二维数组不一定是矩阵
例：
在这里插入图片描述
是二维数组但是不是矩阵
当二维数组的行列相等时称之为方阵

习题

一维数组

1、在这里插入图片描述

/*
数据：用户输入的一组数   这组数中(0,100]的数出现的次数
指令：提示用户输入一组数  将各数字出现的次数存入数组中  输出
步骤；
1、提示用户输入一组数
2、将各数字出现的次数存入数组中
3、输出
*/
import java.util.Scanner;
class ProblemOne{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户输入一组数
        System.out.print("请输入一组数以0结尾： ");
        int []a=new int[100];
        int []b=new int[100];
        //2、将各数字出现的次数存入数组中
        while(true){
            int i=0;
            a[i]=scanner.nextInt();
            if(a[i]==0){
                break;
            }else if(a[i]>=1&&a[i]<=100){
                b[a[i]-1]+=1;
            }
            i+=1;
        }
        //3、输出
        for(int j=0;j<100;j++){
            if(b[j]>0){
                System.out.println((j+1)+" 出现了 "+b[j]+" 次。");
            }
        }
    }
}

运行结果

请输入一组数以0结尾： 3 4 5 6 7 8 0
3 出现了 1 次。
4 出现了 1 次。
5 出现了 1 次。
6 出现了 1 次。
7 出现了 1 次。
8 出现了 1 次。

2、在这里插入图片描述

/*
数据：从控制台读入的10个数  不同数的个数  不同的数是什么
指令：提示用户输入10个数  将未出现存入数组中  输出不同的数及有多少个
步骤：
1、提示用户输入10个数
2、将未出现存入数组中
3、输出不同的数及有多少个
*/
import java.util.Scanner;
class ProblemTwo{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户输入10个数
        System.out.print("请输入十个数：");
        int []a=new int [10]; 
        int count=0;
        //2、将未出现存入数组中
        for(int i=0;i<10;i++){
            a[i]=scanner.nextInt();
            for(int j=0;j<i;j++){
                if(a[j]==a[i]){
                    a[i]=0;
                    break;
                }
            }
        }
        //3、输出不同的数及有多少个
        System.out.print("出现的数分别是：");
        for(int k=0;k<10;k++){
            if(a[k]!=0){
                System.out.print(a[k]+" ");
                count+=1;
            }
        }
        System.out.println();
        System.out.println("出现的数的个数为： "+count);
    }
}

运行结果

请输入十个数：1 2 3 4 5 6 7 8 7 9
出现的数分别是：1 2 3 4 5 6 7 8 9
出现的数的个数为： 9

3、在这里插入图片描述

/*
数据：用户输入的一组数 
指令：提示用户输入一组数  调用函数isSorted()  输出数组是否是升序的
步骤：
1、提示用户输入一组数
2、使用循环将数放入数组中 
3、调用isSorted()函数
4、并输出数组是否是升序的
*/
import java.util.Scanner;
class ProblemThree{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("输入这组数的个数：");
        int number=scanner.nextInt();
        //1、提示用户输入一组数
        System.out.print("Enter list: ");
        int[] list=new int[number];
        for(int i=0;i<number;i++){
            list[i]=scanner.nextInt();
        }
        boolean flag=isSorted(list);
        if(flag){
            System.out.println("The list is already isSorted");
        }else{
            System.out.println("The list is not isSorted");
        }
    }
    public static boolean isSorted(int[] list){
        for(int j=list.length-1;j>=0;j--){
            for(int k=0;k<j;k++){
                if(list[k]>list[j]){
                    return false;
                }
            }
        }
        return true;
    }
}

运行结果

输入这组数的个数：6
Enter list: 1 2 3 5 3 6
The list is not isSorted

输入这组数的个数：6
Enter list: 2 3 5 6 7 9
The list is already isSorted

4、在这里插入图片描述

/*
数据：小球个数number  槽数a    每个槽的小球个数m  每个槽内的小球数
指令：提示用户输入小球个数和槽数   调用函数isWhat()判断小球会落到那个槽和输出路径   统计每个槽的小球个数  输出
步骤：
1、提示用户输入小球个数和槽数
2、调用函数isWhat()判断小球会落到那个槽和输出路径   统计每个槽的小球个数
3、输出小球落到槽内的图
*/
import java.util.Scanner;
class ProblemFour{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户输入小球个数和槽数
        System.out.print("请输入小球个数和槽数： ");
        int number=scanner.nextInt();
        int m=scanner.nextInt();
        int[] a=new int[m];//使用数组存放每个槽内的小球数
        System.out.println();//输出一个回车避免分不清楚
        //2、调用函数isWhat()判断小球会落到那个槽和输出路径   统计每个槽的小球个数
        for(int i=0;i<number;i++){
            a[(int)(isWhat(m))]++;
        }
        System.out.println();//输出一个回车避免分不清楚
        //3、输出
        int b=0;//存放  最多的小球个数   即最终需要打印的小球图案的层数
        for(int j=0;j<m;j++){
            if(b<a[j]){
                b=a[j];
            }
        }
        for(int k=b;k>0;k--){
            for(int l=0;l<m;l++){//有球就是o没有球就是空格
                if(a[l]==k){
                    System.out.print("o");
                    a[l]-=1;
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
    public static double isWhat(int m){//m是槽数
        double seat;//中间槽的位置   即小球初始位置
        if(m%2==0){//偶数个槽
            seat=m/2;
        }else{//奇数个槽
            seat=m/2+1.0/2;
        }
        for(int i=0;i<m-1;i++){//m-1表示m个槽需要选择m-1次就可以使小球落入槽中
            if((int)(Math.random()*2)==0){//随机数为0表示向左，为1表示向右
                System.out.print("L");//向左就输出L
                seat-=1.0/2;
            }else{
                System.out.print("R");//向右就输出R
                seat+=1.0/2;
            }
        }
        System.out.println();
        return seat;
    }
}

运行结果

请输入小球个数和槽数： 5 6
LRRRL
LLLRR
LRLRR
LLRRR
LRRLL

   o
  oo
  oo

请输入小球个数和槽数： 4 9

RRLLRRLR
LLLRLRRR
RRRRLRLL
RRRRLLRR

     o
    ooo

5、在这里插入图片描述

/*
数据：用户输入数组长度   两个数组
指令：提示用户输入数组长度   提示用户输入两个数组  调用函数equals()  输出
步骤：
1、提示用户输入数组长度
2、提示用户输入两个数组
3、调用函数equals()，并输出
*/
import java.util.Scanner;
class ProblemFive{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户输入数组长度
        System.out.print("请输入数组长度：");
        int length=scanner.nextInt();
        //2、提示用户输入两个数组
        System.out.print("第一个数组list1： ");
        int[] list1=new int[length];
        for(int i=0;i<length;i++){
            list1[i]=scanner.nextInt();
        }
        System.out.print("第一个数组list2： ");
        int[] list2=new int[length];
        for(int j=0;j<length;j++){
            list2[j]=scanner.nextInt();
        }
        if(equals(list1,list2)){
            System.out.println("两个数组是完全相同的");
        }else{
            System.out.println("两个数组不是完全相同的");
        }
    }
    public static boolean equals(int[] list1,int[] list2){
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

运行结果

请输入数组长度：8
第一个数组list1： 1 2 3 4 5 6 7 8
第一个数组list2： 1 2 3 4 5 6 7 8
两个数组是完全相同的

请输入数组长度：8 
第一个数组list1： 1 2 3 4 5 6 7 8
第一个数组list2： 1 3 5 7 9 2 4 6
两个数组不是完全相同的

6、在这里插入图片描述

/*
数据：用户输入的列表长度  用户输入的列表
指令：提示用户输入列表长度   提示用户输入列表   调用函数isConsecutiveFour()并输出列表是否有四个连续的数
步骤：
1、提示用户输入一个列表的长度
2、提示用户输入列表
3、调用函数并输出
*/
import java.util.Scanner;
class ProblemSix{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户输入列表长度
        System.out.print("Enter the number of values:");
        int length=scanner.nextInt();
        //2、提示用户输入列表
        System.out.print("Enter the values:");
        int[] values=new int[length];
        for(int i=0;i<length;i++){
            values[i]=scanner.nextInt();
        }
        //3、调用函数isConsecutiveFour()，并输出列表是否有四个连续的数
        if(isConsecutiveFour(values)){
            System.out.println("The list has consecutive four");
        }else{
            System.out.println("The list has no consecutive four");
        }
    }
    public static boolean isConsecutiveFour(int[] values){
        int count=1;
        for(int i=1;i<values.length;i++){
            if(values[i]==values[i-1]){
                count+=1;
            }else{
                count=1;
            }
            if(count==4){
                return true;
            }
        }
        return false;
    }
}

运行结果

Enter the number of values:8
Enter the values:1 2 3 3 3 3 4 5
The list has consecutive four

Enter the number of values:8
Enter the values:1 2 3 4 5 6 7 8
The list has no consecutive four

7、在这里插入图片描述

/*
数据：用户输入的两个列表的长度和内容 
指令：提示用户输入两个有序列表长度和内容  调用函数merge()  输出合并之后的列表
步骤：
1、提示用户输入两个列表长度和内容
2、调用函数merge()得到合并后的列表
3、输出合并之后的列表
*/
import java.util.*;
class ProblemSeven{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、提示用户数如两个有序列表
        System.out.print("Enter list1(第一个代表列表长度): ");
        int length1=scanner.nextInt();
        int[] list1=new int[length1];
        for(int i=0;i<length1;i++){
            list1[i]=scanner.nextInt();
        }
        System.out.print("Enter list2: ");
        int length2=scanner.nextInt();
        int[] list2=new int[length2];
        for(int j=0;j<length2;j++){
            list2[j]=scanner.nextInt();
        }
        //2、调用函数merge
        //3、输出合并后的数组
        System.out.print("The merged list is "+Arrays.toString(merge(list1,list2)));
    }
    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        int[] list3=new int[list1.length+list2.length];
        int maxlength;
        int i=0;
        int j=0;
        int k=0;
        while(true){
            if(list1[i]<=list2[j]){
                list3[k]=list1[i];
                i++;
            }else{
                list3[k]=list2[j];
                j++;
            }
            k++;
            if(i==list1.length||j==list2.length){
                break;
            }
        }
        if(list1.length==i&&list2.length==j){
            return list3;
        }else if(list1.length==i){
            for(j=j;j<list2.length;j++){
                list3[k]=list2[j];
                k++;
            }
        }else{
            for(i=i;i<list1.length;i++){
                list3[k]=list1[i];
                k++;
            }
        }
        return list3;
    }
}

运行结果

Enter list1(第一个代表列表长度): 5 1 2 3 4 5
Enter list2: 7 1 3 4 6 8 9 11
The merged list is [1, 1, 2, 3, 3, 4, 4, 5, 6, 8, 9, 11]

8、在这里插入图片描述

import java.util.*;
class ProblemEight{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、创建一个字符串数组，存5个单词
        String[] word={"program","airplane","apple","monkey","person"};
        //2、随机产生一个数，表示第几个单词
        int number=(int)(Math.random()*word.length);
        //3、调用函数猜第一次词
        guess(word[number]);
        //4、通过循环确定是否继续猜词
        while(true){
            System.out.print("Do you want to guess other words? Enter y or n: ");
            String choice=scanner.nextLine();
            if(choice.charAt(0)=='y'){
                guess(word[(int)(Math.random()*word.length)]);
            }else{
                break;
            }
        }
    }
    public static void guess(String word){
        Scanner scanner=new Scanner(System.in);
        char[] cipher=new char[word.length()];
        int miss=0;
        for(int i=0;i<word.length();i++){//初始化数组为*
            cipher[i]='*';
        }
        while(true){
            int number=word.length();
            System.out.print("(Guess) Enter a letter in word: ");
            show(cipher);
            System.out.print(" > ");
            char letter=scanner.nextLine().charAt(0);
            for(int j=0;j<word.length();j++){//遍历单词看是单词中否有用户输入的字母
                if(letter==word.charAt(j)&&letter!=cipher[j]){
                    cipher[j]=letter;
                }else if(letter==word.charAt(j)&&letter==cipher[j]){
                    break;
                }else{
                    number--; 
                }
                if(number==0){
                    System.out.println(letter+" is not in word ");
                    miss++;
                    break;
                }
            }
            int k;
            for(k=0;k<word.length();k++){
                if(cipher[k]!=word.charAt(k)){
                    break;
                }
            }
            if(k==word.length()){
                System.out.println("The word is "+word+" .You x=missed it "+miss+" time");
                return;
            }
        }
    }
    public static void show(char[] cipher){//展示数组
        for(int i=0;i<cipher.length;i++){
            System.out.print(cipher[i]);
        }
    }
}

运行结果

(Guess) Enter a letter in word: ****** > q
q is not in word 
(Guess) Enter a letter in word: ****** > p
p is not in word 
(Guess) Enter a letter in word: ****** > a
a is not in word 
(Guess) Enter a letter in word: ****** > m
(Guess) Enter a letter in word: m***** > o
(Guess) Enter a letter in word: mo**** > o
o is already in the word
(Guess) Enter a letter in word: mo**** > l
l is not in word
(Guess) Enter a letter in word: mo**** > k
(Guess) Enter a letter in word: mo*k** > e
(Guess) Enter a letter in word: mo*ke* > y
(Guess) Enter a letter in word: mo*key > n
The word is monkey .You x=missed it 4 time
Do you want to guess other words? Enter y or n: n

(Guess) Enter a letter in word: ****** > m
(Guess) Enter a letter in word: m***** > o
(Guess) Enter a letter in word: mo**** > n
(Guess) Enter a letter in word: mon*** > k
(Guess) Enter a letter in word: monk** > r
r is not in word 
(Guess) Enter a letter in word: monk** > e
(Guess) Enter a letter in word: monke* > y
The word is monkey .You x=missed it 1 time
Do you want to guess other words? Enter y or n: y
(Guess) Enter a letter in word: ***** > h
h is not in word 
(Guess) Enter a letter in word: ***** > d
d is not in word 
(Guess) Enter a letter in word: ***** > f
f is not in word
(Guess) Enter a letter in word: ***** > a
(Guess) Enter a letter in word: a**** > p
(Guess) Enter a letter in word: app** > r
r is not in word
(Guess) Enter a letter in word: app** > l
(Guess) Enter a letter in word: appl* > e
The word is apple .You x=missed it 4 time
Do you want to guess other words? Enter y or n: n

二维数组

1、在这里插入图片描述

import java.util.*;
class ProblemNine{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //1、定义一个矩阵，二维数组
        double[][] column=new double[3][4];
        //提示用户输入有一个数组
        System.out.println("Enter a 3-by-4 matrix row by row:  ");
        for(int i=0;i<3;i++){
            for(int j=0;j<4;j++){
                column[i][j]=scanner.nextDouble();
            }
        }
        //调用函数返回每列的和，并输出
        for(int k=0;k<4;k++){
            System.out.println("Sum of elements at column "+k+" is "+sumColumn(column,k));
        }
    }
    public static double sumColumn(double[][] column,int columnIndex){
        double sum=0;
        for(int i=0;i<column.length;i++){
            sum+=column[i][columnIndex];
        }
        return sum;
    }
}

运行结果

Enter a 3-by-4 matrix row by row:
1 2 3 4
2 3 4 5
3 4 5 6
Sum of elements at column 0 is 6.0
Sum of elements at column 1 is 9.0
Sum of elements at column 2 is 12.0
Sum of elements at column 3 is 15.0

2、在这里插入图片描述

import java.util.Scanner;
class ProblemTen{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter a 4-by-4 matrix row by row:");
        double[][] matrix=new double[4][4];
        //初始化矩阵
        for(int row=0;row<matrix.length;row++){
            for(int col=0;col<matrix[row].length;col++){
                matrix[row][col]=scanner.nextDouble();
            }
        }
        double sum=0;
        for(int j=0;j<matrix.length;j++){
            sum+=matrix[j][j];
        }
        System.out.println("Sum of the elements in the major diagonal is "+sum);
    }
}

运行结果

Enter a 4-by-4 matrix row by row:
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
Sum of the elements in the major diagonal is 10.0

3、在这里插入图片描述

/*
数据：用户输入进来的两个矩阵matrix1和matrix2  矩阵相乘之后的得到的新矩阵newMatrix
指令：提示用户输入两个矩阵 调用multiplyMatrix()方法；
步骤：
1、先提示用户输入两个矩阵matrix1和matrix2
2、调用multiplyMatrix()
*/
import java.util.Scanner;
class ProblemEleven{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter matrix1:");
        double[][] matrix1=new double[3][3];
        double[][] matrix2=new double[3][3];
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                matrix1[i][j]=scanner.nextDouble();
            }
        }
        System.out.print("Enter matrix2:");
        for(int k=0;k<3;k++){
            for(int l=0;l<3;l++){
                matrix2[k][l]=scanner.nextDouble();
            }
        }
        multiplyMatrix(matrix1,matrix2);
    }
    public static void multiplyMatrix(double[][] matrix1,double[][] matrix2){
        double[][] newMatrix=new double[matrix1.length][matrix2[0].length];
        for(int i=0;i<newMatrix.length;i++){
            for(int j=0;j<newMatrix[i].length;j++){
                double sum=0;
                for(int k=0;k<matrix2.length;k++){
                    sum+=matrix1[i][k]*matrix2[k][j];
                }
                newMatrix[i][j]=sum;
                System.out.printf("%4.2f ",newMatrix[i][j]);
            }
        System.out.println();
        }
    }
}

运行结果

Enter matrix1:1 2 3 4 5 6 7 8 9
Enter matrix2:0 2 3 5 6 7 8 4 2
34.00 26.00 23.00 
73.00 62.00 59.00 
112.00 98.00 95.00

4、在这里插入图片描述

/*

数据：用户输入的方阵长度 随机产生的方阵
指令：提示用户输入方阵大小

*/
import java.util.*;
class ProblemTwelve{
    public static void main(String[] args){
        //1.输入方针的尺寸 创建方阵
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter size:");
        int size=scanner.nextInt();
        int[][] m=new int[size][size];
        //2.随机的给方阵中填入0或1
        Random random=new Random();
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                m[i][j]=random.nextInt(2);
                System.out.print(m[i][j]+" ");
            }
            System.out.println();
        }
        //3.让行，列，对角线累加 sum==0 sum==size 表示全相等
        checkRow(m);
        checkCol(m);
        checkDiagonal(m);
        checkSubDiagonal(m);
    }
    public static void checkSubDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][m.length-1-i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkRow(int[][] m){
        for(int i=0;i<m.length;i++){
            int sum=0;
            for(int j=0;j<m[i].length;j++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
            }
        }
    }
    public static void checkCol(int[][] m){
        for(int j=0;j<m.length;j++){
            int sum=0;
            for(int i=0;i<m.length;i++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d列全相等且是%d\n",j+1,sum==0?0:1);
            }
        }
    }
}

运行结果

Enter size:6
0 1 0 0 1 1
0 0 1 0 0 0
0 0 0 0 1 1
1 0 1 1 1 1
1 0 0 1 1 0
0 1 1 0 0 1

0 0 1
1 1 1
0 0 0
第2行全相等且是1
第3行全相等且是0

5、在这里插入图片描述

import java.util.*;
class ProblemThirteen{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter row ,col:");
        int row=scanner.nextInt();
        int col=scanner.nextInt();
        int[][] m=new int[row][col];
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                m[i][j]=scanner.nextInt();
            }
        }
        System.out.println(isConsecutiveFour(m));
    }
    public static boolean isConsecutiveFour(int[][] m){
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                //向右
                if(j<=m[i].length-4){
                    boolean flag=true;
                    for(int c=j+1;c<=j+3;c++){
                        if(m[i][j]!=m[i][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向下
                if(i<=m.length-4){
                    boolean flag=true;
                    for(int r=i+1;r<=i+3;r++){
                        if(m[i][j]!=m[r][j]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右下
                if(i<=m.length-4&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i+1,c=j+1;r<=i+3;r++,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右上
                if(i>=3&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i-1,c=j+1;c<=j+3;r--,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
            }
        }
        return false;//四个方向都没有连续的
    }
}

运行结果

1 2 3 4
2 3 4 5
1 2 4 5
false

Enter row ,col:6 6
1 1 1 1 1 1
2 11 1 1 1 1
1 2 3 4 5 6
1 2 3 4  56  1
1 1 2 3 4 5
1 6 7 3 2 1
true

6、在这里插入图片描述

import java.util.*;
class ProblemFifteen{
    /* 
    五子棋 黑白棋 谁先连成5个子 谁就赢
    棋盘 我们用什么去表示棋盘
    +++++++
    +++++++
    +++++++
    那也就是说我们需要创建一个String的二维数组来表示棋盘
    如何下棋呢？
    目前我们的程序是控制台程序，不能说是用点击的方式进行下棋
    只能是输入棋子的坐标进行下棋
    输入 1,1 指的就是在(0,0)处下一个棋子
    
    初始化棋盘 initBoard()
    打印棋盘   printBoard()
    开始游戏   startGame()
    下棋(黑白) putDownChess()
    判断输赢   isGameOver()
    上述方法都会去调用棋盘board数据 
    如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
    我们可以将board数据定义为全局变量 任何函数都可以访问的变量
    全局变量定义在函数的外面 类的里面 必须public static开头
    */

    //全局变量 棋盘 方便函数直接调用 而不需要依次传参
    public static String[][] board; //定义为是15*15的棋盘
    public static String BLACK_CHESS="O";   //黑棋
    public static String WHITE_CHESS="X";   //白棋
    public static Scanner scanner=new Scanner(System.in);

    public static void main(String[] args){
        //1.初始化棋盘
        initBoard();
        //2.打印棋盘
        printBoard();
        //3.开始游戏
        startGame();
    }
    public static void startGame(){
        /*
        黑方 白方 轮流 下棋 
        */
        int player=0;   //player 偶数 黑 ；奇数 白
        while(true){
            if(player%2==0){    //黑方下棋
                System.out.print(">>>请黑方下棋:");
                if(!putDownChess(BLACK_CHESS)){
                    continue;
                }
            }else{              //白方下棋
                System.out.print(">>>请白方下棋:");
                if(!putDownChess(WHITE_CHESS)){
                    continue;
                }
            }
            if(isGameOver()){
                break;
            }
            player++;
        }
        System.out.println("游戏结束");
    }
    public static boolean isGameOver(){
        int i;
        int j;
        int k;
        //向右判断
        for(i=0;i<15;i++){
            for(j=0;j<11;j++){
                for(k=j;k<j+5;k++){
                    if(board[i][j]!=board[i][k]){
                        break;
                    }
                }if((k-j)==4&&board[i][k].charAt(0)=='X'){
                    System.out.println("白方胜");
                    return true;
                }else if((k-j)==4&&board[i][k].charAt(0)=='O'){
                    System.out.println("黑方胜");
                    return true;
                }else{
                    break;
                }
            }
        }
        //向下判断
        for(i=0;i<15;i++){
            for(j=0;j<11;j++){
                for(k=j;k<j+5;k++){
                    if(board[j][i]!=board[k][i]){
                        break;
                    }
                }if((k-j)==4&&board[j][k].charAt(0)=='X'){
                    System.out.println("白方胜");
                    return true;
                }else if((k-j)==4&&board[j][k].charAt(0)=='O'){
                    System.out.println("黑方胜");
                    return true;
                }else{
                    break;
                }
            }
        }
        //向右下判断
        for(i=0;i<11;i++){
            for(j=0;j<11;j++){
                for(k=0;k<5;k++){
                    if(board[i][j]!=board[i+1][j+1]){
                        break;
                    }
                }
                if(k==4&&board[i][j].charAt(0)=='X'){
                    System.out.println("白方胜");
                    return true;
                }else if(k==4&&board[i][j].charAt(0)=='O'){
                    System.out.println("黑方胜");
                    return true;
                }else{
                    break;
                }
            }
        }
        //向左下判断
        for(i=14;i>4;i--){
            for(j=14;j>4;j--){
                for(k=0;k<5;k++){
                    if(board[i][j]!=board[i-1][j+-1]){
                        break;
                    }
                }
                if(k==4&&board[i][j].charAt(0)=='X'){
                    System.out.println("白方胜");
                    return true;
                }else if(k==4&&board[i][j].charAt(0)=='O'){
                    System.out.println("黑方胜");
                    return true;
                }else{
                    break;
                }
            }
        }
        return false;
    }
    public static boolean putDownChess(String chess){
        //用户输入的 (1,1) -> (0,0)
        //1 B
        int x=scanner.nextInt()-1;
        int y=scanner.next().charAt(0)-'A';
        if(!board[x][y].equals("+")){
            System.out.println(">>>此处已有棋子，请重新下棋");
            //另外一种处理方式 就是讲player定义为全局 此处player--即可
            return false;//意味着下棋不成功
        }
        board[x][y]=chess;
        printBoard();
        return true;    //意味着下棋成功
    }
    public static void printBoard(){
        System.out.print("   ");
        for(int i=0;i<=14;i++){
            System.out.print((char)('A'+i)+" ");
        }
        System.out.println();
        for(int i=0;i<board.length;i++){
            System.out.printf("%2d ",i+1);
            for(int j=0;j<board[i].length;j++){
               System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void initBoard(){
        board=new String[15][15];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                board[i][j]="+";
            }
        }
    }
}

运行结果

 1 2 3
1 1 1
1 1 1
Wrong input:the letters must be from A to C

Enter number n: 3
Enter 3 rows of letters separated by spaces:
1 2 3
2 3 1
3 1 2
The input array is a Latin square
/*注释不编译*/
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后缀数组代码理解加注释
liuzhan214的博客
10-05 901
一段三四十行的代码却看了一个下午，仿佛又回到了刚学C语言的时候，终于看懂了，写下注释，晚上写题。 后缀数组是用来在线处理模式串匹配问题的算法，比如有一个文本串aabaaaab,我们求出一个sa数组，sa[i] = x表示第该文本串中第i小的后缀串的头字母是x，sa[0] = 3(aaaab),sa[1] = 4(aaab),sa[2] = 5(aab),sa[7]=2(baaaab),暴力处理后缀
数据结构中的堆--堆的定义、调整堆、建堆、自定义堆
smell201611010513的博客
05-08 1万+
一、堆的定义 1.结构特点 堆（数据结构）和Java语言中提到的堆没有一点关系。 逻辑上：完全二叉树 物理上：数组 堆是一种顺序存储结构（采用数组方式存储），仅仅是利用完全二叉树的顺序结构的特点进行分析。 2.结点下标计算公式（根节点从0开始） 已知二叉树根结点的下标是root,那么它左孩子的下标left=2*root+1，右孩子的下标right=...
认真学习数据结构之堆
小小默：进无止境
10-10 2365
# 【1】什么是堆？ 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： * 堆中某个结点的值总是不大于(大顶堆)或不小于其父结点的值(小顶堆)； * 堆总是一棵完全二叉树。 将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 堆是非线性数据结构，相当于一维数组，有两个直接后继。 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 ![在这里插入图片
【数据结构】堆的概念 | 从零开始实现数组堆
有道无术, 术尚可求。有术无道, 止于术。
11-27 2547
我们之前似乎确凿在C语言教学里讲过堆，但是那是操作系统中的堆，我们今天将要讲的堆是数据结构里的堆。数据结构中也有栈和堆，它跟操作系统对内存划分中的栈和堆没有关系。我横竖卷不动其他人，于是就打算再更亿篇博客罢。
是不是所有的对象和数组都会在堆内存分配空间
吒哇
07-17 1281
熟看了java编译原理等多本大神级别书籍后，小明信心满满的去面试字节跳动了，跳动的面试官说：小伙，来给我讲一下是不是所有的对象和数组都会在堆内存分配空间？ 小明不由一喜，昨天正好我看了相关jvm的书籍，堆中主要存放对象，即通过new关键字创建的对象。当场哈哈大笑：没错，面试官你太威武了，所有的对象和数组都存在堆中。当场从jvm原理：方法区、虚拟机栈、本地方法栈、堆、程序计数器讲起，说到堆内主要存放对象，栈中存放一些基本类型的变量数据（int/short/long/byte/float/double/.
三维数组操作_labview三维数组_labview_三维数组_
10-02
在LabVIEW编程环境中，三维数组是一种非常重要的数据结构，它能够有效地存储和处理大量多维数据。本篇文章将深入探讨如何在LabVIEW中创建、操作和应用三维数组，以实现如标题和描述所述的功能。 首先，让我们理解...
读取二维数组所有数据_labview读取数组_
09-29
在LabVIEW编程环境中，二维数组是一种常见的数据结构，用于存储多行多列的数据。本教程将深入探讨如何在LabVIEW中有效地读取二维数组的所有数据，这对于数据分析、处理和可视化至关重要。 首先，让我们理解二维数组...
C语言数组入门之数组的声明与二维数组的模拟
12-31
语言中指针与数组这两个概念之间的联系是密不可分的，以至于如果不能理解一个概念，就无法彻底理解另一个概念。 C语言中的数组值得注意的地方有以下两点： C语言中只有一维数组，而且数组的大小必须在编译期就作为一...
python将三维数组展开成二维数组的实现
01-21
这篇文章尝试用“曲线救国”的方法来解决二维数组叠加成三维数组的问题。 但天道有轮回，苍天绕过谁。好不容易把数组叠加在一块儿了，新的需求又出现了：将三维数组展开成二维数组。有借有还，再借不难。今天就来...
多维数组的运算
01-06
一、多维数组 简单来讲，多维数组就是“数字的集合”，数字排成一列的集合、排成长方形的集合、排成三维状或者（更加一般化）N 维状的集合都称为多维数组。 如上所述，数组的维数可以通过 np.dim()函数获得。此外，...
（第17讲）堆的数组实现
weiyastory的博客
07-31 1838
堆: 1、实际是一种完全二叉树，只有最后一层会不满，所以用数组实现，数组都会填满，不会有空缺 2、堆的左右子节点都不大于父节点，即父节点大于或者等于其子节点 程序如下： /**  * 堆：基于数组的  * 堆实际上是一个完全二叉树，并且其左右子节点都不大于父节点（父节点大于子节点）  */ package com.twelve; import java.util.Scan
数组存储在栈中还是堆中
热门推荐
yuanbinquan的专栏
08-31 2万+
今天看代码，定义了一个结构体 typedef struct {     int a;     int b;     int char[6*1024]; } ss_t; //定义一个指针 ss_t *sTmp = NULL; sTmp = malloc(sizeof(ss_t));  我的第一反应是，怎么可以定义这么大数据，容易把栈搞死（理由：数组保存在栈空间）。 哎...忘了是
【数据结构】什么是堆
weibo_dm的博客
06-17 2万+
#
最大（小）堆---数组的实现
小鹰的博客
05-01 8596
最大堆是我在看浙大陈越老师的数据结构视频学到的，用的数组实现的 如何描述堆呢？用我自己的话说就是： 根是这颗树最大的值，每个 根节点都比 左右子节点的值大， 对左右子树仍然成立； 那么最小堆呢正好相反： 根是这颗树的最小的值， 每个 根节点都比左右子节点的值小， 同样对左右子树成立； 图能最直观的体现： 我们很容易看出来，堆的左右子树仍然是堆。 （图摘自CSDN）所...
数组在堆还是栈
Phil0624的博客
02-19 1万+
看以下代码： char *str(char ch[],int n) { char temp[80] = {0}; for (int i = 0; i < n; i++) temp[i] = ch[i]; return temp; } char *arr1=new char[3]; arr1 = arr("hello", 3); cout << arr1 <&lt...
流程控制语句：顺序结构、选择结构、循环结构
weixin_45887924的博客
02-08 551
顺序结构 代码从主函数开始逐行向下运行 是一种宏观的代码运行结构 选择结构 程序员在写代码时碰到了多中可能发生的情况时，会使用选择结构来完成程序。 选择结构主要有两种 if 语句和switch语句 if 和 switch 的区别： if 既可以对一个单一的值进行判断，也可以对一个区间的值进行判断；switch 只能判断单一的值 if语句 双分支 基本格式： if(条件表达式){ ...
创建多维数组与数组操作方法详解
在第3章中，主要学习内容围绕数组和簇展开，这是VBA或类似的编程环境中的核心概念。章节首先定义了数组，强调了数组是相同类型数据元素的集合，可以是一维或多维，通过索引进行访问，索引从0开始且每个元素都有唯一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值