6.数组元素操作

最新推荐文章于 2024-01-20 20:58:58 发布
最新推荐文章于 2024-01-20 20:58:58 发布
阅读量410 收藏
点赞数
分类专栏： java基础 文章标签： java 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44385781/article/details/120596968
版权 
1.需求：定义一个方法，找出int数组中，最大值的索引下标
[1,2,23,5,6,7,8]  打印出来2
2.需求：定义一个方法，找出int数组中，最小值的索引下标
3.需求：定义一个方法，在指定的int数组中找出指定的数据的下标
[1,2,3,4,5,78,7,8,9]
4. 在一个数组中，找出所有指定数据的下标位置 【难】
5. 完成一个方法，替换掉数组中所有元素之为0的元素，替换为指定元素
6. 完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】
7. 完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】
8.冒泡排序
9.选择排序
9. 找出数组中最大的元素，放到下标为0的位置

10. 在上一道题的基础上，不考虑下标为0的元素。
    找出数组中最大的元素，放到下标为1的位置

需求：定义一个方法，找出int数组中，最大值的索引下标

package com.qfedu.a_array;

/**
 * 定义一个方法，找出int数组中，最大值的索引下标
 */
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 17, 9, 2, 4, 6, 17, 10};
        int i = maxIndexInArray(arr);
        System.out.println(i);
    }
    /*
    * 方法的分析
    *   方法名字：maxIndexInArray   主要是方法的功能
    *   形式参数：
    *       这里需要一个int类型的数组  int[]  array
    *   返回值类型：
    *      这里需要的是得到最大值的索引的下标，就是int类型的数据
    *
    * */

    /**
     * 找出指定数组的最大值的索引下标
     * @param array 给定的数组，就是从这个数组中找
     * @return  最大值的下标
     */

    public static int maxIndexInArray(int[] array) {
        //1.假设下标为0的时候是最大值
        int maxIndex = 0;
        //2.利用循环进行两两比较，数据从1的开始
        for (int i = 1; i < array.length; i++) {
            //3.判断下标为maxIndex元素如果小于下标为i的元素，保存i的值到maxIndex
            if (array[maxIndex] < array[i]) {
                maxIndex = i;
            }
        }
        return maxIndex;
    }
    /*
    * 代码执行流程：{1, 3, 5, 17, 9, 2, 4, 6, 17, 10};
    *   当i = 1 1<10 array[0] < array[1]  1<3 true maxIndex = 1  i=2
    *       i = 2 2<10 array[1] < array[2] 3<5 true maxIndex=2 i=3
    * 3<10  arry[2] < array[3] 5<17 true maxIndex=3 i=4
    * 4<10 array[3] < array[4] 17<9false i=5  maxIndex=3
    * 5<10 array[3] <array[5] 17<2false i=6 maxIndex=3
    * ...
    *
    *
    * */
}

需求：定义一个方法，找出int数组中，最小值的索引下标

package com.qfedu.a_array;

/**
 * 定义一个方法，找出int数组中，最大值的索引下标
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {89, 3, 5, 17, 9, 2, 4, 6, 17, 10};
        int i = minIndexInArray(arr);
        System.out.println(i);
    }
    /*
     * 方法的分析
     *   方法名字：maxIndexInArray   主要是方法的功能
     *   形式参数：
     *       这里需要一个int类型的数组  int[]  array
     *   返回值类型：
     *      这里需要的是得到最小值的索引的下标，就是int类型的数据
     *
     * */

    /**
     * 找出指定数组的最小值的索引下标
     * @param array 给定的数组，就是从这个数组中找
     * @return  最大值的下标
     */

    public static int minIndexInArray(int[] array) {
        //1.假设下标为0的时候是最小值
        int minIndex = 0;
        //2.利用循环进行两两比较，数据从1的开始
        for (int i = 1; i < array.length; i++) {
            //3.判断下标为maxIndex元素如果大于下标为i的元素，保存i的值到maxIndex
            if (array[minIndex] > array[i]) {
                minIndex = i;
            }
        }
        return minIndex;
    }

}

