数组

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量165 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/jocelynD-9/p/11268132.html
版权

目录

  1. 数组中的最大值和最小值
  2. 找出数组中第二大的数
  3. 最大子数组之和
  4. 数组中重复最多的元素
  5. 数组中两两相加等于20的组合种数
  6. 一个数组循环右移k位
  7. 找出数组中第k个最小的数
  8. 数组中只出现一次的元素
  9. 数组中唯一的重复元素
  10. 递归方法求一个整数数组的最大元素
  11. 数对之差的最大值
  12. .绝对值最小的数
  13. 数组中两个元素的最小距离
  14. 指定数字在数组中第一次出现的位置
  15. 数组的两个子有序段进行合并
  16. 计算两个有序整型数组的交集
  17. 判断数组中数值是否连续相邻
  18. 求解数组中反序对的个数
  19. 最小三元组距离

 

 

1.数组中的最大值和最小值

寻找方法：

  1. 问题分解法
  2. 取单元素法
  3. 取双元素法
  4. 数组元素移位法
  5. 分治法

Java代码：

//方法3
public class minandmax {
    static int Max,Min;
    
    public static void getMaxandMin(int[] arr) {
        Max = arr[0];
        Min = arr[0];
        int len = arr.length;
        for(int i=1;i<len-1;i=i+2) {
            if(arr[i]>arr[i+1]) {
                if(arr[i]>Max) 
                    Max=arr[i];
                if(arr[i+1]<Min) 
                    Min=arr[i+1];
            }
            if(arr[i]<arr[i+1]) {
                if(arr[i+1]>Max) 
                    Max=arr[i+1];
                if(arr[i]<Min) 
                    Min=arr[i];
            }
            
            if(i+1>len) {
                if(arr[i]>Max)
                    Max=arr[i];
                if(arr[i]<Min) 
                    Min=arr[i];
            }
        }
    }
    
    public static void main(String[] args) {
        int[] A= {7,3,19,40,4,7,1};
        getMaxandMin(A);
        System.out.println("max="+Max);
        System.out.println("min="+Min);
    }

}

 

2.找出数组中第二大的数

public class secondMax {
    public static void main(String[] args) {
        int[] A= {7,3,19,40,4,7,1};
        System.out.println(getsecondMax(A));
    }

    private static int getsecondMax(int[] arr) {
        // TODO Auto-generated method stub
        int count = arr.length;
        int maxnum = arr[0];
        int secmax = Integer.MIN_VALUE;
        for(int i=1;i<count;i++) {
            if(arr[i]>maxnum) {
                secmax = maxnum;
                maxnum = arr[i];
            }
            else {
                if(arr[i]>secmax) {
                    secmax = arr[i];
                }
            }
        }
        return secmax;
    }

}

 

3.最大子数组之和 

public class maxsubArr {
    public static void main(String[] args) {
        int[] A= {1,-2,4,8,-4,7,-1,-5};
        System.out.println(getmaxsubArr1(A));
        System.out.println(getmaxsubArr2(A));
        System.out.println(getmaxsubArr3(A));
        System.out.println("max = " + getmaxsubArr4(A));
        System.out.println("begin = " + begin +" , end = " + end);
    }    
    
    //方法一：蛮力法
    public static int getmaxsubArr1(int[] arr) {
        // TODO Auto-generated method stub
        int len = arr.length;
        int sum,maxsum = 0,i,j,k;
        for(i=0;i<len;i++) {
            for(j=i;j<len;j++) {
                sum = 0;
                for(k=i;k<j;k++)
                    sum+=arr[k];
                if(sum>maxsum)
                    maxsum=sum;
            }
        }
        return maxsum;
    }
    
    //方法二：重复利用已计算的子数组和
    public static int getmaxsubArr2(int[] arr) {
        // TODO Auto-generated method stub
        int len = arr.length;
        int maxsum = Integer.MIN_VALUE;
        for(int i=0;i<len;i++) {
            int sum=0;
            for(int j=i;j<len;j++) {
                sum+=arr[j];
                if(sum>maxsum)
                    maxsum=sum;
            }
        }
        return maxsum;
    }
    
