【Java】数组的相关算法（数组反转、复制、查找、排序、找最值、数组统计）

最新推荐文章于 2022-10-30 21:17:56 发布
最新推荐文章于 2022-10-30 21:17:56 发布
阅读量554 收藏 8
点赞数 2
分类专栏： Java 文章标签： Java 数组 算法 查找 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41569732/article/details/106153823
版权

数组的相关算法

文章目录

数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的(顺序查找)
（2）数组中的元素是有序的(二分查找)

复习下数组的

public class Test01_Review{
    public static void main(String[] args){
        //推荐
        int[] arr1;//在Java中int[]是一种引用数据类型，是数组类型
        //也对，但是不推荐
        int arr2[];
        //最早的时候，C语言不提对象的概念，所以没有把int[]看成一种数据类型，
        //只是强调一组数，而最重要的是这组数据的类型是int类型

        //int[] arr = new int[5]{1,2,3,4,5};//错误的

        int[] arr = new int[5];
        arr = new int[]{1, 2, 3, 4, 5};
        System.out.println(System.identityHashCode(arr));

        int[] arr3 = new int[5];
//        arr3 = new int[5]{1, 2, 3, 4, 5};//错误的
        arr3 = new int[]{1, 2, 3, 4, 5};
        System.out.println(System.identityHashCode(arr3));

        int[] arr4 = {1, 2, 3, 4, 5};
        for (int i = 0; i < arr4.length ; i++) {
            System.out.println(arr4[i]);
        }
    }
}

1、数组找最值

1、数组中找最值

思路：

（1）先假设第一个元素最大/最小

（2）然后用max/min与后面的元素一一比较

数组中找最值

先假设第一个元素最大/最小

然后用max/min与后面的元素一一比较

eg 示例代码：

int[] arr = {1, 2, 3, 4, 5};
//找最大值
int max = arr[0];
//遍历 比较  max
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

2、数组中找最值及其下标

情况一：找最值及其第一次出现的下标

思路：

（1）先假设第一个元素最大/最小

（2）然后用max/min与后面的元素一一比较

找最值及其第一次出现的下标

示例代码：

int[] arr = {1, 2, 3, 4, 5};
//找最大值
int max = arr[0];
int index = 0;
//遍历 比较 max
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
        index = i;
    }
}

或

int[] arr = {1, 2, 3, 4, 5};
//找最大值
int maxIndex = 0;
for(int i=1; i<arr.length; i++){
    if(arr[i] > arr[maxIndex]){
        maxIndex = i;
    }
}
System.out.println("最大值：" + arr[maxIndex]);

找最大值的数组索引，数组索引下标获取最大值。

情况二：找最值及其所有最值的下标（即可能最大值重复）

可能重复 我可以这样 先找到最大值 再去遍历一遍数组看是否有与最大值相等的值拿出来

思路：

（1）先找最大值

①假设第一个元素最大

②用max与后面的元素一一比较

（2）遍历数组，看哪些元素和最大值是一样的

示例代码：

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
    if(max == arr[i]){
        System.out.print(i+"\t");
    }
}

2、 数组统计：求总和、均值、统计偶数个数等

数组统计 求总和 均值 统计偶数个数

思路：遍历数组，挨个的累加，判断每一个元素

示例代码：求总和、均值

int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果，默认为0一波
for(int i=0; i<arr.length; i++){
    sum += arr[i];
}
double avg = (double)sum/arr.length;

示例代码2：

数组的元素累积

int[] arr = {4,5,6,1,9};

//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
    result *= arr[i];
}

累积 阶乘

int n = 5;
 
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=1; i <= n; i++){
     result *= n;
}
//result 为n的阶乘

示例代码3：求偶数个数

int[] arr = {4,5,6,1,9};
//统计偶数个数
int even = 0;
for(int i=0; i<arr.length; i++){
    if(arr[i]%2==0){
        even++;
    }
}

3、 反转

方法有两种：

1、借助一个新数组

2、首尾对应位置交换

第一种方式示例代码：借助一个新的数组 反转

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[len -1 - i];//-1 数组的下标
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

第二种方式示例代码：首尾对应位置交换

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
    //首  与  尾交换
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

4、 复制

