Java中数组的使用（第二篇）

Java中数组的使用（第二篇）

• 筛选求出2-100的所有素数
• 帅选法是在2-100中先去掉2的倍数，再去掉3的倍数，依次类推，最后剩下的就是素数了
• 注意：2是最小的素数，不能去掉

/**
 * 筛选求出2-100的所有素数
 * 帅选法是在2-100中先去掉2的倍数，再去掉3的倍数，依次类推，最后剩下的就是素数了
 * 注意：2是最小的素数，不能去掉
 */
public class PrimeNumber {
    public static void main(String[] args){
        int [] number = new int [100] ;
        for(int j=0; j<number.length; j++){
            number[j] = j ;
        }

        for(int i=2; i<number.length; i++){
            for(int j=0; j<100; j++){
                if(number[j] % i == 0){ //筛选法
                    if(j == i){
                        continue ;
                    }
                    else{
                        number[j] = 0 ;
                    }
                }
            }
        }
        for(int j=2; j<number.length; j++){
            if(number[j] != 0){
                System.out.print( number[j] + " ") ;
            }
        }
    }
}

• 对于两个一维数组list1和list2长度相同，写一个方法判断两个数组元素是否完全相同

import java.util.Arrays;

/**
 * 对于两个一维数组list1和list2长度相同，写一个方法判断两个数组元素是否完全相同
 */
public class Equals {
    public static boolean equals(int [] list1, int [] list2){
        for(int i=0; i<list1.length; i++){
            if(list1[i] != list2[i]){
                return false ;
            }
        }
        return true ;
    }
    public static void main(String[] args){
        int [] list1 =  new int [] {1,2,3} ;
        int [] list2 = new int [] {1,2,3} ;
        System.out.println(equals(list1,list2)) ;
        Arrays.equals(list1,list2) ; //也可以使用此方法直接比较
    }
}

• 约瑟夫问题，有12个人排成一圈，从1号开始报数，凡是数到5的人就离开
• 然后继续报数，试问最后剩下的一个人是谁？

/**
 * 约瑟夫问题，有12个人排成一圈，从1号开始报数，凡是数到5的人就离开
 * 然后继续报数，试问最后剩下的一个人是谁？
 */
public class Josephus {
    public static void main(String[] args){
        int [] p = new int [13] ;
        for(int j=1; j<p.length; j++){
            p[j] = j ;
        }
        int n = 0 , k = 0 ;
        while(true){
            for(int i=1; i<p.length; i++){
                if(p[i] != 0){
                    n ++ ;
                    if(n % 5 == 0){ //判断是否叫到5
                        p[i] = 0 ;
                        k ++ ; //记录多少人已经离开
                    }
                }
            }
            if(k == 11){
                break ;
            }
        }
        for(int i= 1; i<p.length; i++){ //将最后一个没有离开的打印出来
            if(p[i] != 0){
                System.out.println(p[i]) ;
            }
        }
    }
}

• 从一副52张的扑克牌中抽出4张，然后计算它们对的和，A，J,Q,K分别代表10，11，12，13
• 输出得到牌和为24的选牌次数

/**
 * 从一副52张的扑克牌中抽出4张，然后计算它们对的和，A，J,Q,K分别代表10，11，12，13
 * 输出得到牌和为24的选牌次数
 */
public class CardDemo {
    public static void main(String[] args){
        int [] cards = new int [52] ;
        for(int i=0; i<cards.length; i++){
            cards[i] = i ;
        }
        int sum = 0, count = 0 ;
        while(sum != 24){
            for(int i=0; i<cards.length; i++){
                int index = (int) (Math.random() * cards.length) ; //随机产生0-51的数
                //将产生的元素与当前元素进行交换
                int temp = cards[i] ;
                cards[i] = cards[index] ;
                cards[index] = temp ;
             }
            sum = 0 ;
            for(int j=0; j<4; j++) {
                sum += ((cards[j] % 13) + 1) ;
            }
            count ++ ;
        }
        System.out.println(sum) ;
        System.out.println(count) ;
    }
}

• 提示用户键盘输入一个正整数，以降序的顺序输出该数的所所有最小因子，
• 例如：120，应输入的最小因子依次为:5,3,2,2,2
• 使用栈存储这些因子，然后以降序检索和显示它们。

import java.util.Scanner;
import java.util.Stack;