    //方法三：动态规划法
    public static int getmaxsubArr3(int[] arr) {
        // TODO Auto-generated method stub
        int len = arr.length;
        int End[]=new int[len];
        int All[]=new int[len];
        End[len-1]=All[len-1]=arr[len-1];
        End[0]=All[0]=arr[0];
        for(int i=1;i<len;++i) {
            End[i] = max(End[i-1]+arr[i],arr[i]);
            All[i] = max(End[i],All[i-1]);
        }
        return All[len-1];
    }

    public static int max(int m, int n) {
        // TODO Auto-generated method stub
        return m>n?m:n;
    }
    
    //方法四：优化动态规划法
    private static int begin=0;
    private static int end=0;
    public static int getmaxsubArr4(int[] arr) {
        // TODO Auto-generated method stub
        int maxsum = Integer.MIN_VALUE;
        int sum = 0;
        int start = 0;
        for(int i=0;i<arr.length;i++) {
            if(sum<0) {
                sum = arr[i];
                start = i;
            }
            else {
                sum+=arr[i];
            }
            if(sum>maxsum) {
                maxsum=sum;
                begin = arr[start];
                end = arr[i];
                
            }
        }
        return maxsum;
    }
}

 

4.数组中重复最多的元素 

import java.util.*;

public class findmaxfrequent {
    public static void main(String[] args) {
        int[] A= {1,5,4,2,4,4,5,4,5,5,6,6,6,6,6};
        int num = maxfrequentnum(A);
        System.out.println("maxfrequentnum = "+num);
    }

    public static int maxfrequentnum(int[] arr) {
        // TODO Auto-generated method stub
        int result = 0;
        int len = arr.length;
        if(len==0)
            return Integer.MIN_VALUE;
        //记录次数
        Map<Integer,Integer>m=new HashMap<Integer,Integer>();
        for(int i=0;i<len;i++) {
            if(m.containsKey(arr[i])) {
                m.put(arr[i], m.get(arr[i])+1);
            }
            else
                m.put(arr[i],1);
        }
        
        //找出出现最多次数的元素
        int maxfre = 0;
        Iterator iter = m.entrySet().iterator();//迭代器，map类型的必须先转换成集合类型才能使用迭代器去获取元素
        //使用获取键值
        while(iter.hasNext()) {
            Map.Entry entry = (Map.Entry)iter.next();
            int key = (Integer)entry.getKey();
            int val = (Integer)entry.getValue();
            if(val>maxfre) {
                result = key;
                maxfre = val;
            }
        }
        System.out.println("maxfre = "+maxfre);
        return result;
    }
}

 

5.数组中两两相加等于20的组合种数

import java.util.*;

public class findsum {
    public static void main(String[] args) {
        int[] A= {1,7,17,2,6,3,14,10};
        int n = 20;
        FindSum1(A,n);
        System.out.println();
        FindSum2(A,n);
    }

    //蛮力法
    public static void FindSum1(int[] arr, int n) {
        // TODO Auto-generated method stub
        int len = arr.length;
        for(int i=0;i<len;i++) {
            for(int j=i+1;j<len;j++) {
                if(arr[i]+arr[j]==n) 
                    System.out.println(arr[i]+","+arr[j]);
            }
        }
    }
    
    //排序法
    public static void FindSum2(int[] arr, int n) {
        // TODO Auto-generated method stub
        Arrays.sort(arr);
        int begin = 0;
        int end = arr.length-1;
        while(begin<end) {
            if(arr[begin]+arr[end]<n)
                begin++;
            else if(arr[begin]+arr[end]>n)
                end--;
            else {
                System.out.println(arr[begin]+","+arr[end]);
                begin++;
                end--;
            }
        }
        
    }

}

 

 6.一个数组循环右移k位

public class torightk {
    public static void main(String[] args) {
        int[] A= {1,7,17,2,6,3,14,10};
        int n = 2;
        for(int i=0;i<A.length;i++) {
            System.out.print(A[i]+" ");
        }
        System.out.println();
        toRightk(A,n);
        for(int i=0;i<A.length;i++) {
            System.out.print(A[i]+" ");
        }
    }
    
