2020年7月29日 数组操作练习

Posted douyunpeng

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2020年7月29日 数组操作练习相关的知识,希望对你有一定的参考价值。

/*
1、数组的练习
用一个数组存储本组学员的成绩,并遍历显示
(1)其中学员的人数从键盘输入
(2)学员的成绩从键盘输入
*/
class Test08_Exer4{
    public static void main(String[] args){
        /*
        步骤:
        1、先确定人数,从键盘输入
        2、声明并创建数组,用来存储成绩
        3、确定每一个成绩:为每一个元素赋值
        4、遍历显示
        */
        
        //1、先确定人数,从键盘输入
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入本组的人数:");
        int count = input.nextInt();
        
        //2、声明并创建数组,用来存储成绩
        //int[] scores = new int[长度];
        int[] scores = new int[count];
        
        //3、确定每一个成绩:为每一个元素赋值
        for(int i=0; i<count; i++){
            System.out.print("请输入第"+ (i+1) + "个学员的成绩:");
            //为元素赋值:为谁赋值,就把谁写在=的左边
            scores[i] = input.nextInt();//用键盘输入的值为元素赋值
        }
        
        //4、遍历显示
        System.out.println("本组学员的成绩如下:");
        for(int i=0; i<scores.length; i++){
            System.out.print(scores[i]+"	");
        }
    }
}
/*
2、数组的练习
用一个数组存储26个英文字母的小写形式,
并遍历显示
‘a‘->‘A’
*/
class Test09_Exer5{
    public static void main(String[] args){
        //用一个数组存储26个英文字母的小写形式
        //(1)声明并创建数组
        char[] letters = new char[26];
        
        //(2)为元素赋值,即把‘a‘,‘b‘等存储到letters数组中
        //因为有规律,所以用循环赋值
        for(int i=0; i<letters.length; i++){
            letters[i] = (char)(‘a‘ + i);
        }
        
        //(3)显示结果
        //‘a‘->‘A’
        //->左边就是元素的值,右边是根据元素的值,算出来的
        //‘a‘的编码值是97,‘A‘编码值为65,差32
        //‘b‘的编码值是98,‘B‘编码值为66,差32
        for(int i=0; i<letters.length; i++){
            System.out.println(letters[i] +"->" + (char)(letters[i]-32));
        }
    }
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
*/
class Test11_FindMax{
    public static void main(String[] args){
        int[] array = {4,2,6,8,1};
        
        //在数组中找最大值
        //类似于:猴子掰玉米
        //先假设第一个最大,然后与后面的元素一一比较,如果有比手上还大,就修改手上的玉米
        
        //(1)//先假设第一个元素最大
        int max = array[0];
        //(2)用max中的值,与后面的元素一一比较,如果有比max的值还大,就修改max的值
        //这里i=1的原因,max与[1,长度-1]的元素比较就可以了,不用再与[0]元素进行比较
        for(int i=1; i<array.length; i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        
        System.out.println("最大值是:" + max);
    }
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,9};
        
        //最小值及其下标
        //(1)假设第一个元素最小
        int min = array[0];
        int index = 0;
        
        //(2)用min与后面的元素一一比较
        for(int i=1; i<array.length; i++){
            if(array[i] < min){
                min = array[i];
                index = i;
            }
        }
        System.out.println("最小值是:" + min);
        System.out.println("最小值的下标是:" + index);
    }
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex_2{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,9};
        
        //最小值及其下标
        //(1)假设第一个元素最小
        int minIndex = 0;//array[minIndex]就是最小值
        
