数组练习题-java

最新推荐文章于 2023-01-25 20:37:21 发布
最新推荐文章于 2023-01-25 20:37:21 发布
阅读量902 收藏 6
点赞数 1
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51351504/article/details/124934661
版权

目录

1.判断一个数组里是否有重复的数

2.判断数组是否是对称数组 

3. 定义一个数组，用来存储1 1 2 3 5 8 13……这样的Fibonacci数列，存储该数列的前20个数；

4.定义一个10个元素的数组，编写程序，随机打乱顺序；

5. 将两个已经排序的数组合并，合并之后，按大小进行排序；

6.定义一个数组，例如: int[]  arr = {1,2,23,1,1,2,3,4};将数组中的元素，去重，变成 int[] newArr = {1,2,3,4,23};

7.定义连个数组，一个数组存储去重后的的 电话号码，例如: int[] myPhone = {1,5,7,6,3};将这个数组输出，得出 15776635351

8.将一个正整数如35转换成二进制码

9.已知一个数组，例如int[] a={5,6,8,0,6,,0,1,0,56};写一段代码，要求不使用新数组的情况下，将非0的数字向前移动，将所有的0放非0之后，并说明一下程序执行的时间复杂度;(百度机试题)

移动之后的数据应该如下： a={5,6,8,6,1,56,0,0,0};

10.利用二分法查找数组中的数据的位置，如果不存在，输出-1

11.找出两个已排序的数组中包含的相同元素；

12. 二维数组排序

13. int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;

要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：

int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} ;

1.判断一个数组里是否有重复的数

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
    //1.判断一个数组里是否有重复的数
        int[] a = {1,2,3,4,5};
        boolean b=false;
        for(int i=0;i<a.length-1;i++){
            for(int j=i+1;j<a.length;j++){
                if(a[i]==a[j]){
                    b=true;
                    break;
                }
            }
            if(b){
                break;
            }
        }
        if(b) {
            System.out.println("有重复的数");
        }else{
            System.out.println("无重复的数");
        }

    }
}

2.判断数组是否是对称数组 

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
    //2.判断数组是否是对称数组
        int[] a = {1,2,3,2,1};
        boolean b=true;
       for(int i=0;i<a.length/2;i++){
           if (a[i]!=a[a.length-1-i]){
              b=false;
              break;
           }
       }
       if(b){
           System.out.print("是");
       }else{
           System.out.print("不是");
       }
    }
}

3. 定义一个数组，用来存储1 1 2 3 5 8 13……这样的Fibonacci数列，存储该数列的前20个数；

 import java.util.Arrays;
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int[] arr = new int[20];
arr[0]=1;
arr[1]=1;
for(int i=2;i< arr.length;i++){
arr[i] = arr[i-1]+arr[i-2];
}
System.out.println(Arrays.toString(arr));
  }
}

4.定义一个10个元素的数组，编写程序，随机打乱顺序；

import java.util.Arrays;
import java.util.Random;

public class Random_sort {
    public static void main(String[] args) {
        //4.定义一个10个元素的数组，编写程序，随机打乱顺序；
        int[] arr = {2,3,5,4,7,5,7,9,1,45};
        Random random = new Random();
        //思路:遍历数组,利用随机数产生0-9的随机索引,把随机索引所代表的值与当前值(交换)
        int t;
        for(int i = 0;i< arr.length;i++){
            int index = random.nextInt(arr.length);
            t = arr[i];
            arr[i] = arr[index];
            arr[index] = t;

        }
        System.out.println(Arrays.toString(arr));
    }
}

5. 将两个已经排序的数组合并，合并之后，按大小进行排序；

public class Merge {
	public static void main(String[] args) {	
		int[] a={1,2,8,45,89};
		int[] b={3,4,6,9,30,66,100};
		
		//1.创建一个数组c
		int[] c=new int[a.length+b.length];
		
		int c_i=0;
		int a_i=0;
		int b_i=0;
		for(int i=0;i<c.length;i++) {
			if(a_i==a.length) {//如果a中的元素已取完，直接取b中的元素
				c[i]=b[b_i++];
			}else if(b_i==b.length) {//如果b中的元素已取完，直接取a中的元素
				c[i]=a[a_i++];
			}else {//取元素小的元素的那个数组
				if(a[a_i]<b[b_i]) {
					c[i]=a[a_i++];
				}else {
					c[i]=b[b_i++];
				}
			}
		}
		

		System.out.println(Arrays.toString(c));
	}

}

6.定义一个数组，例如: int[]  arr = {1,2,23,1,1,2,3,4};将数组中的元素，去重，变成 int[] newArr = {1,2,3,4,23}; 

import java.util.Arrays;