复制数组 数组扩容
应用场景：

1、扩容

2、备份

3、截取

示例代码：扩容

int[] arr = {1,2,3,4,5,6,7,8,9};

//如果要把arr数组扩容，增加1个位置
//(1)先创建一个新数组，它的长度 = 旧数组的长度+1
int[] newArr = new int[arr.length + 1];

//(2)复制元素
//注意：i<arr.length   因位arr比newArr短，避免下标越界
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 新值;

//(4)如果下面继续使用arr，可以让arr指向新数组
arr = newArr;

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

示例代码：备份

备份一个数组 创建一个新的数组进行复制就可以了

扩容

int[] arr = {1,2,3,4,5,6,7,8,9};

//1、创建一个长度和原来的数组一样的新数组
int[] newArr = new int[arr.length];

//2、复制元素
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//3、遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

示例代码：截取

截取是拿一部分 截取

int[] arr = {1,2,3,4,5,6,7,8,9};

int start = 2;
int end = 5;

//1、创建一个新数组，新数组的长度 = end-start + 1;
int[] newArr = new int[end-start+1];

//2、赋值元素
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[start + i];
}

//3、遍历显示
for(int i=0; i<newArr.length; i++){
    System.out.println(newArr[i]);
}

5、 查找

查找 顺序查找 二分查找

查找分为两种：

1、顺序查找：挨个看

​ 对数组没要求

2、二分查找：对折对折再对折

​ 对数组有要求，元素必须有大小顺序的

查找 顺序查找 对数据没有要求 二分查找 对数组有要求 元素必须有大小顺序的

顺序查找示例代码：

int[] arr = {4,5,6,1,9};
int value = 1;
int index = -1;

for(int i=0; i<arr.length; i++){
    if(arr[i] == value){
        index = i;
        break;
    }
}

if(index==-1){
    System.out.println(value + "不存在");
}else{
    System.out.println(value + "的下标是" + index);
}

二分查找示例代码：

/*
2、编写代码，使用二分查找法在数组中查找 int value = 2;是否存在，如果存在显示下标，不存在显示不存在。
已知数组：int[] arr = {1,2,3,4,5,6,7,8,9,10};
*/
class Exam2{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9,10};//数组是有序的
		int value = 2;
		
        int index = -1;
		int left = 0;
        int right = arr.length - 1;
        int mid = (left + right)/2;
        while(left<=right){
            //找到结束
            if(value == arr[mid]){
                index = mid;
                break;
            }//没找到
            else if(value > arr[mid]){//往右继续查找
                //移动左边界，使得mid往右移动
                left = mid + 1;
            }else if(value < arr[mid]){//往左边继续查找
                right = mid - 1;
            }
            
            mid = (left + right)/2;
        }
        
        if(index==-1){
    		System.out.println(value + "不存在");
		}else{
    		System.out.println(value + "的下标是" + index);
		}
        
	}
}

使用for

class Exam2{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9};//数组是有序的
		int value = 2;
		
        int index = -1;
        
        for(int left=0,right=arr.length-1,mid = (left+right)/2; left<=right; mid = (left + right)/2){
             //找到结束
            if(value == arr[mid]){
                index = mid;
                break;
            }//没找到
            else if(value > arr[mid]){//往右继续查找
                //移动左边界，使得mid往右移动
                left = mid + 1;
            }else if(value < arr[mid]){//往左边继续查找
                right = mid - 1;
            }
        }
        
		
        
        if(index==-1){
    		System.out.println(value + "不存在");
		}else{
    		System.out.println(value + "的下标是" + index);
		}
        
	}
}

6、 排序

foundation 基础

数组的排序算法有千万种，我这里先写个两种：

1、冒泡排序

2、简单的直接排序

示例代码：冒泡：从小到大，从左到右两两比较

从小到大 从左到右两两比较

