关于数组的常见算法

已于 2024-07-10 23:55:44 修改
阅读量676 收藏 8
点赞数 18
分类专栏： 看文章就能学会java 文章标签： 算法 数据结构 java
于 2024-07-10 21:15:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44554794/article/details/140333721
版权

一、案例一

案例说明

案例：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，总和，平均值，并输出出来
要求：所有随机数都是两位数：[10,99]
提示：求[a,b]范围内的随机数： (int)(Math.random() * (b - a + 1)) + a;

代码实现

public class ArrayExer01 {
    public static void main(String[] args) {
        //1. 动态初始化方式创建数组
        int[] arr = new int[10];
        //2. 通过循环给数组元素赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * (99 - 10 + 1)) + 10;
            System.out.print(arr[i] + "\t");
        }

        System.out.println();

        //3.1 求最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);

        //3.2 求最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);


        //3.3 求总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为：" + sum);

        //3.4 求平均值
        int avgValue = sum / arr.length;
        System.out.println("平均值为：" + avgValue);


    }
}

二、案例二

案例说明

案例：评委打分

分析以下需求，并用代码实现：

（1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5,4,6,8,9,0,1,2,7,3

（2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）

代码实现

public class ArrayExer02 {
    public static void main(String[] args) {

        int[] scores = {5,4,6,8,9,0,1,2,7,3};
        //声明三个特征值
        int sum = 0;
        int max = scores[0];
        int min = scores[0];

        for (int i = 0; i < scores.length; i++) {
            sum += scores[i]; //累加总分
            //用于获取最高分
            if(max < scores[i]){
                max = scores[i];
            }
            //用于获取最低分
            if(min > scores[i]){
                min = scores[i];
            }
        }

        int avg = (sum - max - min) / (scores.length - 2);
        System.out.println("去掉最高分和最低分之后，平均分为：" + avg);


    }
}

三、案例三

案例说明找最值及其所有最值的下标
代码实现一

public class Test13AllMaxIndex {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9,9,3};
        //找最大值
        int max = arr[0];
        for(int i=1; i<arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("最大值是：" + max);
        System.out.print("最大值的下标有：");

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

代码实现二

public class Test13AllMaxIndex2 {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9,9,3};
        //找最大值
        int max = arr[0];
        String index = "0";
        for(int i=1; i<arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
                index = i + "";
            }else if(arr[i] == max){
                index += "," + i;
            }
        }

        System.out.println("最大值是" + max);
        System.out.println("最大值的下标是[" + index+"]");
    }
}

四、案例四

案例说明


案例：使用二维数组打印一个 10 行杨辉三角。

   提示：
   1. 第一行有 1 个元素, 第 n 行有 n 个元素
   2. 每一行的第一个元素和最后一个元素都是 1
   3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
   yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

代码实现

public class YangHuiTest {
    public static void main(String[] args) {

        //1. 创建二维数组
        int[][] yangHui = new int[10][];

        //2.使用循环结构，初始化外层数组元素
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];
            //3. 给数组的元素赋值
            //3.1 给数组每行的首末元素赋值为1
            yangHui[i][0] = yangHui[i][i] = 1;
            //3.2 给数组每行的非首末元素赋值
            //if(i >= 2){
                for(int j = 1;j < yangHui[i].length - 1;j++){ //j从每行的第2个元素开始，到倒数第2个元素结束
                    yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
                }
            //}

        }
        //遍历二维数组
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }


    }
}

五、案例五

案例说明

案例：复制、赋值

使用简单数组
(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,array[2]=2)。
(5)打印出array1。

思考：array1和array2是什么关系？
【answer】array1和array2是两个变量，共同指向了堆空间中的同一个数组结构。即二者的地址值相同。

拓展：修改题目，实现array2对array1数组的复制

代码实现（赋值）

public class ArrayExer04 {
    public static void main(String[] args) {
        //(1)创建一个名为ArrayExer04的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
        int[] array1,array2;
        //(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
        array1 = new int[]{2,3,5,7,11,13,17,19};
        //(3)显示array1的内容。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        //(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。
        array2 = array1;
        System.out.println();
        System.out.println(array1);
        System.out.println(array2);

        for (int i = 0; i < array2.length; i++) {
            if(i % 2 == 0){
                array2[i] = i;
            }
        }

        System.out.println();//换行
        //(5)打印出array1。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
    }
}

代码实现（复制）

public class ArrayExer04_1 {
    public static void main(String[] args) {
        //(1)创建一个名为ArrayExer04的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
        int[] array1,array2;
        //(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
        array1 = new int[]{2,3,5,7,11,13,17,19};
        //(3)显示array1的内容。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        //(4)复制array1数组给array2，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。
        array2 = new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }

        System.out.println();
        System.out.println(array1);
        System.out.println(array2);

        for (int i = 0; i < array2.length; i++) {
            if(i % 2 == 0){
                array2[i] = i;
            }
        }

        System.out.println();//换行
        //(5)打印出array1。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
    }
}

六、案例六

案例说明案例：
定义数组：int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};
如何实现数组元素的反转存储？你有几种方法。
代码实现1

