算法-基础（一）数组基本操作 和 静态方法（后面编写算法的时候会用到）

最新推荐文章于 2023-09-28 15:36:14 发布
最新推荐文章于 2023-09-28 15:36:14 发布
阅读量333 收藏
点赞数
分类专栏： 算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzb1386097/article/details/79566906
版权

由于后面编写算法涉及一些基础语法，我这边先复习复习有错误望指导。




public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}
public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}

这边最后一个用了二维数组，二维数组就是一堆数组，二维数组可以长度不一致是参差不齐的，但是二维数组有默认规定i i代表行 j代表列，创建的时候要在类型之后制定行数列数，它的图形结构如下（自己画的大家将就着看）：


public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}

静态方法: 

public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}

/**
 * 静态方法小样类
 * @addPerson ： hzb 2018-3-122
 */
public class StaticDemo {
    public static  void main(String[] args){

    }
    /**
     * 计算一个绝对值
     */
    public static int abs(int x){
        if(x < 0){
            return -x;
        }else {
            return x;
        }
    }
    /**
     * 计算一个浮点数的绝对值
     */
    public static double abs1(double x){
        if(x < 0.0){
            return -x;
        }else {
            return x;
        }
    }

    /**
     * 计算一个是否素数
     */
    public static boolean abs2(int x){
        if(x < 2){
            return false;
        }
        for(int i =2;i*i<=x;i++){
            if(x % i==0){
                return false;
            }

        }
        return true;
    }

    /**
     * 计算平方根
     * 注意这个地方用的是迭代的方法你们可以搜索一下牛顿迭代法
     */
    public static double abs3(double x){
        if(x < 0){
            return Double.NaN;
        }
        double err = 1e-15;
        double t = x;
        while(Math.abs(t-x/t)>err*t){
            t= (x/t+t)/2.0;

        }
        return t;
    }

  

}
                 
public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}

                                                                                                                                                                    有写错指出望指出 wavesape@126.com
                                                                                                                                                                    addPerson ：hzb 2018-3-12 22:29:28 
public class ArrayDemo {
    /**
     * 数组操作小样类
     * @addPerson ： 黄昭滨 2018-3-12
     * @param args
     */
    public static void main(String[] args){

    }

    /**
     * 找出数组中最大数 并返回
     */
    public double arrayIsMax(){
        //定义一个数组
        double[] unkonwn = new double[10];

        //先把第一个假设为最大值
        double isMax = unkonwn[0];
        for(int i=1;i<unkonwn.length;i++){
            if(unkonwn[i]>isMax){
                //如果当前这个索引的值大于假设最大值 就直接赋值过去
                isMax = unkonwn[i];
            }
        }
        return isMax;
    }

    /**
     * 计算元素的平均值
     */
    public double arrayIsAverage() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //定义数组累加值字段
        double sum = 0.0;