        //(2)用min与后面的元素一一比较
        for(int i=1; i<array.length; i++){
            if(array[i] < array[minIndex]){
                minIndex = i;
            }
        }
        System.out.println("最小值是:" + array[minIndex]);
        System.out.println("最小值的下标是:" + minIndex);
    }
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex_3{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,-7};
        
        //找出最小值,及其下标,但是如果最小值有两个或多个
        /*
        (1)先找出最小值
        (2)找出所有最小值的下标
        */
        //(1)先找出最小值
        int min = array[0];
        for(int i=1; i<array.length; i++){
            if(array[i] < min){
                min = array[i];
            }
        }
        System.out.println("最小值:" + min);
        
        //(2)找出所有最小值的下标
        System.out.println("最小值的下标有:");
        for(int i=0; i<array.length; i++){
            if(array[i] == min){
                System.out.print("[" + i + "]	");
            }
        }
        
    }
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
*/
class Test13_SumAndAvg{
    public static void main(String[] args){
        /*
        有一组学员的成绩存储在数组中,统计总分和平均分
        */
        int[] scores = {78,89,56,99,100};
        
        //求总分
        int sum = 0;
        for(int i=0; i<scores.length; i++){
            sum += scores[i];
        }
        
        //求平均值
        double avg = (double)sum / scores.length;
        System.out.println("总分:" + sum);
        System.out.println("人数:" + scores.length);
        System.out.println("平均分:" + avg);
        
    }
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse_2{
    public static void main(String[] args){
        //有一个数组,存储26个字母
        //‘A‘~‘Z‘
        char[] letters = new char[26];
        for(int i=0; i<letters.length; i++){
            letters[i] = (char)(‘A‘ + i);
        }
        
        //需求:要反转整个数组
        //原来letters[0]中存储的是‘A‘-->现在letters[0]中存储的是‘Z‘
        //...
        //原来letters[25]中存储的是‘Z‘-->现在letters[25]中存储的是‘A‘
        //方式二:首尾交换
        //问题1:交换几次   次数 = 长度/2  例如:6个元素交换3次,5个元素交换2次
        /*
        这个i可以用作下标,同时循环的次数,可以表示交换的次数
        */
        for(int i=0; i<letters.length/2; i++){
            //问题2:谁和谁交换
            //letters[0] ~ letters[25]
            //letters[1] ~ letters[24]
            //..
            //首尾交换
            //letters[i] ~ letters[长度-1 - i]
            
            //问题3:如何交换
            //借助第三个变量
            char temp = letters[i];
            letters[i] = letters[letters.length-1-i];
            letters[letters.length-1-i] = temp;
        }
        
        //显示结果
        for(int i=0; i<letters.length; i++){
            System.out.println(letters[i]);
        }
    }
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
    例如:从原数组中截取一部分
(3)复制一个比原来的长的
    例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_01{
    public static void main(String[] args){
        //(1)复制一个和原来一样的数组,长度和元素
        int[] arr = {1,2,3,4,5};
        
        /*
        (1)创建一个新数组,和原来的数组一样
        */
        int[] newArr = new int[arr.length];
        /*
        (2)复制元素
        */
        for(int i=0; i<newArr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(3)遍历新数组
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
    例如:从原数组中截取一部分
(3)复制一个比原来的长的
    例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_02{
    public static void main(String[] args){
        //(1)复制一个比原来数组短的
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        
        //复制原来的数组的一部分,来构成新数组,例如:[2]~[8]
        int start = 2;
        int end = 8;
        /*
        (1)创建新数组,新数组的长度 = 8-2
        */
        int[] newArr = new int[end-start+1];
        
        //(2)复制元素
        for(int i=0; i<newArr.length; i++){
            /*
            newArr[0] = arr[2] = arr[start+0];
            newArr[1] = arr[3] = arr[start+1];
            ...
            */
            //newArr[i] = 值;
            newArr[i] = arr[start+i];
        }
        
        //(3)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
    例如:从原数组中截取一部分
(3)复制一个比原来的长的
    例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_03{
    public static void main(String[] args){
        //(3)复制一个比原来的长的
        int[] arr = {1,2,3,4,5};
        
        //需求:新增加了几个数据,需要存储,此时需要把数组进行扩容
        //(1)创建一个新数组,例如:新数组的长度为原来的2倍
        int[] newArr = new int[arr.length*2];
        
        //(2)复制元素
        for(int i=0; i<arr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(3)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
    例如:从原数组中截取一部分
(3)复制一个比原来的长的
    例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_04{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        
        /*
        复制一个新数组,新数组的长度由键盘输入,可能和原来一样,可能比原来的短,可能比原来的长
        */
        /*
        (1)从键盘输入新数组的长度
        */
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入新数组的长度:");
        int len = input.nextInt();
        
        //(2)创建新数组
        int[] newArr = new int[len];
        
        //(3)复制元素,这里都是从原数组的[0]开始复制
        //i<arr.length && i<newArr.length保证newArr[i] = arr[i];左右两边都不越界
        for(int i=0; i<arr.length && i<newArr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(4)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}

 

以上是关于2020年7月29日 数组操作练习的主要内容,如果未能解决你的问题,请参考以下文章

pycharm 激活码 2020.亲测有效(2020年7月7日)

2020年7月3日 查找算法 代码

2022-03-29

11月7日 数组练习

2020年9月全国计算机等级考试C语言冲刺练习(9月13日)

2017年8月7日 星期一 --出埃及记 Exodus 28:29