int[] arr = {5,4,6,3,1};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
    /*
    第1轮，i=1,从左到右两两比较，arr[0]与arr[1]。。。。。arr[3]与arr[4]
    第2轮，i=2,从左到右两两比较，arr[0]与arr[1]。。。。。arr[2]与arr[3]
    ...
    				arr[j]与arr[j+1]比较
    找两个关键点：（1）j的起始值：0（2）找j的终止值，依次是3,2,1,0，得出j<arr.length-i
    */
    for(int j=0; j<arr.length-i; j++){
        //两两比较
        //从小到大，说明前面的比后面的大，就交换
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

示例代码：从大到小，从右到左

char[] arr = {'h','e','l','l','o','j','a','v','a'};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
    /*
    第1轮，i=1，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[1]与arr[0]
    第2轮，i=2，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[2]与arr[1]
    ...
    第8轮，i=8，从右到左两两比较，arr[8]与arr[7]
    		   arr[j]与arr[j-1]
    找两个关键点：（1）j的起始值：8（2）找j的终止值，依次是1,2,3,。。。8，得出j>=i
    */
    for(int j=8; j>=i; j--){
        //从大到小，后面的元素 > 前面的元素，就交换
        if(arr[j]>arr[j-1]){
            int temp = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = temp;
        }
    }
}

示例代码：简单的直接选择排序

int[] arr = {3,2,6,1,8};

for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
    //（1）找出本轮未排序元素中的最值
    /*
    未排序元素：
    第1轮：i=1,未排序，[0,4]
    第2轮：i=2,未排序，[1,4]
    ...
    
    每一轮未排序元素的起始下标：0,1,2,3，正好是i-1的
    未排序的后面的元素依次：
    第1轮：[1,4]  j=1,2,3,4
    第2轮：[2,4]  j=2,3,4
    第3轮：[3,4]  j=3,4
    第4轮：[4,4]  j=4
    j的起点是i，终点都是4
    */
    int max = arr[i-1];
    int index = i-1;
    for(int j=i; j<arr.length; j++){
        if(arr[j] > max){
            max = arr[j];
            index = j;
        }
    }
    
    //（2）如果这个最值没有在它应该在的位置，就与这个位置的元素交换
    /*
    第1轮，最大值应该在[0]
    第2轮，最大值应该在[1]
    第3轮，最大值应该在[2]
    第4轮，最大值应该在[3]
    正好是i-1的值
    */
    if(index != i-1){
        //交换arr[i-1]与arr[index]
        int temp = arr[i-1];
        arr[i-1] = arr[index];
        arr[index] = temp;
    }
}



//显示结果
for(int i=0; i<arr.length; i++){
	System.out.print(arr[i]);
}

n-1躺 搞定最大 两两交换