public class 去重 {
    public static void main(String[] args) {
        int[]  arr = {1,2,23,1,1,2,3,4};
        int[] newArr = new int[8];
        boolean[] b = new boolean[8];
        int index = 0;
        for(int i = 0;i< arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]==arr[j]){
                    b[i] = true; //有相等的
                    break;
                }
            }
        }
        for(int i = 0;i<b.length;i++){
            if (!b[i]){
                newArr[index++] = arr[i];
            }
        }
        System.out.println(Arrays.toString(newArr));
        //System.out.println(Arrays.toString(b));
    }
}

7.定义连个数组，一个数组存储去重后的的 电话号码，例如: int[] myPhone = {1,5,7,6,3};将这个数组输出，得出 15776635351

import java.util.Arrays;
import java.util.Random;

public class Random_sort {
    public static void main(String[] args) {
        //7.定义连个数组，一个数组存储去重后的的 电话号码，
        // 例如: int[] myPhone = {1,5,7,6,3};将这个数组输出，得15776635351
        int[] myPhone = {1,5,7,6,3};
        int[] myphone1={0,1,2,2,3,3,4,1,4,1,0};
        //把数组myphone1的值作为myPhone的下标
        int[] real_phone = new int[11];
        int index=0;
        for(int i=0;i<myphone1.length;i++){
           real_phone[index++] = myPhone[myphone1[i]];
        }
        System.out.println(Arrays.toString(real_phone));
    }
}

8.将一个正整数如35转换成二进制码

import java.util.Arrays;
import java.util.Random;

public class Random_sort {
    public static void main(String[] args) {
        //8.将一个正整数如35转换成二进制码
        String b = Integer.toBinaryString(35);
        System.out.println(b);

    }
}

9.已知一个数组，例如int[] a={5,6,8,0,6,,0,1,0,56};写一段代码，要求不使用新数组的情况下，将非0的数字向前移动，将所有的0放非0之后，并说明一下程序执行的时间复杂度;(百度机试题)

移动之后的数据应该如下： a={5,6,8,6,1,56,0,0,0};

1.暴力法

package com.moju;
import java.util.Arrays;
import java.util.Scanner;
public class Mtest {
	public static void main(String[] args) {
		//已知一个数组，例如int[] a={5,6,8,0,6,0,1,0,56};
		//写一段代码，要求不使用新数组的情况下，将非0的数字向前移动，
		//将所有的0放非0之后，并说明一下程序执行的时间复杂度;(百度机试题)
       //移动之后的数据应该如下：
       //a={5,6,8,6,1,56,0,0,0};
	  int[] a={5,6,8,0,6,0,1,0,56};
	  int t;
		for(int i=0;i<a.length;i++) {
			if(a[i]==0) {
				for(int j=i+1;j<a.length;j++) {
					if(a[j]!=0) {
						t = a[j];
						a[j] = a[i];
						a[i] = t;
						break;
					}
				}
			}
		}
		System.out.print(Arrays.toString(a));	
	}

}

2. 双指针法 

10.利用二分法查找数组中的数据的位置，如果不存在，输出-1

11.找出两个已排序的数组中包含的相同元素；

 package com.moju; 
import java.util.Arrays;
import java.util.Scanner;
 public class Mtest {
public static void main(String[] args) {
	//找出两个已排序的数组中包含的相同元素；
	int[] nums1 = {3,56,78,78};
	int[] nums2 = {0,1,2,3,78};
	int[] nums3 = new int[5];
	int i = 0,j = 0,index=0;
	while(i<nums1.length&&j<nums2.length) {
		if(nums1[i]>nums2[j]) {
			j++;
		}else if(nums1[i]<nums2[j]) {
			i++;
		}else {
			nums3[index++] = nums1[i];
			i++;
			j++;
		}
	}
	System.out.print(Arrays.toString(nums3));	

}
}

12. 二维数组排序

package com.moju.practice;

public class 二维数组排序 {
	