定义一个方法，在指定的int数组中找出指定的数据的下标

package com.qfedu.a_array;

public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 5, 6, 7, 8, 9};
        int i = indexOf(arr, 6);
        System.out.println(i);
    }
    /*
    * 定义一个方法，在指定的int数组中找出指定的数据的下标
    * 找到返回值的下标：0~arr.length-1
    * 找不到：-1
    * 方法的分析：
    *   方法名字:
    *       indexOf
    *   形式参数列表：
    *       第一个参数：指定的数组  int[] array
    *       第二个参数：int find
    *   返回值：
    *       int类型的数据
    * */
    public static int indexOf(int[] array, int find) {
        //1.假设没有返回的一个变量值
        int index = -1;
        //2.利用for循环，两两进行比较，找出指定数据在数组中下标的位置，并保存在index
        for (int i = 0; i < array.length; i++) {
            //3.下标为i的元素就是指定的find数据，保存到index
            if(array[i] == find) {
                index = i;
                //如果找到数据，就终止循环
                break;
            }
        }
        return index;
    }
    /*
    {2, 3, 4, 5, 6, 7, 8, 9};
    * 分析：i =0 0<8  true arra[i] == find  array[0]==6 i=1
    i=1  1<8  true array[i]==find  array[1] ==6  false
    i=2  2<8  true array[i]==find  array[2] ==6  false
    i=3  3<8  true array[i]==find  array[3] ==6  false
    i=4  4<8  true array[i]==find  array[4] ==6  true  index = 4

    * */
}

在一个数组中，找出所有指定数据的下标位置 【难】

package com.qfedu.a_array;

public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,1,3,5,1,3,5};
        int[] indexes = new int[arr.length];
        int allIndexes = findAllIndexes(arr, indexes, 5);
        System.out.println(allIndexes);//3
        for (int i = 0; i < allIndexes; i++) {
            System.out.println(indexes[i]);
        }
    }
    /*
    * 在一个数组中，找出所有指定数据的下标位置 【难】
    * [1,2,3,1,2,3,1,2,3]
    * 方法分析
    *   方法名字：
    *       findAllIndexes
    *   形式参数列表：
    *       1.在哪个数组中进行查询  int[] array
    *       2.要查询的数据
    *       3.需要另外一个数组，用来存储保存找到的数据的下标
    *           a.该数组是int类型的数据
    *           b.数组的容量？和需要查询数组的长度保持一致
    *    返回值类型：
    *       不考虑数组，
    *       int:返回值找到数据的个数
    * */
    public static int findAllIndexes(int[] arr, int[] indexes, int find) {
        //1.判断参数的额合法性
        if(arr == null || indexes == null || arr.length == 0 ||
                indexes.length == 0 || arr.length  < indexes.length) {
            System.out.println("参数有误");
            return 0;
        }
        //2.定义一个变量进行计数，因为你要找个数
        int count = 0;
        //3.使用for循环，遍历目标数组 arr, 使用if判断，找到目标元素
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == find){
                //计数  count++
                indexes[count++] = i;
            }
        }
        return count;
    }
    /*
    {1,3,5,1,3,5,1,3,5}
    * i=0 0<9   arr[0] == 5false
    i=1 1<9  arr[1]==5 false
    i=2 2<9 arr[2] ==5 true
    indexes[0] = 2
    i=3 3<9 arr[3] ==5 false
    i=4 4<9 arr[4] ==5 false
    i=5 5<9 arr[5] ==5 true
    indexes[1] = 5
    i=6 6<9 arr[6] ==5 false
    i=7 7<9 arr[7] ==5 false
    i=8 8<9 arr[8] ==5 true
    indexes[2]=8
    *
    * */
}

完成一个方法，替换掉数组中所有元素之为0的元素，替换为指定元素

package com.qfedu.a_array;