渐若窥宏大
关注
专栏目录
Java自定义数组的工具类
小贺想改变
09-07 781
将一些数组使用的常用算法封装到方法中来使用，方法的初步理解使用，也体现了方法的可复用性和代码的整洁性
JavaSE - 数组的相关算法
adas5f1a51的博客
10-31 221
JavaSE - 数组的相关算法 本节学习目标： 了解并掌握Java中随机数的生成方式； 了解常用的数组赋值算法； 了解并掌握浅拷贝与深拷贝的区别与理解 了解并掌握常用的数组查找算法； 了解并掌握常用的数组排序算法。 1. 算法简述 算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的
数组相关的算法--java实现
GXR的博客
04-08 188
数组中涉及的常见算法（复制、排序、查找） 数组的赋值 package Day_01.demo; /* 使用简单数组 (1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量， 他们是int[]类型的数组。 (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。 (3)显示array1的内容。 (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值 (如array[0]=0,ar
与数组相关算法
wudiyong22的专栏
08-12 3311
找出递增数组中和为s的两个数 问题： 已知一个递增排序的数组和一个数字s，在数组中找出两个数，使它们的和正好等于s，找出任意一对便可。 思路： 普通解法： 第一个数从数组的开头开始，然后利用二分法找第二个数，时间复杂度为nlogn，因为第一个数是从头到尾顺序选择的。 时间复杂度为n的解法： 第一个数从数组的开头开始，第二个数从数组的结尾开始，如果两者的和大于s，则第二个数往前取下一个
数组相关算法
southernriver的博客
09-03 332
问题1、打印1到最大的n位数//解法一、直接求出n位数的最大值，然后直接从1开始打印 //缺陷：可能会溢出，大数问题 void Print1toMax(int n){ int num=1; while(n>0){ num*=10; n--; } for(int i=1;i<num;i++){ cout<<i<<" ";
【数据结构-数组】数组的相关算法
Mount256的博客
10-30 945
【数据结构-数组】数组的相关算法
java中数组的应用及方法
09-05
除了以上的基本应用，Java数组还支持许多其他操作，如排序（使用`Arrays.sort()`方法）、填充（使用`Arrays.fill()`方法）以及复制（使用`System.arraycopy()`方法）。此外，Java还提供了多维数组，可以创建数组的...
java数组总结使用手册
07-09
### Java数组总结使用手册 #### 一、数组基础概念 **1.1 什么是数组** 数组是一种基本的数据结构，用于存储一系列相同类型的元素。在Java中，数组是一种对象，它包含固定数量的相同类型的元素。数组中的每一个...
【Java】数组
flora
09-28 195
数组Array数组的概述一维数组声明和初始化数组的长度 array.length数组元素的默认初始化值整形和浮点型数组元素char型boolean型引用数据类型遍历数组for 下标循环for each 循环 （不考虑下标Arrays.toString(a)数组的内存解析内存的简化结构多维数组二维数组的声明和初始化Arrays.deepToString() 快速打印二维数组二维数组的内存解析数组中涉及的常见算法数组元素的赋值（杨辉三角、回形数）求数值型数组中元素的最大值、最小值、平均数、总和数组的复制、反转
数组操作相关算法
06-16 244
/* 数组的相关的算法操作： 1、在数组中找最大值/最小值 */ class Test11_FindMax{ public static void main(String[] args){ int[] array = {4,2,6,8,1}; //在数组中找最大...
数组相关的算法题
rover
08-02 388
// https://www.cnblogs.com/grandyang/category/625406.html 快速排序 void quickSort(int a[], int left, int right) { if(left < right) { int i = left, j = right; int x = a[left]; while(i < j) { while(i < j && a[j] >=
数组及其相应算法
lbj12345678_的博客
05-31 322
文章只是为了方便自己总结刷题，参考代码随想录，指路：https://programmercarl.com
数组相关算法整理（一）
快乐星球
05-20 266
先从基础 ：二分查找开始吧 。 1 二分查找 别看一个 二分查找： 他也有很多要注意的点 。区间开闭？相应边界怎么控制？ 二分查找思想1946 年提出 ， 知道1962年才出现一个真正没有bug的二分查找法。 //二分查找 前提： 原数组有序 template <typename T> int binarySearch(T arr[], int n, T target){ int l =0; int r = n-1;//闭区间 while(l <= r)//闭区间,相等时元素
数组的相关算法题
comli_cn的博客
07-31 360
1. 螺旋矩阵 描述： 给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。 示例: 输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ] 解题思路： 模拟螺旋矩阵的生成方式，即先按照顺序在第一行从左到右生成，然后在最后一列从上到下生成，然后在最后一列从右到左生成，然后在第一列从下到上生成，彼此之间不能有交叉。但这样只能生成最外层的数，要想完整地生成矩阵我们可以每生成一整行或者一整列就把这一整行或一整列去掉，只对
数组的常见算法
weixin_62914558的博客
07-28 824
数组的创建与元素的赋值；数组的赋值与复制；数组的反转；数组中指定元素的查找：搜索、检索；数组的排序算法（冒泡算法）
数组相关算法题
业精于勤荒于嬉 行成于思毁于随
04-06 231
题一： 128.：Longest Consecutive Sequence 要求是O（n），所以不能使用排序，那么就得考虑辅助。利用Map，key为num，value为其连续长度，每次之更新这个连续序列的首尾两个位置的value值。 public int longestConsecutive(int[] nums) { Map&amp;amp;amp;amp;amp;lt;Integer, Intege...
简单的冒泡排序
不曾留得桃花影
01-10 234
冒泡排序 介绍： 冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元 素，如果他们的顺序错误就把他们交换过来。 排序思想： 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步 做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有...
Java数组排序算法详解：冒泡、递增、快速、选择排序
"Java数组常用排序算法的实例代码与解析" 在Java编程中，排序是常见的操作，本资源总结了四种常用的排序算法，分别是冒泡排序、数组递增排序（也称为简单选择排序）、快速排序以及选择排序。这些算法都是基于数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值