    //三次逆序
    public static void toRightk(int[] a, int k) {
        // TODO Auto-generated method stub
        int len = a.length;
        k = k % len;
        reverse(a,len-k,len-1);
        reverse(a,0,len-k-1);
        reverse(a,0,len-1);
    }

    public static void reverse(int[] a, int i, int j) {
        // TODO Auto-generated method stub
        for(;i<j;i++,j--) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

}

 

7.找出数组中第k个最小的数

public class kminandmax {
    public static void main(String[] args) {
        int[] A= {1,7,17,2,6,3,14,10};
        int n = 2;
        int kmin = findkMin(A,n);
        int kmax = findkMax(A,n);
        System.out.println("数组中第"+n+"小的元素为："+kmin);
        System.out.println("数组中第"+n+"大的元素为："+kmax);
    }

    //剪枝发
    public static int findkMin(int[] a, int k) {
        // TODO Auto-generated method stub
        if(a==null||a.length<k)
            return Integer.MIN_VALUE;
        return sort(a,0,a.length-1,k);        
    }
    
    public static int findkMax(int[] a, int k) {
        // TODO Auto-generated method stub
        if(a==null||a.length<k)
            return Integer.MIN_VALUE;
        k = a.length-k;
        return sort(a,0,a.length-1,k);        
    }
    
    public static int sort(int array[],int low,int high,int k){
        int i,j;
        int index;
        if(low>=high)
            return Integer.MIN_VALUE;
        i=low+1;
        j=high;
        index=array[i];
        while(i<j){
            while(i<j&&array[j]>=index)
                j--;
            if(i<j){
                array[i++]=array[j];
            }
            while(i<j&&array[i]<index)
                i++;
            if(i<j)
                array[j--]=array[i];
        }
        array[i]=index;
        if(i+1==k)
            return index;
        else if(i+1>k)
            return sort(array,low,i-1,k);    
        else
            return sort(array,i+1,high,k);
    }
}

 

8.数组中只出现一次的元素

public class onetimenum {
    public static void main(String[] args) {
        int[] A= {1,5,4,2,4,5,2,5,5,6,6,6,6};
        int[] B= {1,2,1,2,4,2,4,4,1,3};
        System.out.println("只出现一次的元素： "+findnum1(A));
        int num = findnum2(B);
        System.out.println("只出现一次的元素： "+num);
    }    

    //一个整数数组里除了一个数字以外，其他数字都出现两次。
    public static int findnum1(int[] a) {
        // TODO Auto-generated method stub
        int len=a.length;
        int num=a[0];
        for(int i=1;i<len;++i) 
            num^=a[i];
        return num;
    }
    //一个整数数组里除了一个数字以外，其他数字都出现两次以上。
    public static int findnum2(int[] a) {
        // TODO Auto-generated method stub
        int len=a.length;
        int[] bitCount=new int[32];
        for(int i=0;i<len;i++)
            for(int j=0;j<32;j++)
                bitCount[j]+=((a[i]>>j)&1);
        for(int i=0;i<len;i++)
            System.out.print(bitCount[i]);
        int appearone = 0;
        for(int i=0;i<32;i++) {
            if(bitCount[i]%3!=0)
                appearone+=(1<<i);
        }
        return appearone;
    }
}

 

9.数组中唯一的重复元素

public class 唯一的重复元素 {
    public static void main(String[] args) {
        int[] A= {1,2,3,4,5,6,7,4};
        System.out.println(onerepeatNum1(A));
        System.out.println(onerepeatNum2(A));
    }

    //求合法
    public static int onerepeatNum1(int[] a) {
        // TODO Auto-generated method stub
        int len=a.length;
        int tmp1 = 0;
        int tmp2 = 0;
        for(int i=0;i<len;i++) {
            tmp1 += i;
            tmp2 += a[i];
        }
        int num = tmp2-tmp1;
        if(num>=len)
            return Integer.MIN_VALUE;
        return num; 
    }
    