import java.util.Arrays;

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

        int[] array = {1,2,3,4,5,0,0,0,0,0};
        boolean replace = replace(array, 6);
        System.out.println(replace);
        //Arrays是java内置的一个类，这个类下面有一个内置的方法叫toString()
        //Arrays.toString(array):将一个数组转为字符串输出
        System.out.println(Arrays.toString(array));
        
    }
    //完成一个方法，替换掉数组中所有元素之为0的元素，替换为指定元素
    /*
    * 方法分析：
    *       方法名:replace
    *       形式参数:
    *           需要被替换的数组
    *           需要替换成什么样的一个int类型的数据
    *       返回值：
    *           不推荐使用void,这个是黑盒的方法。不知道里面报错没有报错
    *            给与当前方法一个监控
    *             boolean方法替换成功以后返回true,失败为false
    *             你怎么知道true,怎么知道是false
    *             这个玩意还能失败？
    *               1.如果数组的容量为0会失败
    *               2.数组的名字是一个引用数据（new的），保存的内存地址不能为null

    * */
    public static boolean replace(int[] array, int newNumber){
        //1.参数的合法性
        if(null == array || array.length == 0){
            System.out.println("参数不合法");
            //告诉调用者，方法执行失败了
            return false;

        }
        //2.开始使用for循环和if进行替换
        for (int i = 0; i < array.length; i++) {
            if (0 == array[i]){
                array[i] = newNumber;
            }
        }
        return true;
    }
}

完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】s

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,7,9,11,13,15,17,19};
        boolean remove = remove(arr, 17);
        System.out.println(remove);
        System.out.println(Arrays.toString(arr));
    }
    /*
    * 分析方法：
    *       完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】
    *       数组int[] arr = {1,3,5,7,9,11,13,15,17,19};
    *       删除以后，需要在数组的末尾补上0
    *       方法的名字：
    *           remove
    *       形式参数：
    *           1.删除数据的目标数组
    *           2.指定能够删除数据的下标位置
    *       返回值类型:
    *           boolean 删除成功返回true, 删除失败返回false
    *           什么情况是失败：
    *               1、数组的容量为0
    *               2、数组中保存的地址null
    *               3、给与的删除的下标非法下标
    *
    *
    * */

    /**
     *
     * @param arr
     * @param index
     * @return
     */
    public  static boolean remove (int[] arr, int index) {
        //1.参数合法性的判断
        if(arr == null || arr.length == 0 || index < 0 || index > arr.length-1) {
            System.out.println("参数不合法");
            return false;
        }
        /*
        * 使用for循环进行操作
        * 这个地方使用的是  arr[i] = arr[i+1]
        * */
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = 0;
        return true;
    }
}

完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo7 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,7,9,11,13,15,17,0};
        boolean add = add(arr, 27, 250);
        System.out.println(add);
        System.out.println(Arrays.toString(arr));
    }
    /*
    * 分析方法 完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】
    *
    *   方法名字:
    *       add
    *   形式参数：
    *       1.目标数组   int[] arr
    *       2.制定下标的位置  int index
    *       3.添加的数据  int  number
    *   返回值：
    *       boolean  成功返回true, 添加失败返回false
    *       什么情况会添加失败：
    *           1、数组的容量为0
    *           2.数组保存的位置为null
    *           3.给与的添加下标是一个非法的下标
    * */
    public static boolean add (int[] arr, int index, int number) {
        //1.参数合法性的判断
        if(arr == null || arr.length == 0 || index < 0 || index > arr.length - 1) {
            System.out.println("参数不合法");
            return false;
        }
        //移动数组中元素，从最后一位开始挪
        for (int i = arr.length - 1; i > index ; i--) {
            arr[i] = arr[i - 1];
            /*
            * index=5   arr.length =10
            * arr[9] = arr[8];i--  i=8
            * arr[8]=arr[7]i-- i=7
            * arr[7]=arr[6] i-- i=6
            * arr[6]=arr[5] i-- i=5
            * false
            * */
        }
        arr[index] = number;
        return true;

    }
}

冒泡排序和选择排序

冒泡排序：从小到大

​ 他是重复的走访要排序的元素，依次比较相邻的两个元素，如果顺序错误了，两个位置交换一下。