	public static void main(String[] args) {
			 	 // 1 1	 	 2 3 4	 	7 8 34 54
	int[][] aaa = {{8,2} , {54,1,3} , {1,7,34,4}}; 	     		
	
	//1.将二维数组 变成一维数组
	int count = 0;
	//你要知道一维数组多长？
	for(int i =0; i < aaa.length;i++) {
		for(int j = 0; j < aaa[i].length;j++) {
			count++;
		}
	}
	//一维数组的长度确定了  9
	int[] newArr = new int[count];
	int haha = 0;
	//一维数组长度确定了，将二维数组的元素，导入到一维数组中
	for(int i =0; i < aaa.length;i++) {
		for(int j = 0; j < aaa[i].length;j++) {
				newArr[haha++] = aaa[i][j];
		}
	}
	
	//2.将一维数组排序
	for(int i = 0 ;i < newArr.length-1;i++) {
		for(int j = 0; j < newArr.length-1-i;j++) {
			if(newArr[j] > newArr[j+1]) {
				int temp = newArr[j];
				newArr[j] = newArr[j+1];
				 newArr[j+1] = temp;
			}
		}
	}
	
	//排序后 遍历一维数组看看对不对
	for(int i = 0;i < newArr.length; i++) {
		System.out.print(newArr[i]+" ");
	}
	
	//重新清零
	haha = 0;
	//3.在将一维数组 变成 二维数组
	for(int i =0; i < aaa.length;i++) {
		for(int j = 0; j < aaa[i].length;j++) {
			aaa[i][j] = newArr[haha++];
		}
	}
	System.out.println("我是二维数组输出结果");
	//遍历二维数组看看对不对
	
	System.out.print("{");
	for(int i =0; i < aaa.length;i++) {
		System.out.print("{");
		for(int j = 0; j < aaa[i].length;j++) {
			if(j == aaa[i].length-1) {
				System.out.print(aaa[i][j]+"}");
			}else {
				System.out.print(aaa[i][j]+",");
			}
		}
		if(i != aaa.length-1) {
			System.out.print(",");
		}
	}
	System.out.print("}");	
	}
}

13. int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;

要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：

int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} ;

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
     //int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
        // 要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
        //    int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} ;
        int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
        int count=0;
        for(int i = 0;i<oldArr.length;i++){
            if (oldArr[i]!=0){
                count++;
            }
        }
        int[] newArr = new int[count];
        int index=0;
        for (int i = 0;i<oldArr.length;i++){
            if(oldArr[i]!=0){
                newArr[index] = oldArr[i];
                index++;
            }
        }
        for(int i:newArr){
            System.out.print(i+" ");
        }

    }
}

14.静态初始化二维数组 {{9},{2,7}，{4,1,6},{2,17,5}}，求出最大数，最小数和平均值

import java.util.Arrays;
public class Random_sort {
    public static void main(String[] args) {
        //静态初始化二维数组 {{9},{2,7}，{4,1,6},{2,17,5}}，求出最大数，最小数和平均值
        int[][]arr = {{9},{2,7},{4,1,6},{2,17,5}};
        int max,min,sum=0,count=0,t;
        max=arr[0][0];
        min=arr[0][0];
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                count++;
                sum+=arr[i][j];
                if(max<arr[i][j]){
                    t = arr[i][j];
                    arr[i][j] = max;
                    max = t;
                }
                if(min>arr[i][j]){
                    t = arr[i][j];
                    arr[i][j] = min;
                    min = t;
                }
            }
        }
        System.out.println("最小值: "+min);
        System.out.println("最大值: "+max);
        System.out.println("平均值: "+(double)(sum/count));

    }
}