    //异或法X^X=0 0^X=X
    public static int onerepeatNum2(int[] a) {
        // TODO Auto-generated method stub
        int len=a.length;
        int tmp1 = 0;
        for(int i=0;i<len;i++) {
            tmp1 ^= a[i];
        }
        for(int i=0;i<len;i++) {
            tmp1 ^= i;
        }        
        if(tmp1>=len)
            return Integer.MIN_VALUE;
        return tmp1; 
    }    
}

 

10.递归方法求一个整数数组的最大元素

public class 数组的最大元素_递归 {
    public static void main(String[] args) {
        数组的最大元素_递归 t =new 数组的最大元素_递归();
        int[] num= {0,16,2,3,4,5,10,7,8,9};
        System.out.println(t.findmax(num, 0));        
    }

    public int findmax(int[] num, int i) {
        // TODO Auto-generated method stub
        int len = num.length-i;
        if(len==1) 
            return num[i];
        else {
            return max(num[i],findmax(num,i+1));
        }
    }

    private int max(int i, int j) {
        // TODO Auto-generated method stub
        return i>j?i:j;
    }

}

 

11.数对之差的最大值

public class 数对之差的最大值 {
    public static void main(String[] args) {
        int[] num= {0,16,2,3,4,5,10,7,8,1};
        System.out.println(getMax(num));
    }

    public static int max(int m,int n){
        return m>n?m:n;
    }

    public static int getMax(int[] a){
        int len=a.length;
        if(a==null||len<=1)
            return Integer.MIN_VALUE;
        int diff=0;
        int max=a[0];
        for(int i=1;i<len;i++){
            diff=max(diff,max-a[i]);
            max=max(max,a[i]);
        }
        return diff;
    }
}

 

12.绝对值最小的数

public class 绝对值最小的数 {
    public static int getMinAbs(int[] arr){
        int len=arr.length;
        if(arr==null||len<1)
            return Integer.MIN_VALUE;
        int min=Integer.MAX_VALUE;
        for(int i=0;i<len;i++){
            min=getMin(min,Math.abs(arr[i]));
        }
        for(int i=0;i<len;i++){
            if(Math.abs(arr[i])==min)
                return arr[i];
        }
        return Integer.MIN_VALUE;

    }
    public static int getMin(int m,int n){
        return m<n?m:n;
    }

    public static void main(String[] args) {
        int[] num= {10,5,2,3,4,5,10,15,22,50};
        System.out.println(getMinAbs(num));
    }
}

 

13.数组中两个元素的最小距离

public class 两个元素的最小距离 {
    public static int minDistance(int[] arr,int n1,int n2){
        int len=arr.length;
        if(arr==null||len<2)
            return Integer.MIN_VALUE;
        int n1_index=-1;
        int n2_index=-1;
        int minDis=Integer.MIN_VALUE+1;
        for(int i=0;i<len;i++){
            if(arr[i]==n1){
                n1_index=i;
                if(n2_index>=0)
                    minDis=getMin(Math.abs(minDis),Math.abs(n1_index-n2_index));
            }
            if(arr[i]==n2){
                n2_index=i;
                if(n1_index>=0){
                    minDis=getMin(Math.abs(minDis),Math.abs(n1_index-n2_index));
                }
            }
        }
        return minDis;
    }

    public static int getMin(int n,int m){
        return m<n?m:n;
    }