走访工作重复进行，直到没有两个相邻的元素需要交换了，就证明排序完成了。

越小的元素慢慢排在前面。

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo8 {
    public static void main(String[] args) {
        //依次比较两个相邻的元素，将小的数放在前面，大的数放在后面，
        //第一次：首先比较第一个第二个  2  57
        //第二次:57 36 ===> 36  57  ==> temp
        //第三次:57和78比  57 78
        //第四次：78  和3   3  78====>  2  36  57  3  78
        // ===>2   36  3  57  78
        //===>2   3  36  57  78
        //==>
        int[] arr = {2,57,36,78,3};
        int temp;//临时存储的变量
        for (int i = 0; i < arr.length - 1; i++) {//
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    //只有这种情况才交换
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

        }

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

选择排序

第一次从下标为0 的开始，下标为0 的这个数与后面的n-1个数。找出最小的那个放在下标为0的位置。

第二次从下标为诶1的开始，查询剩余的最小值。放在下标为1的位置。

依次类推直到完成排序。

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        int[] arr = {32,57,36,78,3};
        //第一次拿32索引0  和 57,36,78,3

        for (int i = 0; i < arr.length - 1; i++) {//需要进行多少次的选择
            //使用一个变量，当成最小值下标，临时索引变量
            int index = i;
            //找到极值的下标位置
            //{32,57,36,78,3}
            //arr[0] >  arr[1]
            for (int j = i + 1; j < arr.length; j++) {//一直在找最小值的索引
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            //交换位置
            if (index != i) {
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;

            }
        /*
        * i =0 0<4  index=0    j = 1  1<5   arr[0] > arr[1] false
        *                       j=2  2<5   arr[0] > arr[2] false
        *                       j=3 3<5  arr[0]>arr[3]  false
        *                       j=4 4<5  arr[0]> arr[4] true  现在的index=4
        *                       交换位置int temp = arr[4]  ==>3
        *                       arr[4] = arr[0]32
        *                       arr[0] = 3
        *{3,57,36,78,32};
        *i =1 1<4  index=1    j = 2  2<5   arr[1] > arr[2] true  index = 2
        *
         *                       j=3 3<5   arr[2] > arr[3] false
         *                       j=4 4<5  arr[2]>arr[4]  true  index=4
         *
         *                       交换位置int temp = arr[4]  ==>32
         *                       arr[4] = arr[1] 57
         *                       arr[1] = 32
         **{3,32,36,78,57};
         *i =2 2<4  index=2    j = 3  3<5   arr[2] > arr[3] false
         *
         *                       j=4 4<5   arr[2] > arr[4] false
         *                      不用交换
         * {3,32,36,78,57};
         **i =3 3<4  index=3    j = 4  4<5   arr[3] > arr[4] true index=4
         *                      j=5 5<5false
         *                       交换 int temp = arr[4]57
         *                          arr[4] = arr[3]78
         *                          arr[3] = temp  57
         *
         *
        * */

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

找出数组中最大的元素，放到下标为0的位置

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {1, 3,4,78,56,26};
        boolean b = function1(arr);
        System.out.println(b);
        System.out.println(Arrays.toString(arr));
    }
    /*
    *
    * 找出数组中最大的元素，放到下标为0的位置
    * 方法名字：
    *   function1
    *  形式参数：
    *    int[]  数组
    * 返回值：
    *   true  或者false
    * */
    public static boolean function1(int[] arr) {
        if(arr == null || arr.length == 0) {
            System.out.println("参数不合法");
            return false;
        }
        //1.找出数组中最大值的下标
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[index] < arr[i]) {
                index = i;
            }
        }
        //2.最大值和索引为0的进行交换一下位置。如果刚好下标为0的元素是最大值
        if(index != 0) {
            int temp = arr[index];
            arr[index] = arr[0];
            arr[0] = temp;
        }
        return true;
    }
}

今天的代码敲会为止，给你两周时间。

作业：

题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？   


//这是一个菲波拉契数列问题



题目：判断101-200之间有多少个素数，并输出所有素数。 
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。




题目：打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。