选择困难症患者emm...
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
javaSE-阶段 数组-练习题及答案
cookies___的博客
03-12 1248
1.定义一个包含10个元素的数组，对其进行赋值，使每个元素的值等于其下标的2倍 package homework5; public class test5 { public static void main(String[] args) { int[] a = new int[10]; for(int i=0;i<10;i++){ a[i]=i*2; System.out.print(a[i]+" ");
排序算法总结
今天比昨天进步一点点
05-07 435
排序算法说明（1）排序的定义：对一序列对象根据某个关键字进行排序；输入：n个数：a1,a2,a3,...,an输出：n个数的排列:a1',a2',a3',...,an'，使得a1'&lt;=a2'&lt;=a3'&lt;=...&lt;=an'。再讲的形象点就是排排坐，调座位，高的站在后面，矮的站在前面咯。（3）对于评述算法优劣术语的说明稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面...
两个数组合并排序的java实现
热门推荐
qq_42846655的博客
08-06 1万+
两个数组合并排序的java实现 本文主要描述了两个数组的合并排序，用Java代码实现的几种方法 方法一 用于合并两个有序数组，默认升序 package com.cyl.day05; /** * 数组A：“1，7，9，11，13，15，17，19”； * 数组b：“2，4，6，8，10” ； * 两个数组合并为数组c，按升序排列。 *...
Java基础练习题之数组(一)
weixin_44786702的博客
01-25 1035
Java基础练习题之数组(一)
指针和数组试题解析（重置版）
DarkAndGrey的博客
09-19 823
指针 和 数组 试题解析 小编，在这里想说一下，c语言的最后一节 C预处理，可能还需要一些时间，因为小编，昨天才下载了虚拟机 和 linux 系统，还没开始安装。所以无法着手写，因为 C预处理，vs2013很难表达，也就意味可能会讲不清楚。所以这篇文章可能需要点时间，再加上小编初期的文章，是没有排版的（而且可能有些错误，请大家以重置版为准），所以这几天我就把这些重新写。有兴趣的朋友可以看看。（ps：如果哪一天没有更新，意味着小编正在努力学习，为了能给大家呈现一片详细好懂的文章。）       下面直接进入
找出两个有序数组的公共元素
tianxieeryang的博客
03-22 5309
找出两个有序数组的公共元素，例：有序数组[3, 5, 7, 8, 10, 12]和有序数组[15, 10, 8, 7, 4, 3, 1]的公共元素为（8, 10）#include&lt;iostream&gt; #include&lt;vector&gt; using namespace std; int main() { int m,n; vector&lt;int&gt; a; ve...
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。...以上是对Java数组练习题中的主要知识点的详细解析，通过这些题目，可以更好地理解和掌握Java中数组的操作、特性以及异常处理。
Java算法练习-最短子数组练习题
09-28
[Java]算法练习-最短子数组练习题
Java 数组练习题（1）.docx
01-14
Java 数组练习题（1） Java 数组是一种基本的数据结构，通过本练习题，我们将学习如何声明和使用数组，包括基本类型数组和字符串数组的声明、赋值、输出、索引、循环遍历、元素操作等。 1. 将’A’,’B’,’C’...
Java数组练习题带答案.doc
10-07
Java 数组练习题带答案 Java 数组是一种基本的数据结构，用于存储固定大小的同类型元素的集合。本文通过多种练习题和答案，帮助读者更好地理解 Java 数组的概念和应用。 1. 数组元素的访问 数组的元素可以通过...
求两个有序数组相同元素的个数-JAVA
terry84fun的专栏
11-13 1458
 /** * @param args *求两个有序数组相同元素的个数 */ public static int commonLength(int[] a,int[] b) { int lenA=a.length; int lenB=b.length; int i=0,j=0; int count=0; while(i { if(a[i]==b
Javase—数组习题二
qq_39162424的博客
11-27 1142
/** * 2.静态初始化一维数组{10,20,11,35,6,89}，进行冒泡排序 */ package com.array2; import java.util.Arrays; public class Text02 { public static void main(String[] args) { //按照从小到大的顺序进行冒泡排序 int[] a=new int[]
将两个整形数组排序后合并成一个数组
shanzhizi的专栏
05-23 5581
将两个整形数组排序后合并成一个数组， 数组排序采用快速排序法，快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j). 它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。 #include #include #inclu
Java中二维数组的定义及静态初始化
pipizhen_的博客
07-11 3769
二维数组的定义及静态初始化： 二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。 那三维数组是什么？三位数组是一个特殊的二维数组，特殊在这个二维数组中的每一个元素是一个一维数组。 二维数组的静态初始化： int[][] array1 = { {1, 2, 3}, {0, 3, 1, 6}, {7} }; 测试代码： public class ArrayTest06 { public static void main(String[] args) {
Java排序及二维数组练习
ChenYanQing666的博客
03-15 1461
【编程题】 1.判断一个数组里是否有重复的数,假设数组名为int[] array 您的回答： import java.util.*; public class Test{ public static void main(String args[]){ //判断一个数组里是否有重复的数,假设数组名为int[] array 做笔记！！！ int[] array=new int[5]; Scanner sc=new Scanner(System.in); for(int i=0;i<
java数组int_Java数组（int为例）
weixin_30700095的博客
02-12 7953
Java数组(int为例)定义：相同数据类型的数据的组合,是一种引用类型，是一个对象，存在堆里。数组初始化：int[] scores1 = new int[]{72,90,59};//静态初始化：在声明并初始化数组与给数组相应的元素赋值操作同时进行。int scores2[] = new int[3];scores2[0] = 72;scores2[1] = 90;scores2[2] = 59;...
java 数组合并_Java排序算法——归并排序(Merge Sort)
weixin_39976733的博客
12-02 599
简介：归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。二路归并排序是一种稳定的算法。两个有序的数组合并的思路：假设有两个已经排好序的数组arr1[ ]，arr2[ ]...
定义一个一维数组 int a[]= {1,2,3,4,5,6,7,8}
m0_71934534的博客
10-09 983
定义一个一维数组 int a[]= {1,2,3,4,5,6,7,8}, (1) 求一维数组的长度 (2) 并将所有奇数下标元素自乘3，偶数下标*元素*自增2.输出变化后的数组
Javase—数组习题一
qq_39162424的博客
11-26 2811
/** * 1.定义一个5个元素组成的一维数组，对其赋值，再把该数组反向输出。 */ package com.array1; public class Text1 { public static void main(String args[]) { //定义一个数组 int[] a=new int[5]; //利用循环对数组赋值，通过下标i调用数组，从0开始 for(in
java 数组练习题
最新发布
05-09
Java 数组练习题可以有很多，下面是一些常见的例子： 1. 给定一个整数数组，找出其中两个数的和等于目标值，返回这两个数的索引。例如，给定 nums = [2, 7, 11, 15], target = 9，因为 nums + nums = 2 + 7 = 9，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值