数组与方法的应用

目录

引语

综合实战

题目一

题目二

例题源码

第一题源代码

 第二题源代码


引语

小伙伴们大家好啊,之前我们说了数组与方法的简单定义,那今天我举两个例子,给大家更深刻的去了解我们的方法与数组,更好的去实际应用。

 

综合实战

题目一

请先看题目要求

冒泡排序,首先实现如下的数组从小到大排序,再完成下面的需求。
        int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
        (1).反转上面的数组。请代码实现
        (2).复制上述数组,得到一个新的数组
        (3).使用线性查找,从上述数组中查找22是否存在。存在,返回所在位置的索引。不存在,输出提示信息。

        可以看到,题目有四个要求,这种情况我们首先可以想到用方法去实现他,因为这样可以让我们的代码更简洁,也可以让我们有更清晰的思路,不是一团乱
其次:题目无非就考了四种问题,冒泡,反转,复制数组到一个新的数组当中,查找返回索引,这种经典的问题。那么我们一个一个的说。
第一个,冒泡排序
要实现冒泡,就要先了解冒泡,冒泡是什么呢?
冒泡的原理:比较相邻的元素,如果一个元素比后一个元素大,就交换这两个元素的位置;  对每一对相邻元素做同样的工作,从第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
要实现数组中挨个比对,就不免用到循环,那么这里我就直接上代码

public static void buddleSort(int[] arr) {
        int temp;
        for (int i = arr.length - 1; i > 0; i--) {//控制有多少个元素参与冒泡
            for (int j = 0; j < i; j++) {//遍历数组
                if (arr[j] > arr[j + 1]) {//如果索引i处的值大于索引i+1处的值
                    temp = arr[j];//就把索引j处的值赋值给temp
                    arr[j] = arr[j+ 1];//索引j+1处的 值赋值给索引j
                    arr[j+1] = temp;//最后将temp中存储的j的值赋值给j+1,完成交换
                }
            }
        }
    }
第一个i表示的就是数组最后的索引值,每完成一次内循环,也就代表最大值已经冒泡到最后一个位置,所以i的值也应该相应的减少一位,即最后一位值变不再参与运算,依次类推。
if条件则表示数组中j值与j+1值依次比对,如果前一个数比后一个数大,那么久讲两数的位置交换,直到遇到比该数大的则停止。循环结束之后,冒泡排序则完成,那么这道题用代码可以写成如下
//返回值类型:void
    //参数:int[] arr
    public static void bubbleSort(int[] arr) {
        int temp = 0;
        //控制参与运算的元素递减,从最后一个下标递减
        for (int i = arr.length - 1; i > 0; i--) {
            //遍历
            for (int j = 0; j < i; j++) {
                //交换元素
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

    }
第二个:反转
反转便是将数组的每一对元素反过来。
这个完全就是一个元素位置对调,所以把索引对调也就OK。

//返回值类型:void
    //参数:int[] arr
    public static void reserveSort(int[] arr) {
        //定义一个临时变量
        int temp = 0;
        //参与运算的元素是一对一对的,所以只有一半
            for (int i = 0; i < arr.length / 2; i++) {
            temp = arr[i];
            //将反转的元素对调
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }
第三个:复制。
即我们需要定义一个新的数组,将原数组的值赋值给这个新数组。

 //返回值类型:int[]
    //参数: int[]arr
    public static int[] copySort(int[] arr) {
        //定义一个新数组brr
        int[] brr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            //复制
            brr[i] = arr[i];
        }
        return brr;
第四个:查找
查找我们并不陌生,要想实现查找数组的元素,那就是索引,只要找到索引,那么问题也就迎刃而解。

//返回值类型:int 类型的数。
    //参数:int类型的数组,int 类型的定义的查找的数。
    public static int findSort(int[] arr, int num) {
        //定义索引返回值
        int index = 0;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //如果要查找的数能在数组中找的,就返回其索引。
            if (num == arr[i]) {
                index = i;
                return index;
            }
        }
        //不存在,返回-1
        return -1;
    }
按照题目的要求,我们还应该给该题目的返回做一个提示,那么可以有一下操作:

 if (flag != -1) {//打印
            System.out.println("找到了,下标为" + flag);
        } else {
            System.out.println("你找的数不存在数组");
        }
    }
 

题目二

求一个3*3矩阵对角线元素之和,要求矩形里面的值为随机赋值
        看题目我们不难看出,题目有三个要求1.创建一个二维数组,长度为3,其一维数组长度也为3
                                       2.随机赋值
                                       3.找出对角线规律,求和
都是些简单地问题,那么如何找到对角线规律呢?
我们将它带到索引当中去看,因为说到底他是数组,并且他的数值小,只有5个,即i = 0,j=0;i=0,j=2;i=1,j=1;i=2,j=2;i=2,j=0。

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = r.nextInt(100);
                //矩形对应的\这个斜边的值
                if (i == j) {
                    sum += arr[i][j];
                    //矩形剩余的两个值
                } else if ((i == 0 && j == 2) || (i == 2 && j == 0)) {
                    sum +=arr[i][j];
                }
            }
        }
找出这个规律之后输出就可以啦!