题目：将一个正整数分解质因数。例如：输入90,打印出90=233*5。   
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：   


(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。   

(2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。 

  
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。





题目：输入两个正整数m和n，求其最大公约数和最小公倍数。   /*在循环中，只要除数不等于0，用较大数除以较小的数，将小的一个数作为下一轮循环的大数，取得的余数作为下一轮循环的较小的数，如此循环直到较小的数的值为0，返回较大的数，此数即为最大公约数，最小公倍数为两数之积除以最大公约数。 /



题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。





题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？



题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润，求应发放奖金总数？


题目：输入某年某月某日，判断这一天是这一年的第几天？




https://blog.csdn.net/wufaliang003/article/details/85557260
孤狼程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于数组的一部分内容
qq_40873772的博客
05-25 110
一维数组： ○1数组：1.相同数据类型的集合 2.一块连续内存 ○2一维数组的定义： 1）int [] arr = {1,2,3}; 2）int [] arr = new int []{1,2,3}; 3）int [] arr = new int [3]; ○3数据访问：arr [0] = 99;arr [1] = 100; ○4遍历： 1）for(int index = 0;index <...
js数组一部分方法
yin_mkajs的博客
04-16 205
数组方法 数组方法 1.push—在数组的尾部添加一个元素（改变原始数组） var arr=[1,2,3,4,5]; arr.push(6); console.log(arr); //[1,2,3,4,5,6] 2.unshift—在数组的头部添加一个元素（改变原始数组） var arr=[1,2,3,4,5]; arr.unshift(0) console.log(arr);//[0,1,2,3,4,5] 3.pop—在数组的尾部删除一个元
数组的常用方法以及数组元素的一些运算
m0_73849466的博客
10-28 898
数组的常用方法，筛选数组最大值，偶数和，反转
数组元素移动
axiqia的专栏
03-25 4686
描述 试设计一个算法，将数组a中的元素a[0]至a[n-1]循环右移k位，并要求只用一个元素大小的附加存储，元素移动或交换次数为O(n)。   输入 先输入一个大于1且小于100的正整数n，再输入n个整数存到数组a中，最后输入一个小于n正整数k，   输出 循环移动k位后输出。   输入样例 5 2 6 15 39 5 3   输出样例 15 39 5 2
初学者系列：数组元素循环移动问题。
Leviathan的博客
12-25 389
对于初学编程的同学来说，数组是一个让人头疼的东西，但是对于编程来说，数组可是一个好东西。熟练运用后，可以解决很多有趣的问题。这里我给大家讲一下初学者都会遇到的一个编程题：数组循环右移问题。多数同学可能会考虑不到一些特殊的情况，例如移动的长度大于数组原来的长度，又或是在处理数组边界问题上苦苦思索，今天咱就给大家一一解开疑惑。`在这里插入代码片` 首先输入给出输入长度(L)和移动长度(s)。我们不能...
8.数组课堂案例.rar
11-12
3. **数组操作**：包括读取、修改和插入元素。读取元素通过索引完成，如`numbers[0]`；修改元素则直接赋值，如`numbers[0] = 10`；插入元素通常涉及数组扩容或创建新数组，因数组长度固定，直接插入可能导致溢出。 ...
5.数组作业答案1
08-08
这些知识点涵盖了Java编程中数组的基本操作，包括声明、初始化、遍历、查找特定元素，以及与用户交互等。此外，还涉及到了随机数的生成和统计分析，这些都是Java编程的基础技能，对于学习和理解Java程序设计至关重要...
1. 数组-连续排布的格子1
08-03
这种一致性使得通过索引（下标）访问数组元素变得极其快速，时间复杂度仅为O(1)，即无论数组大小如何，访问任意元素只需要常量时间。 内存连续性的概念主要涉及的是进程的虚拟内存空间，而不是物理内存空间。操作...
数组元素操作
07-09
数组元素的操作2015年2月12日 - 淘宝SOA框架dubbo学习(7)--异步调用:直接上代码: 1、服务提供端及客户端共享代码 package com.alibaba.dubbo.demo; public interface D...
PHP多维数组元素操作类的方法
12-18
我的框架里面一个多维数组元素操作类，主要用于读取数组中配置数据，可以通过字符串节点的方式：a.b.c 来获取和设置元素，以及多维数组的覆盖，有需求的可以参考下吧！ <?php /** * Created by PhpStorm. * ...
7-19 数组元素移动 (25 分)
汪汪的博客
10-07 8210
7-19 数组元素移动 (25 分) 完成数组元素的移动功能：假设数组有n个元素，输入一个数x，把数组的第x个位置的元素先保存起来，然后把x+1到n的元素，依次往前移一位，最后将原来的第x个位置的元素放在数组的最后。 重复若干次这样的移动，得到最后的结果。 输入格式: 第一行包括一个整数n（1<=n<=100），表示数组元素的个数。 第二行输入n个数组元素，均为整数，用空格隔开。...
C ++ 数组案例【指定下标添加元素】
最新发布
iot_Ming的博客
01-20 482
例如：int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 0};此数组容量为 10 有效元素为 9 下标为 9 的位置仅占位使用。我们的指定下标为 5 插入的元素为 10 效果如下。提供一个数组其中 0 只为占位使用。在指定的的下标位置添加指定元素。
学习笔记：数组的定义、添加、遍历及判断
acflair的专栏
11-02 141
// 数组创建 var arr = new Array();//最好不用这种方法 arr[0] = 10; arr[1] = 100; arr[2] = 33; //遍历数组 for (var i in arr) { console.log(arr[i]) } //用这种方法较好 var arr1 = []; //添加数组元素 arr1.push("300"); arr1.push("500"); for (var i in arr) { conso...
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引
weixin_45383034的博客
12-07 3027
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引
实现在数组的中的指定位置插入元素，使其他的元素向后移动，（JS实现）
坐看云起时_雨宣
02-09 6040
相信很多人都接触过拖曳排序，很屌的样子，他里边就用到了一个数组实施插入元素后移的算法，算法不难，挺简单的，给大家顺便贴出来。 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> </head> <body&...
java中请设计一个方法，将一个int数组arr中指定的两个下标之间的元素删除【牛皮级别-很难】
weixin_56310628的博客
06-22 893
/** *java中删除下标之间的元素，百分之95都是含头不含尾。即{ ) */ public class _04Exercises { public static void main(String[] args) { //请设计一个方法，将一个int数组arr中指定的两个下标之间的元素删除 int[] arr = new int[]{1,2,3,4,5,6}; int[] expurgate = expurgate(arr, 1, 3); // 调用方法 .
MATLAB 索引和修改数组
小嗷犬的博客
10-23 2299
如果我们在索引时只提供一个值，那它会被认为是行索引，列索引则默认是。到 最后一个元素，即行向量。行所有列的元素，即行向量。行最后一列的值，即数值。行所有列的元素，即矩阵。行的所有列都会被赋值为。行的值会被赋值为与第。用作索引时，冒号运算符。
数组元素的删除 【vector】
banshen0201的博客
03-23 1733
7-5 数组元素的删除（5 分） 完成数组元素的移动功能：假设数组有n个元素，输入一个数x，把数组的第x个位置的元素删除了，后面的元素依次前进一个位置。 重复若干次这样的删除，得到最后的结果。 输入格式: 第一行包括一个整数n（1<=n<=100），表示数组元素的个数。 第二行输入n个数组元素，均为整数，用空格隔开。 第三行输入一个数k...
设计一个整型数组操作库，要求设计用户界面。 功能： 1. 数组输入 2. 数组排序 3.元素插入 4. 元素查找 5. 元素删除 6. 数组输出 7.输出指定位置元素 8. 对指定个数的数组元素求和 9.书写实验报告
03-27
6. 数组输出：数组元素为：（输出数组元素） 7. 输出指定位置元素：请输入要查询的位置：（用户输入位置） 该位置的元素为：（输出元素） 8. 对指定个数的数组元素求和：请输入要求和的个数：（用户输入个数） ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值