        for (int i = 0; i < N; i++) {
            sum += unkonwn[i];
        }
        return sum/N;
    }



    /**
     * 复制数组
     */
    public double[] arrayIsCopy() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;
        //创建一个被复制的数组一样的壳
        double[] copyArray = new double[N];

        for (int i = 0; i < N; i++) {
            copyArray[i] = unkonwn[i];
        }
        return copyArray;
    }

    /**
     * 颠倒数组元素顺序
     */
    public double[] arrayIsFlip() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        for (int i = 0; i < N/2; i++) {
           double temp = unkonwn[i];
           unkonwn[i] = unkonwn[N-1-i];
           unkonwn[N-1-i] = temp;
        }
        return unkonwn;
    }

    /**
     * 矩阵相乘
     */
    public double[] arrayIsMatrix() {
        //定义一个数组
        double[] unkonwn = new double[10];
        //获取数组长度
        int N = unkonwn.length;

        //创建类似矩阵的双数组结构
        double[][] x = new double[N][N];

        for (int i = 0; i < N; i++) {
            for(int j =0;j<N;j++){
             //开始计算i行和j列的点乘
                for(int k =0;k<N;k++){
                    x[i][j] +=x[i][k]*x[k][j];
                }
            }
        }
        return unkonwn;
    }


}
WavesApe_Bin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Array类中的静态方法
洋葱专栏-有灵魂的程序员
04-13 834
1，sort排序 public class Array { public static void main(String[] args) { // array的各种类 int[] array1 = {1,4,5,7,8,4,9,0}; java.util.Arrays.sort(array1);//直接对数组排序 for(int i=0;i { System.out
数组Array和操作集合Collections的静态方法；
AerfaGo的博客
09-07 468
// Arrays类；静态方法；—直接是类名.方法 int []n={2,5,8,3,9}; //升序排序 Arrays.sort(n); //以字符串形式输出数组； System.out.println(Arrays.toString(n)); //查找数组中元素的下标；
Arrays静态方法
zycxnanwang的博客
08-05 788
Arrays静态方法 在java的编程实践中，在很多地方会用到Arrays的静态方法，总结一下，以便翻阅sort方法版本一 sort(T [] a);一般数字按大小排序， 字母按照字典序排序(小写字母大于大写字母) 版本二 sort(T[] a,Comparator<? super T> c) 可以自己自定义按照那种标准进行排序, 通过实现Comparator接口的compare函数实
第二章---四.Array的静态方法
a13686343384的博客
12-15 740
Array.isArray(); 判断给入的内容是不是数组 1.Array.from() 将迭代器对象转换为数组 可以将迭代器对象转换为数组 ES5就可以使用 var arr=Array.prototype.slice.call(divs); var arr=Array.prototype.concat.apply([],divs); console.log(arr) 例：HTMLCollection argumehts NodeList Set Ma.
Arrays类常用静态方法
西北的博客
02-26 408
文章目录1、sort2、asList3、toString4、copyOf5、copyOfRange6、fill7、mismatch8、binarySearch 1、sort sort​(int[] a) 将指定数组按升序排序 int a[]={21,12,90,1,3,2,88}; System.out.println("排序前："+Arrays.toString(a)); Arrays.sort(a); System.out.println("排序后："+A
Java面试宝典-经典
03-28
3、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，如“我ABC”，4，应该截取“我AB”，输入“我ABC汉DEF”，6，应该输出“我ABC”，而不是“我ABC+汉...
易语言程序免安装版下载
04-07
6) 修改MYSQL支持库跨静态编译的EXE和DLL传递连接句柄和记录集句柄无效的BUG（改动较大，可能会产生兼容性问题，我们已经仔细测试，也请使用到此库的用户帮助我们多多测试，以便及早发现问题，谢谢） 7) 其它修改 ...
超级有影响力霸气的Java面试题大全文档
07-18
忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。 28、short s1 = 1; s1 =...
数组的静态方法
weixin_48333440的博客
12-07 241
判断变量是不是数组 Array.isArray（数组名）——返回布尔值 arr（数组名）instanceof Array ——返回布尔值判断是否为数组 arr.constructor===Array——判断是不是数组 将非数组列表转换为数组Array.from() 获取过来的dom类型为html。。。 需要对其转换成数组以后方可使用数组的方法 对象列表无法转换为数组 Array.from_1=function(list){ // return [].slice.call(list);//将
JavaScript数组的静态方法
前端开发小白9527
04-21 1323
1 数组的静态方法 Es5 ：Array.isArray Es6 : Array.form Array.of // Es5 判断一个基本类型是否是数组类型 不能用来检测引用类型 let arr = []; let state = Array.isArray(arr) // state: true Array.form // Es6 Array.form(arrayLike,[callback]) // 作用是把一个伪数组转换为...
数组基本操作，三种基础算法演示
m0_55637617的博客
05-18 228
数组基本操作，三种基础算法演示一、数组定义方法二、数组包括的数据类型三、获取数组长度，读取某索引赋值四、数组遍历五、数组切片六、数组替换七、数组删除八、数组追加元素九、向函数传数组参数十、排序算法 一、数组定义方法 方法一： 数组名=（value0 value1 value2 …） 方法二: 数组名=（[0]=value [1]=value [2]=value …) 方法三： 列表名=“value0 value1 value2 …” 数组名=（$列表名） 方法四： 数组名[0]=“value” 数组名[1]
Arrays类静态方法
weixin_43774841的博客
06-12 409
静态Arrays类
数组基本操作
ShiXiao0121的博客
12-23 489
数组 一、数组定义方法 (10 20 40 60 90 ) 0 1 2 3 4 数组下标最大长度：n-1 方法一： 数组名=（value0 value1 value2 ...） 方法二： 数组名=([0]=11 [1]=22 [2]=33 [3]=44 ...) 方法三： 列表名="value0 value1 value2 ..." 数组名=($列表名) 方法四： 数组名[0]="value" 数组名[1]="value" 数组名[2]="value" 数组名[3]="value" 二
操作数组的基础算法
迷心兔的博客
11-25 132
# coding=utf-8 import doctest import collections from collections.abc import Iterable from timeit import timeit # 操作一维数组中多余的数值（限制值为num）【适用短数组】 def array_limit_count_01(array, num): # 时间复杂度O（n ^ 2） ...
【JavaScript 19】Array对象 构造函数 静态方法 实例方法
最新发布
Zane Boy's blogs
09-28 149
Array是 JavaScript 的原生对象，同时也是一个构造函数，可以用它生成新的数组Array()构造函数的参数2，表示生成一个两个成员的数组，每个位置都是空值如果没有使用new关键字，运行结果也是一样的考虑到语义性，以及与其他构造函数用法保持一致，建议总是加上newArray()构造函数有一个很大的缺陷，不同的参数个数会导致不一致的行为可以看到，Array()作为构造函数，行为很不一致因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。
数据结构与算法2--数组常见操作
脚步不能达到的地方，眼光可以达到；眼光不能达到的地方，精神可以飞到
11-07 726
数据结构与算法2--数组常见操作   数组是最常见也是我们使用最多的数据结构了，它是一块连续的内存空间，以下标来描述空间的位置，C++中int arr[len]表示的的数组一旦配置后大小就无法改变，vector&lt;int&gt; v表示的数组可以动态增加。以下是笔者根据数组的特性和平时使用情况完成的一些基本功能，后续将根据使用情况再增加相关功能。   1、功能 00-打印数组 01-...
数据结构：数组的基本使用
阿河的博客
09-13 979
数组的介绍： 所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。 数组是用于储存多个相同类型数据的集合。 ...
c语言中，计数排序算法如何将累计数组转化为结果数组，请编写一段代码
04-03
计数排序的累计数组记录了每个元素在排序后的位置，最后需要将累计数组转化为结果数组。 以下是一个简单的示例代码： ```c void count_sort(int arr[], int n) { int max_val = arr[0]; for (int i = 1; i ; i++...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值