    public static void main(String[] args) {
        int[] num= {4,5,6,4,7,4,6,4,7,8,5,6,4,1,10,8};
        System.out.println(minDistance(num,4,8));
    }
}

 

14.指定数字在数组中第一次出现的位置

public class 第一次出现的位置 {
    public static int firstTime(int[] arr,int n){
        if (arr==null)
            return -1;
        int index=-1;
        for(int i=arr.length-1;i>=0;i--){
            if(arr[i]==n)
                index=i+1;
        }
        return index;
    }
    public static void main(String[] args) {
        int[] num= {3,4,5,6,5,6,7,8,9,8};
        System.out.println(firstTime(num,6));
    }
}

 

15.数组的两个子有序段进行合并

public class 两个子有序段进行合并 {
    public static void findMid(int[] a,int mid ){
        int len=a.length;
        int tmp;
        for(int i=mid;i<len-1;i++){
            if(a[i+1]<a[i]){
                tmp=a[i];
                a[i]=a[i+1];
                a[i+1]=tmp;
            }
        }
    }
    public static void sort(int a[],int mid){
        int tmp;
        for(int i=0;i<mid;i++){
            if(a[mid]<a[i]){
                tmp=a[i];
                a[i]=a[mid];
                a[mid]=tmp;
                findMid(a,mid);
            }
        }
    }
    public static void main(String[] args) {
        int[] num= {1,5,6,7,9,2,4,8,10,13,14};
        sort(num,5);
        for(int i=0;i<num.length;i++)
            System.out.print(num[i]+" ");
    }
}

 

16.计算两个有序整型数组的交集

public class 两个有序整型数组的交集 {
    public static void findMixed(int a[],int b[]){
        ArrayList<Integer> list=new ArrayList<Integer>();
        int i=0,j=0;
        int len1=a.length;
        int len2=b.length;
        while(i<len1&&j<len2){
            if (a[i]==b[j]){
                list.add(a[i]);
                i++;
                j++;
            }
            else if (a[i]<b[j])
                i++;
            else
                j++;
        }
        for(int n:list)
            System.out.print(n+" ");
    }
    public static void main(String[] args) {
        int[] a= {0,1,2,3,4};
        int[] b={1,3,5,7,9};
        findMixed(a,b);

    }

}

 

17.判断数组中数值是否连续相邻

public class 数值是否连续相邻 {
    public static Boolean isCountinue(int[] arr){
        int len=arr.length;
        int min=-1,max=-1;
        for (int i=0;i<len;i++){
            if(arr[i]!=0){
                if(min>arr[i]||-1==min)
                    min=arr[i];
                if(max<arr[i]||-1==max)
                    max=arr[i];
            }
        }
        if(max-min>len-1)
            return false;
        else
            return true;
    }

    public static void main(String[] args) {
        int[] num= {0,5,4,9,3};
        int[] num1={8,7,5,0,6};
        System.out.println(isCountinue(num));
        System.out.println(isCountinue(num1));
    }

}

 

18.求解数组中反序对的个数

public class 反序对的个数 {
    public static int reverse(int a[]) {
        int count = 0;
        int len = a.length;
        for (int i = 0; i < len; i++) {
            for (int j = i; j < len; j++) {
                if (a[i] > a[j]) {
                    count++;
                    System.out.println(a[i]+","+a[j]);
                }
            }
        }
        return count;
    }