好了,以上就是我所分享的经典例题,希望对大家有所帮助,大家可以在评论区互相探讨哈,共同进步,那么最后再给大家一道经典例题,我就不解释了哦。

例题源码

package com.company;


/*
        数组a:"1,7,9,11,13,15,17,19"
        数组b:"2,4,6,8,10"
        两个数组合并为数组c。
        总思想:1.先将两个数组拼接起来
        2.再用冒泡排序将其按顺序排列
        3.打印输出
*/
public class Merge {
    public static void main(String[] args) {
        int[] arr1 = {1, 7, 9, 11, 13, 15, 17, 19};
        int[] arr2 = {2, 4, 6, 8, 10};
        //定义第三个数组为前两个数组的长度之和
        int[] arr3 = new int[arr1.length + arr2.length];
        getNewArr(arr1, arr2, arr3);
        print(arr3);
    }

    public static void getNewArr(int[] arr1, int[] arr2, int[] arr3) {
        //将第一个数组的值依次赋值给第三个数组
        for (int i = 0; i < arr1.length; i++) {
            arr3[i] = arr1[i];
        }
        //定义一个索引自第一个数组长度位置起
        int thru = arr1.length;
        for (int i = 0; i < arr2.length; i++) {
            //将数组二的值赋值给它
            arr3[thru] = arr2[i];
            thru++;
        }
        //排序
        for (int i = arr3.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr3[j] > arr3[j + 1]) {
                    int temp = arr3[j];
                    arr3[j] = arr3[j + 1];
                    arr3[j + 1] = temp;
                }

            }
        }
    }

    public static void print(int[] arr3) {
        System.out.print("[");
        for (int i = 0; i < arr3.length; i++) {
            if (i == arr3.length - 1) {
                System.out.print(arr3[i]);
            } else {
                System.out.print(arr3[i] + ",");
            }
        }
        System.out.print("]");
    }
}

第一题源代码

package Homework;

import java.util.Scanner;

/*
7.冒泡排序,首先实现如下的数组从小到大排序,再完成下面的需求。
        int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
        (1).反转上面的数组。请代码实现
        (2).复制上述数组,得到一个新的数组
        (3).使用线性查找,从上述数组中查找22是否存在。存在,返回所在位置的索引。不存在,输出提示信息。
*/
public class Comprehensive {
    public static void main(String[] args) {
        //冒泡排序,首先实现如下的数组从小到大排序,再完成下面的需求。
        int[] arr = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
        bubbleSort(arr);
        printSort(arr);
        // (1).反转上面的数组。请代码实现
        reserveSort(arr);
        printSort(arr);
        // (2).复制上述数组,得到一个新的数组
        int[] brr = copySort(arr);
        printSort(brr);
        //使用线性查找,从上述数组中查找22是否存在。存在,返回所在位置的索引。不存在,输出提示信息。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的数:");
        int num = sc.nextInt();
        int flag = findSort(arr, num);
        if (flag != -1) {//打印
            System.out.println("找到了,下标为" + flag);
        } else {
            System.out.println("你找的数不存在数组");
        }
    }

    //返回值类型:int 类型的数。
    //参数:int类型的数组,int 类型的定义的查找的数。
    public static int findSort(int[] arr, int num) {
        //定义索引返回值
        int index = 0;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //如果要查找的数能在数组中找的,就返回其索引。
            if (num == arr[i]) {
                index = i;
                return index;
            }
        }
        //不存在,返回-1
        return -1;
    }

    //返回值类型:int[]
    //参数: int[]arr
    public static int[] copySort(int[] arr) {
        //定义一个新数组brr
        int[] brr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            //复制
            brr[i] = arr[i];
        }
        return brr;
    }

    //返回值类型:void
    //参数:int[] arr
    public static void reserveSort(int[] arr) {
        //定义一个临时变量
        int temp = 0;
        //参与运算的元素是一对一对的,所以只有一半
        for (int i = 0; i < arr.length / 2; i++) {
            temp = arr[i];
            //将反转的元素对调
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }

    //返回值类型:void
    //参数:int[] arr
    public static void bubbleSort(int[] arr) {
        int temp = 0;
        //控制参与运算的元素递减,从最后一个下标递减
        for (int i = arr.length - 1; i > 0; i--) {
            //遍历
            for (int j = 0; j < i; j++) {
                //交换元素
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

    }

    //输出方法
    public static void printSort(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }

        }
        System.out.println("]");
    }

 第二题源代码

package Homework;
//求一个3*3矩阵对角线元素之和,要求矩形里面的值为随机赋值

import java.util.Random;

public class Matrix {
    public static void main(String[] args) {
        //初始化
        int[][] arr = new int[3][3];
        Random r = new Random();
        int sum = 0;
        //二维数组的遍历赋值
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = r.nextInt(100);
                //矩形对应的\这个斜边的值
                if (i == j) {
                    sum += arr[i][j];
                    //矩形剩余的两个值
                } else if ((i == 0 && j == 2) || (i == 2 && j == 0)) {
                    sum +=arr[i][j];
                }
            }
        }//可以输出随机生成的数组,验证答案
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");

            }
            System.out.println( );
            }

        System.out.println("对角线和为:" + sum);

    }
}

        

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

空山新雨后~

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

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

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

打赏作者

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

抵扣说明:

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

余额充值