public class ArrayExer05 {
    public static void main(String[] args) {
        int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //反转操作
        //方式1：
        for(int i = 0;i < arr.length/2;i++){
            //交互arr[i] 与 arr[arr.length - 1 - i]位置的元素
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }
}

代码实现2

public class ArrayExer05 {
    public static void main(String[] args) {
        int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //反转操作
        //方式2：
        for(int i = 0,j = arr.length - 1;i < j;i++,j--){
            //交互arr[i] 与 arr[j]位置的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

代码实现3

public class ArrayExer05 {
    public static void main(String[] args) {
        int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //反转操作

        //方式3：不推荐
        int[] newArr = new int[arr.length];
        for(int i = arr.length - 1;i >= 0;i--){
            newArr[arr.length - 1 - i] = arr[i];
        }

        arr = newArr;

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

七、案例七

案例说明一个数组，让数组的每个元素去除第一个元素，得到的商作为被除数所在位置的新值。
代码实现public class Test3 {
    public static void main(String[] args) {
        int[] arr = new int[]{12,43,65,3,-8,64,2};
        
//        for(int i = 0;i < arr.length;i++){
//            arr[i] = arr[i] / arr[0];
//        }
        for(int i = arr.length -1;i >= 0;i--){
            arr[i] = arr[i] / arr[0];
        }
        //遍历arr
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
    }
}

七、案例七

案例说明创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。
代码实现

public class Test4 {
    // 5-67 Math.random() * 63 + 5;
    @Test
    public void test1() {
        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
            arr[i] = (int) (Math.random() * 30) + 1;

            boolean flag = false;
            while (true) {
                for (int j = 0; j < i; j++) {
                    if (arr[i] == arr[j]) {
                        flag = true;
                        break;
                    }
                }
                if (flag) {
                    arr[i] = (int) (Math.random() * 30) + 1;
                    flag = false;
                    continue;
                }
                break;
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    //更优的方法
    @Test
    public void test2(){
        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
            arr[i] = (int) (Math.random() * 30) + 1;
            
                for (int j = 0; j < i; j++) {
                    if (arr[i] == arr[j]) {
                        i--;
                        break;
                    }
                }
            }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

八、案例八：回形数

案例说明

从键盘输入一个整数（1~20） ，则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。

例如： 输入数字2，则程序输出：

1 2

4 3

输入数字3，则程序输出：

1 2 3

8 9 4

7 6 5

输入数字4， 则程序输出：

1   2    3   4

12 13 14  5

11 16 15  6

10  9   8   7

代码实现一//方式1
public class RectangleTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个数字");
        int len = scanner.nextInt();
        int[][] arr = new int[len][len];
        
        int s = len * len;
        /*
         * k = 1:向右
         * k = 2:向下
         * k = 3:向左
         * k = 4:向上
         */
        int k = 1;
        int i = 0,j = 0;
        for(int m = 1;m <= s;m++){
            if(k == 1){
                if(j < len && arr[i][j] == 0){
                    arr[i][j++] = m;
                }else{
                    k = 2;
                    i++;  
                    j--;
                    m--;
                }
            }else if(k == 2){
                if(i < len && arr[i][j] == 0){
                    arr[i++][j] = m;
                }else{
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            }else if(k == 3){
                if(j >= 0 && arr[i][j] == 0){
                    arr[i][j--] = m;
                }else{
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
            }else if(k == 4){
                if(i >= 0 && arr[i][j] == 0){
                    arr[i--][j] = m;
                }else{
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }
        
        //遍历
        for(int m = 0;m < arr.length;m++){
            for(int n = 0;n < arr[m].length;n++){
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();
        }
    }
}
代码实现二

//方式2
/*
    01 02 03 04 05 06 07 
    24 25 26 27 28 29 08 
    23 40 41 42 43 30 09 
    22 39 48 49 44 31 10 
    21 38 47 46 45 32 11 
    20 37 36 35 34 33 12 
    19 18 17 16 15 14 13 
 */
public class RectangleTest1 {

    public static void main(String[] args) {
        int n = 7;
        int[][] arr = new int[n][n];
        
        int count = 0; //要显示的数据
        int maxX = n-1; //x轴的最大下标
        int maxY = n-1; //Y轴的最大下标
        int minX = 0; //x轴的最小下标
        int minY = 0; //Y轴的最小下标
        while(minX<=maxX) {
            for(int x=minX;x<=maxX;x++) {
                arr[minY][x] = ++count;
            }
            minY++;
            for(int y=minY;y<=maxY;y++) {
                arr[y][maxX] = ++count;
            }
            maxX--;
            for(int x=maxX;x>=minX;x--) {
                arr[maxY][x] = ++count;
            }
            maxY--;
            for(int y=maxY;y>=minY;y--) {
                arr[y][minX] = ++count;
            }
            minX++;
        }
        
        
        for(int i=0;i<arr.length;i++) {
            for(int j=0;j<arr.length;j++) {
                String space = (arr[i][j]+"").length()==1 ? "0":"";
                System.out.print(space+arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

编程学无止境
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java—数组中涉及的常见算法
小贺想改变
09-04 762
数组元素的赋值(杨辉三角、回形数等)，求数值型数组中元素的最大值、最小值、平均数、总和等，数组的复制、反转、查找(线性查找、二分法查找)，数组元素的排序算法
数组常见算法汇总
MrDAW的博客
07-22 1619
数组常见算法汇总 1、寻找数组中的最大值 | 最小值 ` public class max_min { public static void main(String[] args) { int[] nums = {10,20,30,40,33,22,11,8}; //1.创建一个变量，用于存储遍历数组发现的最大值 int n = nums[0]; for (int i = 1; i < nums.length; i++) {
数组常见算法
weixin_64975807的博客
03-05 2128
数组排序、数组有序和无序查找和数组旋转、乱序算法
Java数组常见算法
Sky529353的博客
04-04 1183
1.定义方法: int [] a = new int[10]; int [] b = new int[]{1,2,3,4,5};//动态初始化 int [] c = {1,2,3,4,5};//静态初始化 2.数组相关算法： 2.1冒泡排序 每次遍历，如果前一位大于后一位的话，就将前一位大的数字向后移动。最终实现将数组从小到大依次排序。 int [] c = {1,2,3,4,5,6,7,33,44,11,7,99,88}; int temp; for
数组的常见算法
weixin_62914558的博客
07-28 800
数组的创建与元素的赋值；数组的赋值与复制；数组的反转；数组中指定元素的查找：搜索、检索；数组的排序算法（冒泡算法）
【算法】数组常见算法
weixin_52811588的博客
08-29 731
数组的常见算法，使用C语言实现了移除元素，删除有序数组中的重复项，合并有序数组，旋转数组，供大家参考
数组常见算法比较
promiseend的博客
09-21 7884
1.选择排序基本思想： 选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件则交换元素。 算法示例： 如图，先将下标为0的数组元素分别与其他元素相比，23<45,不交换（从小到大排序），再比较23与6，交换……这样将23与其他元素比较后，下标为0的元素变成了6。再将下标为1的元素与下标为2，3，4，5的元素进行比较，经过5轮这样的比较后，就可完成排
C++算法题：关于数组的算法
feikudai8460的博客
05-08 896
1、问题描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 适用于严格递增的数组 求这个已经旋转过得数组的最小元素 //函数功能 ： 旋转数组的最小元素 //函数参数 ： pArray指向数组，len为数组长度 //返回值 ： 最小元素 int FindMin(int *pArray, int len)
数组常见算法代码总结
xzcxzc1q的博客
03-08 1599
数组常见算法代码总结:数组排序,无序数组查找,有序数组查找（二分），数组乱序，数组旋转
数组涉及的常见算法
chen2745213271的博客
09-19 381
1. 数组元素的赋值(杨辉三角、回形数等)2. 求数值型数组中元素的最大值、最小值、平均数、总和等 3. 数组的复制、反转、查找(线性查找、二分法查找)4. 数组元素的排序算法练习1定义一个int型的一维数组，包含10个元素，分别赋一些随机整数， 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。 要求：所有随机数都是两位数。数组中涉及到的常见算法：二分法查找算法 数组中涉及到的常见算法：排序算法排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为 {K1，K2，...
Java数组高级算法与Arrays类常见操作小结【排序、查找】
08-26
本文主要介绍了Java数组高级算法与Arrays类常见操作，结合实例形式总结分析了Java数组常见的排序算法、查找算法相关原理、实现与使用技巧。 一、冒泡排序 冒泡排序是一种简单且常用的排序算法。其原理是通过相邻...
JavaScript数组排序的六种常见算法总结
10-14
在JavaScript编程中，数组排序是一项常见的操作，本文将详细介绍六种常见的排序算法，它们分别是希尔排序、sort排序、桶排序、冒泡排序，以及另外两种未在内容中具体提及的排序算法：快速排序和选择排序。这些算法在...
代码随想录算法训练营day30
qq_56445436的博客
09-05 434
【代码】代码随想录算法训练营day30。
树状数组记录
volcan的博客
09-06 658
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 389
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 408
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
最新发布
mimo_mimo的博客
09-10 946
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
【Python 千题 —— 算法篇】寻找两个正序数组的中位数
繁依Fanyi的博客
09-07 1208
合并排序法：易于理解，但时间复杂度较高，适合小规模数据。双指针法：通过双指针合并数组，时间复杂度 O(m + n)，适合中等规模数据。二分查找法：通过二分查找，在较短数组上进行划分，时间复杂度为 O(log(min(m, n)))，是处理大规模数据的最佳选择。对于这种涉及高效搜索和排序的题目，掌握二分查找的应用至关重要。通过本题目，我们不仅能够提升对数组和中位数的理解，还能够学到如何优化时间复杂度，使算法在处理大规模数据时更加高效。
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 947
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
C语言数组删除算法解析
"这篇资源是关于C语言中数组删除算法的讲解，主要涉及如何从整型数组中删除特定元素，并提供了具体的算法步骤和注意事项。内容包括数组的基本概念、定义、存储方式、初始化以及访问方法，同时也提及了数组的查询、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程学无止境

你的鼓励是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值