    public static void main(String[] args) {
        int[] A = {1, 7, 17, 2, 6, 3, 14, 10};
        System.out.println(reverse(A));

    }
}

 

19.最小三元组距离

public class 最小三元组距离 {
    public static int min(int a,int b,int c){
        int min=a<b?a:b;
        min=min<c?min:c;
        return min;
    }
    public static int max(int a, int b, int c){
        int max=a>b?a:b;
        max=max>c?max:c;
        return max;
    }
    public static int minDistance(int a[],int b[],int c[]){
        int alen=a.length;
        int blen=b.length;
        int clen=c.length;
        int curDis=0;
        int min=0;
        int minDis=Integer.MAX_VALUE;
        int i=0,j=0,k=0;
        while(true){
            curDis=max(Math.abs(a[i]-b[j]),Math.abs(a[i]-c[k]),Math.abs(b[j]-c[k]));
            if(curDis<minDis)
                minDis=curDis;
            min=min(a[i],b[j],c[k]);
            if(min==a[i]){
                if(++i>=alen)
                    break;
            }
            else if(min==b[j]){
                if(++j>=blen)
                    break;
            }
            else{
                if(++k>=clen)
                    break;
            }
        }
        
        return minDis;
    }
    public static void main(String[] args) {
        int[] num1= {3,4,5,7};
        int[] num2={10,12,14,15,17};
        int[] num3={20,21,23,24,37,30};
        System.out.println(minDistance(num1,num2,num3));
    }
}

 

转载于:https://www.cnblogs.com/jocelynD-9/p/11268132.html

XMQ2006
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言总结（一维数组、二维数组、字符数组和字符串）
csuft20164442的博客
01-23 12万+
C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 数组是构造数据类型之一 数组： 有序数据的集合,用数组名标识 元素： 属同一数据类型,用数组名和下标确定 一维数组 一维数组的定义 定义方式： 例： int a[6] 一维数组的引用 1、数组...
字符数组
JiaoXin327的博客
07-20 9143
字符数组 用来存放字符数据的数组是字符数组。字符数组中的每一个元素存放一个字符，其定义和使用方法与其他类型的数据基本相似。 1.1字符数组的定义和使用 字符数组的定义与其他类型的数组类似，标准形式如下： Char 数组名 【常量表达式】 例如： Char array [5]; Array[0]=‘h’； Array[1]=‘e’； Array[2]=‘l’； Array[3]=‘l’； Array...
数组指针和指针数组
mick_hu的博客
09-17 14万+
首先，理解一下数组指针和指针数组这两个名词： “数组指针”和“指针数组”，只要在名词中间加上“的”字，就知道中心了—— 数组的指针：是一个指针，什么样的指针呢？指向数组的指针。 指针的数组：是一个数组，什么样的数组呢？装着指针的数组。 然后，需要明确一个优先级顺序：()>[]>*，所以： (*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长...
c语言—数组详解(建议收藏)
热门推荐
Welcome to my blog.
07-06 15万+
文章目录一、一维数组1.一维数组的创建和初始化(1).数组的创建(2).数组的初始化2.一维数组的使用3.一维数组在内存中的存储二、二维数组1.二维数组的创建和初始化(1).二维数组的创建(2).二维数组的初始化2.二维数组的使用3.二维数组在内存中的存储三、数组作为函数参数1.一维数组2.二维数组四、数组指针和指针数组1.指针数组2.数组指针 一、一维数组 1.一维数组的创建和初始化 (1).数组的创建 数组是一组相同类型元素的集合。 数组的创建方式： type_t arr_name [const
js数组常用方法
夏天的博客
03-27 9万+
js数组常用方法还挺多的，如果面试官问你这道题可不要只回答几个哟，那是会扣分的！下面是一篇详细的js数组教程文章
Java数组
qq_63762763的博客
03-27 4万+
一. Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二.Java数组02 1.数组的声明与创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: ``··dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用
C语言数组详解
cw412524的博客
09-25 2万+
C语言数组详解，干货满满！
嵌套数组
singhwong
01-02 8133
要注意多维数组和嵌套数组二者之间的区别，嵌套数组也叫数组的数组，或者交错数组。通过以下方式来声明变量： int[3][2] arr; 就是数组中的每个元素也是数组，也就是数组里面也包含数组。如： //嵌套数组 char[][] ccs = new char[][] { new char[]{'a','b'}, new char[]{'c','d'},
Java数组详解
王梦杰_MengJie
03-03 1万+
数组是相同类型数据的有序集合、数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成，其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。
shell数组详解
运维@小兵的博客
03-05 2万+
参考书籍：《Linux Shell核心编程指南》 概述 数组是Shell的一种特殊变量，是一组数据的集合，里面的每个数据被称为一个数组元素。 当前Bash仅支持一维索引数组和关联数组，Bash对数组的大小没有限制。 定义数组 索引数组 第一种方法 array1[0]=a array1[1]=b array1[2]=c 这会得到一个包含三个元素的数组array1 第二种方法 array2=(a b c) 元素之间以空格隔开 处理数组 直接获取元素的值及数组的信息 获取单个元素的值 echo ${array
数组_matlab数组_
10-02
在MATLAB中，数组是一种非常基础且重要的数据结构，它允许我们存储和处理大量数值数据。MATLAB数组的使用广泛，涵盖了科学计算、数据分析、图像处理等众多领域。本资料包着重介绍了MATLAB中的数组计算，包括数组的...
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
js多维数组转一维数组
06-16
js基础代码实现
详解C++中的一维数组和二维数组
09-03
【C++一维数组】 C++中的一维数组是一种存储同类型数据的连续内存空间，可以看作是具有固定大小的线性集合。数组的定义通常遵循以下格式： ```cpp 类型标识符 数组名[常量表达式]; ``` 例如： ```cpp int a[10]; ...
配置Java开发环境
Broken_x的博客
07-10 1600
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 439
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 559
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 301
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值