/**
 * 提示用户键盘输入一个正整数，以降序的顺序输出该数的所所有最小因子，
 * 例如：120，应输入的最小因子依次为:5,3,2,2,2
 * 使用栈存储这些因子，然后以降序检索和显示它们。
 */

public class UseOfStack {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        System.out.print("请输入一个正整数：") ;
        int value = input.nextInt() ;
        Stack stack = new Stack<>() ;
        do{
            for(int i=2; i<=value; i++){
                if(value % i == 0){
                    stack.push(i) ;
                    value = value / i ;
                    break ; //保证找到最小因子，每次找到因子都要退出for循环
                }
            }
        }while(value != 1) ;
        while(!stack.isEmpty()){
            System.out.print(stack.pop() + " ") ;
        }
    }
}

• 求两个矩阵的A与B的和，差，以及A的转置

/**
 * 求两个矩阵的A与B的和，差，以及A的转置
 */
public class MatrixDemo {
    public static void main(String[] args){
        int [][] a =  {{1,3,5}, {-3,6,0}, {13,-5,7},{-2,19,25}};
        int [][] b =  {{0,-1,-2},{7,-1,6},{-6,13,2},{12,-8,-13}};
        int [][] c = new int [4][3] ;
        int [][] d = new int [4][3] ;
        
        //矩阵求和
        for(int i=0; i<4; i++){
            for(int j=0; j<3; j++){
                c[i][j] = a[i][j] + b[i][j] ;
                d[i][j] = a[i][j] - b[i][j] ;
            }
        }
        for(int i=0; i<4; i++){ //求和后的矩阵
            for(int j=0; j<3; j++){
                System.out.print(c[i][j] + " ") ;
            }
        }
        System.out.println() ;

        for(int i=0; i<4; i++){ //求差后的矩阵
            for(int j=0; j<3; j++){
                System.out.print(d[i][j] + " ") ;
            }
        }
        System.out.println() ;

        for(int i=0; i<3; i++){ //转置矩阵
            for(int j=0; j<4; j++){
                System.out.print(a[j][i] + " ") ;
            }
        }

    }
}

• 编写一个方法，返回二维数组中最大值的位置
• 用户键盘输入二维数组的行数和列数，同时输入二维数组元素
• 然后输出二维数组最大元素所在位置

import java.util.Scanner;

/**
 * 编写一个方法，返回二维数组中最大值的位置
 * 用户键盘输入二维数组的行数和列数，同时输入二维数组元素
 * 然后输出二维数组最大元素所在位置
 */
public class MaxLocation {
    public static int [] locateLargest(double [][] a){ //返回记录最大值下标的数组
        int [] index = new int [2] ; //记录最大值的下标
        double max = a[0][0] ;
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a[0].length; j++){
                if(max < a[i][j]){
                    max = a[i][j] ;
                    index[0] = i ;
                    index[1] = j ;
                }
            }
        }
        return index ;
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        System.out.print("请输入数组的行数和列数：") ;
        int row = input.nextInt() ;
        int col = input.nextInt() ;
        double [][] value = new double [row][col] ;
        System.out.print("请输入数组元素的值：") ;
        for(int i=0; i<value.length; i++){
            for(int j=0; j<value[0].length; j++){
                value[i][j] = input.nextDouble() ;
             }
        }
        int [] index = locateLargest(value) ;
        System.out.println("最大元素在数组中的下标为：" + "(" + index[0] + "," + index[1] + ")") ;
    }
}

• 杨辉三角，也称为帕斯卡三角，打印10行的杨辉三角。

/**
 * 杨辉三角，也称为帕斯卡三角，打印10行的杨辉三角
 */
public class TriangleDemo {
    public static void main(String[] args){
        int i, j ;
        int level = 10  ;
        int [][] triangle = new int [level][] ; //不规则数组
        for( i=0; i<triangle.length; i++){
            triangle[i] = new int[i + 1] ;
        }
        triangle [0][0] = 1 ;
        for(i=1; i<triangle.length; i++){
            triangle[i][0] = 1 ;
            triangle[i][triangle[i].length-1] = 1 ;
            for(j=1; j<triangle[i].length-1; j++)
                triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j] ;
        }
        //打印输出triangle数组的元素
        for(i=0; i<triangle.length; i++){
            for(j=0; j<triangle[i].length; j++){
                System.out.print(triangle[i][j] + " ") ;
            }
            System.out.println() ;
        }
    }
}