数组习题

最新推荐文章于 2022-12-27 21:13:01 发布
最新推荐文章于 2022-12-27 21:13:01 发布
阅读量238 收藏 1
点赞数 1
分类专栏： 习题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43410906/article/details/104378892
版权
这篇博客介绍了数组相关的七道题目，涵盖了解法一func1()和func2()，涉及数组扩容、去重复、有序判断、随机路径生成、数组完全相同判断、连续相等数字检查以及有序数组合并。每题均提供了思路分析和结果展示。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第一题

解法一func1()：

分析：问题的难点在于数组长度不固定，需要读取一个数据，并且需要统计次数

          来一个数字加一个数字，那么就需要扩容了。然后填入数据，再进行排序。最后遍历数组依次判断数据的个数

          数组的扩容，就是创建一个新的数组，将元素赋值进去，将新数组的地址返回即可

          1.扩容：新建一个数组，将原先数组的值赋值进去，遍历小的数组，将小的数组的元素逐个按位置放到新的数组中。

          2.读取元素将数据存放到数组中

解法二func2()：

          借助计数排序的思想,将数组固定起来。

Arrays 特殊的是数组的工具类，toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据  "[1,2,3,4]"

import java.util.*;
class Demo05_01_01{
    public static void main(String[] args){
        //func1();
        func2();
    }
    public static void func2(){
        
        int[] arr = new int[101];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the integers between 1 and 100:");
        while(true){
            int num = scanner.nextInt();
            if(num == 0){
                break;
            }
            arr[num]++;
        }
        for(int i = 0;i < arr.length;i++){
            if(arr[i] != 0){//arr[i] 就表示数字i出现的次数
                System.out.println(i + " occurs " + arr[i] + (arr[i] > 1?" times":" time"));
            }
        }
    }
    public static void func1(){
        //1.获取用户输入的数据 动态的扩容数组填充数据
        int[] arr = new int[0];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the integers between 1 and 100:");
        int num = 0;
        while(true){
            num = scanner.nextInt();
            if(num == 0){
                break;
            }
            if(num < 1 || num > 100){//验证用户输入数据的正确性
                System.out.println("有非法数据！");
                return;
            }
            arr = copyOf(arr,arr.length + 1);
            arr[arr.length - 1] = num;
        }
        insertSort(arr);//2.按照输出结果,将数据中的数据进行排序
        show(arr);//3.输出连续相等的数字
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr = new int[newLen];
        for(int i = 0;i < arr.length;i++){
            newArr[i] = arr[i];
        }
        return newArr;
    }
    public static void insertSort(int[] arr){
        for(int i = 1;i < arr.length;i++){
            int e = arr[i];
            int j;
            for(j = i;j > 0 && arr[j - 1] > e;j--){
                arr[j] = arr[j - 1];
            }
            arr[j] = e;
        }
    }
    public static void show(int[] arr){
        for(int i = 0;i < arr.length;){
            int count = 1;
            for(int j = i + 1;j < arr.length;j++){
                if(arr[j] == arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            System.out.println(arr[i] + " occurs "  + count + (count>1?" times":" time"));
            i+=count;
        }
    }
}

结果展示：

 

第二题

分析：这个题同样有两种解法

解法一func1()：在全部输入之后去重复

                         1.循环遍历数组进行赋值

                         2.开始对已有的数据进行去重复操作

                         3.

解法二func2()：边输入边去重复         

三种方法method1(arr)：不创建额外空间 不许改变原先的顺序 

              method2(arr)：插入排序 连续相等

              method3(arr)：判断是否相等

import java.util.*;
class Demo05_02{
    public static void main(String[] args){
        /*
        思路1
            在全部输入之后去重复 func1
        思路2
            边输入边去重复 func2
        */
        // func1();
        func2();
    }
    public static void func2(){
        int[] arr=new int[0];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        for(int i=0;i<10;i++){
            int num=scanner.nextInt();
            if(!contains(arr,num)){
                arr=copyOf(arr,arr.length+1);
                arr[arr.length-1]=num;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static void func1(){
        //1.循环遍历数组进行赋值
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        int[] arr = new int[10];
        for(int i = 0;i < arr.length;i++){
            arr[i] = scanner.nextInt();
        }
        //2.开始对已有的数据进行去重复操作
        // 1 2 3 3 2 4 3 2 4 1
        // 1 2 3 4
        // method1(arr);        //空间S(n) 时间O(nm)
        // method2(arr);        //空间S(1) 时间O(n^2)
        // method3(arr);
    }
    public static void method3(int[] arr){
        //不创建额外空间 不许改变原先的顺序
        int i=0;
        int size=arr.length;
        while(i<size){
            for(int j=i+1;j<size;){
                if(arr[j]==arr[i]){
                    for(int k=j+1;k<size;k++){
                        arr[k-1]=arr[k];
                    }
                    size--;
                }else{
                    j++;
                }
            }
            i++;
        }
        for(i=0;i<size;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void method2(int[] arr){
        //插入排序
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        //连续相等
        for(int i=0;i<arr.length;){ //O(n)
            System.out.print(arr[i]+" ");
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            i+=count;
        }
    }
    public static void method1(int[] arr){
        int[] newArr=new int[0];
        for(int i=0;i<arr.length;i++){ //O(n)
            if(!contains(newArr,arr[i])){ //O(m)
                newArr=copyOf(newArr,newArr.length+1);
                newArr[newArr.length-1]=arr[i];
            }
        }
        System.out.println(Arrays.toString(newArr));
    }
    public static boolean contains(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return true;
            }
        }
        return false;
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }

}

结果展示：

 

 

第三题

分析：1.获取用户的输入 只不过第一个输入的数据时数据的个数(数组的长度)

           2.对数组进行有序的判断

           3.如果不是升序排列 那么势必会出现有一组数据 左大右小的情况，再进行判断

import java.util.*;
class Demo05_03{
    public static void main(String[] args){
        //1.获取用户的输入 只不过第一个输入的数据时数据的个数(数组的长度)
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter a list:");
        int len=scanner.nextInt();//获取的第一个数值就是数组的长度
        int[] arr=new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i]=scanner.nextInt();
        }
        //2.对数组进行有序的判断
        if(isSorted(arr)){
            System.out.println("The list is already sorted.");
        }else{
            System.out.println("The list is not sorted.");
        }
    }
    public static boolean isSorted(int[] list){
        //如果不是升序排列 那么势必会出现有一组数据 左大右小的情况
        for(int i=1;i<list.length;i++){
            if(list[i-1]>list[i]){
                return false;
            }
        }
        return true;
    }

}

结果展示：

 

第四题

分析：

输入的数据：槽子的个数 球的个数=路径的个数

                     创建槽子的具体的容器int[]

                     每一个小球下落的路径L R 字符串

                    对于每一个小球而言其路径中的步骤是随机产生L R

    1.提示用户输入槽子的个数和小球的个数

    2.根据已有的槽子的个数去创建槽子容器

    3.根据已有的球和槽子的个数去随机创建一个小球下落的路径

    4.路径中经过几个钉子？路径的步骤有几步 和槽子的个数有关

    5.如何通过路径的经过得知最终所落入的槽子？

import java.util.*;
class Demo05_04{
    public static void main(String[] args){
        //1.
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.
        int[] arr=new int[slots];
        //3.几个球几个路径path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看当前路径中R的个数即可
            arr[getR(path)]++;
        }
        //6.输出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根据槽子的个数计算每一个球下落的路径
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}

 结果展示：

 

第五题

分析：

判断两个数组是否完全相同

 1.先判断长度

2.再依次判断元素大小

class Demo05_05{
    public static void main(String[] args){
        int[] list1={1,2,3,4,5,6,7};
        int[] list2={1,2,3,4,5,7,6};
        System.out.println(equals(list1,list2));
    }
    public static boolean equals(int[] list1,int[] list2){
        if(list1.length!=list2.length){
            return false;
        }
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

结果展示：

 

第六题

分析：解题步骤：根据用户输入的数字，判断是否有四个连续相等的数字，返回true或false

1.提示用户输入列表中数字的总数和具体的数字

2.判断列表中是否含有四个连续相等的数

import java.util.*;
class Demo05_06{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        //1.提示用户输入列表中数字的总数和具体的数字
        System.out.print("Enter the number of values:");
        int num = scanner.nextInt();
        int[] arr = new int[num];
        for(int i = 0;i < num;i++){
            arr[i] = scanner.nextInt();
        }
        //2.判断列表中是否含有四个连续相等的数
        if(isConsecutiveFour(arr) == true){
            System.out.println("The list has consecutive fours");
        }else{
            System.out.println("The list has no consecutive fours");
        }
    }
    public static boolean isConsecutiveFour(int[] arr){
        for(int i = 0;i < arr.length;){
            int count = 1;
            for(int j = i + 1;j < arr.length;j++){
                if(arr[i] == arr[j]){
                    count++;
                }else{
                    break;
                }
            }
            if(count >= 4){
                return true;
            }
            i+=count;
        }
        return false;
    }
}

结果展示：

 

第七题

分析：有序数组的合并，最主要的问题在于 数组之间有长有短。

1.先判断数组是否为空

2.如果都不为空，再考虑具体操作

import java.util.*;
class Demo05_07{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        //第一个数组list1
        System.out.print("Enter list1:");
        int len1 = scanner.nextInt();
        int[] list1 = new int[len1];
        for(int i = 0;i < list1.length;i++){
            list1[i] = scanner.nextInt();
        }
        //第二个数组list2
        System.out.print("Enter list2:");
        int len2 = scanner.nextInt();
        int[] list2 = new int[len2];
        for(int j = 0;j < list2.length;j++){
            list2[j] = scanner.nextInt();
        }
        System.out.println("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;
        }
        //只有两个都不是null，再考虑具体操作
        int[] list3 = new int[list1.length + list2.length];
        int p1 = 0;
        int p2 = 0;
        int p3 = 0;
        while(true){
            if(p1 == list1.length && p2 == list2.length){
                break;
            }
            if(p1 < list1.length && p2 == list2.length){
                list3[p3++] = list1[p1++];
            }else if(p1 == list1.length && p2 < list2.length){
                list3[p3++] = list2[p2++];
            }else{
                if(list1[p1] <= list2[p2]){
                    list3[p3++] = list1[p1++];
                }else{
                    list3[p3++] = list2[p2++];
                }
            }
        }
        return list3;
    }
}

结果展示：

 

 

 

我们的例题就先说到这儿……

 

Java练习题总结（五）
weixin_44077638的博客
02-15 377
5.1 /* 创建101个长度的数组，如果输入一个数字，那么这个数组的值加一，最后输出的时候输出第i个数字的个数，如果不等于0就输出。然后根据数字的个数看是不是复数即可 */ import java.util.*; class Home05_01{ public static void main(String []args){ Scanner in = new Scanne...
JavaScript数组练习题
qq_58492621的博客
07-18 3167
JavaScript数组方面的练习题，非常详细的练习题，对于新手学习JavaScript数组非常有帮助哦！
6-1 判断一个数列是否已排好序
qq_63433878的博客
12-27 1779
6-1 判断一个数列是否已排好序
编写以下方法，如果参数中的 list 数组已经按照升序排好了，则返回 true。 public static boolean isSorted(int[] list)以及动态输入
lrxd233的博客
03-25 1837
动态输入数组 package exercise3; import java.util.*; public class 作业7_19 { public static boolean isSorted(int[] list) //判断是否已升序排列 { for (int i = 0; i < list.length; i++) { for (int j = i + 1; j < list.length; j++) { if
Java练习题五【数组】
Teacher_HENG
02-18 794
目录 练习题53.计算数字的出现次数 练习题54.打印不同的数 练习题55.是否排好序了 练习题56.游戏：豆机 练习题57.完全相同的数组 练习题58.模式识别：四个连续相等的数 练习题59.合并两个有序列表 练习题60.游戏：猜字游戏 练习题53.计算数字的出现次数 import java.util.Scanner; class Demo53{ publ...
web前端学习611-627（JavaScript数组---数组，创建数组，获取数组元素，遍历数组，数组中新增元素，数组案例）
weixin_51249285的博客
04-06 2749
文章目录JavaScript数组1 数组的概念2 创建数组2.1 数组的创建方式2.2 利用new 创建数组2.3 利用数组字面量创建数组（常用）2.4 数组元素的类型3 获取数组元素数组的索引4 遍历数组4.1 数组的长度案例1：求和案例2：数组最大值案例3：数组转换为分割字符串5 数组中新增元素5.1 通过修改length长度新增数组元素 JavaScript数组 1 数组的概念 之前学的变量：存储一个值。 如果存班级中所有学生姓名：可以使用数组（Array），存放一组数据，提供访问（获取）方式 数组：
Java数组练习题(带答案).doc
03-15
本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细解释： 1. **数组的访问**：数组的元素通过下标来访问，下标从0开始，如`Array[0]`表示访问第一个元素。数组的长度可以通过`...
C语言数组练习题[1].pdf
09-30
从提供的文件内容来看，文档是关于C语言数组的练习题目，其中包含了一定数量的数组定义、初始化、输入输出以及多维数组的使用等基础知识点。以下是对文件内容的详细解读： 1. 数组定义与声明： 文档中出现了不同...
数组练习题Subject:数组
最新发布
10-16
数组练习题总结 数组是一种基本的数据结构，广泛应用于各种编程语言中。在 Java 中，数组是用于存储一组相同类型的元素的集合。下面是数组练习题的总结： 1. 排序算法 在数组练习题中，我们遇到了排序算法的应用...
数组练习题
qq_52919150的博客
09-27 3103
一、一维数组练习题 1、任意一个人输入年龄，就可以判断出他是哪个年龄段的人？ 0-9 垂髫之年；10-19 志学之年；20-29 弱冠之年；30-39 而立之年；40-49 不惑之年；50-59 知命之年；60-69 花甲之年；70-79 古稀之年；80-89 杖朝之年；90-99 耄耋之年。 public class Age { /* 任意一个人输入年龄，就可以判断出他是哪个年龄段的人？ 0-9 垂髫之年 10-19 志学之年
数组习题（1）
weixin_45042315的博客
02-18 332
下面是关于数组的一些题↓↓↓↓↓↓ 分析： 注意输入以0结束。 先创建一个数组长度为0的新数组，将新数组进行扩容， 在依次将用户输入的数据传入新数组中，每传进一个数，数组就要进行一次扩容，将数据全部读取到新数组中之后， 再将数组进行排序，排序完毕之后再依次遍历数组判断数据的个数 ​ import java.util.*; class Demo05_01{ publi...
Java基础---如何使用Java中的数组（三十）
weixin_34210740的博客
09-02 137
如何使用 Java 中的数组Java 中操作数组只需要四个步骤：1、 声明数组语法：或者其中，数组名可以是任意合法的变量名，如：2、 分配空间简单地说，就是指定数组中最多可存储多少个元素语法：其中，数组长度就是数组中能存放元素的个数，如：话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：3、 赋值分配空间后就可以向数组中放数据了，数组中元素都是通...
java遍历数组并重新拼接数组里的元素
dicuifan9127的博客
03-02 864
public ArrayList getinferfacelist(ArrayList<TaskNameList> taskNameLists) { String interfaceName=""; String splitedWorkTable = ""; ArrayList interfaceNameL...
最大子序列和
y114102的博客
12-16 334
最大子序列和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 暴力循环 算法的主要思想是求出所有的连续子序列的和，然后取最大值即可。 public static int base(int[] array) { int max = 0; for (int i = 0; i < array.leng
java scanner接收数组_java – 使用scanner将文件中的整数读入数组
weixin_30228803的博客
02-16 2494
我正在为学校做一份复习工作.赋值是编写一个类,它从标准输入读取一个包含几个整数的文件,这些整数将被放入一个数组中.从这里开始,需要编写方法来找出平均值,中位数,最大值,最小值和标准差.它读起来像这样：4556677889等等…所以,我假设我需要创建一个数组列表(因为长度未定义)并使用scanner读取每一行的整数,然后创建将挑选我需要的方法.但是,我无法理解如何正确使用FileReader和Sca...
Java 冒泡排序及改进
在路上的专栏
06-21 2143
面试经常会碰到让用冒泡排序法对数组进行排序，今天写了个demo，下面先给出冒泡排序的代码：public class BubbleSort { /** * 改进后的冒泡排序算法的实现： * * @param list * 欲排序的数组 * @author csc */ public static void main(String[] args)
JAVA数组习题训练
qq_45824565的博客
02-18 278
1. import java.util.Scanner; class Demo05_01_02{ public static void main(String[] args){ //0 1 2 3 4 5 ~ 100 //0 单独不算 懒一下 不想计算offset //arr[i] 就表示数字i出现的次数 int[]...
第五章数组类型题
weixin_45091028的博客
02-18 276
两种解题思路 思路1：数组长度不固定 需要读取一个数据 数组扩容 填入数据数据填入之后进行排序 然后遍历数组依次判断数据的个数连续相等 import java.util.*; class Demo05_01{ public static void main(String[] args){ /* 思路1：数组长度不固定 需要读取一个数据 数组扩容...
第七章第十九题（是否排序好了）（Is it sorted）
jxh1025_的博客
11-30 1756
第七章第十九题（是否排序好了）（Is it sorted） **7.19（是否排序好了）编写以下方法，如果参数中的list数组已经按照升序排好了，则返回true。 public static boolean isSorted(int[] list) 编写一个测试程序，题数用户输入一个列表，显示该列表会否已经排好序。下面是一个运行示例。注意，输入中的第一个数表示列表中的元素个数。该数不是列表的一部分。 Enter the size of the list:8 Enter the contents of t
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值