1.数组元素的赋值(杨辉三角、回形数等)

1-1杨辉三角

  1. /*【提示】
  2. 1. 第一行有 1 个元素, 第 n 行有 n 个元素
  3. 2. 每一行的第一个元素和最后一个元素都是 1
  4. 3. 从第三行开始, 对于非第一个元素和最后一个元
  5. 素的元素。即：
  6. yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
  7. */
  8. package day07;
  10. public class YangHui {
  12.     public static void main(String[] args) {
  13.         //1.声明并初始化二维数组
  14.         int [][]yanghui =new int [10][];
  16. //        yanghui[0][0]=1;
  17. //        yanghui[1][0]=1;
  18. //        yanghui[1][1]=1;
  21.         //2.给数组的元素赋值
  22.         for(int i=0;i<yanghui.length;i++){
  23.             yanghui[i]=new int [i+1];
  24.             //给首末元素赋值
  25.                 yanghui[i][0]=1;
  26.                 yanghui[i][i]=1;
  27.                 //给非首末元素赋值
  28.                     for(int j=1;j<yanghui[i].length-1;j++)
  29.                 yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];    
  32.         }
  33.         //遍历数组
  34.         for(int i=0;i<yanghui.length;i++){
  35.             for(int j=0;j<yanghui[i].length;j++){
  36.                     System.out.print(yanghui[i][j]+"  ");
  37.             }
  38.             System.out.println();
  40.         }
  43.     }
  45. }

2.求数值型数组中元素的最大值、最小值、平均数、总和等


  1. package day07;
  2. /*定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
  3. 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
  4. 要求：所有随机数都是两位数。
  6. [10,99]
  7. 公式：(int) Math.random()*90+10;
  8. */
  10. public class ArrayTest {
  12.     public static void main(String[] args) {
  13.         int []arr=new int[10];
  15.          for(int i=0;i<arr.length;i++){
  16.              arr[i]=(int)(Math.random()*90+10);
  18.          }
  19.          for(int i=0;i<arr.length;i++){
  20.              System.out.print(arr[i]+" ");
  21.          }
  22.          System.out.println();
  24.          //求数组元素的最大值
  25.          int maxValue=arr[0];
  26.            for(int i=0;i<arr.length;i++){
  27.                if(maxValue<arr[i]){
  28.                    maxValue=arr[i];
  29.                }
  30.            }
  31.            System.out.println("最大值为："+maxValue);
  33.         //求数组元素的最小值
  34.            int minValue=arr[0];
  35.            for(int i=0;i<arr.length;i++){
  36.                if(minValue>arr[i]){
  37.                    minValue=arr[i];
  38.                }
  39.            }
  40.            System.out.println("最小值为："+minValue);
  42.         //求数组元素的总和
  43.            int sum=0;
  44.            for(int i=0;i<arr.length;i++){
  45.                sum+=arr[i];
  46.            }
  47.            System.out.println("总和为："+sum);
  49.         //求数组元素的平均数
  50.            float average ;
  51.              average=(float) (sum*1.0/10);
  52.              System.out.println("平均值为："+average);
  53.     }
  55. }

3. 数组的复制、反转、查找(线性查找、二分法查找)

3-1复制


  1. /*使用简单数组
  2. (1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
  3. 他们是int[]类型的数组。
  4. (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
  5. (3)显示array1的内容。
  6. (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
  7. (如array[0]=0,array[2]=2)。打印出array1。
  9. 思考：array1和array2是什么关系？     array1和array2地址值相同，都指向了堆空间的唯一一个数组实体
  10. 拓展：修改题目，实现array2对array1数组的复制
  11. */
  12. package day07;
  14. public class Arrayexer {
  16.     public static void main(String[] args) {
  18.         int[]array1,array2;
  20.         array1= new int []{2,3,5,11,13,17,19};
  22.         //显示array1的内容
  23.          for(int i=0;i<array1.length;i++){
  24.              System.out.print(array1[i]+"\t");
  25.          }
  27.          //复制array2变量等于array1
  28.          //不能称之为数组得到复制
  29.           array2=array1;          
  30.           //赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
  32.           for(int i=0;i<array2.length;i++){
  33.               if(i%2==0){
  34.                   array2[i]=i;
  35.               }
  36.           }
  37.           System.out.println();
  38.           //打印出array1
  39.           for(int i=0;i<array1.length;i++){
  40.                  System.out.print(array1[i]+"\t");
  41.              }
  43.     }
  45. }

3-2 反转

  1. package day07;
  3. public class ArrayExer2 {
  5.     public static void main(String[] args) {
  7.         String[]arr =new String[]{"JJ","DD","MM","GG","AA","BB"};
  9.         //数组的复制
  10.         String []arr1 =new String[arr.length];
  11.         for(int i=0;i<arr1.length;i++){
  12.             arr1[i]=arr[i];
  14.         }
  16.         //数组的反转
  17.         for(int i=0;i<arr1.length;i++){
  18.             System.out.print(arr1[i]+"  ");
  19.         }
  20.         System.out.println();
  22.         for(int i=0;i<arr1.length;i++){
  23.             System.out.print(arr1[arr1.length-i-1]+"  ");
  24.         }
  26.     }
  28. }

3-3 二分法查找

  1. //二分法查找：
  2.         // 前提，所要查找的数组必须有序
  4.          int [] arr2 =new int []{-99,-54,-2,0,2,33,43,256,999};
  5.            int number=34;
  6.            int head=0;
  7.            int end =arr2.length-1;
  8.            boolean isFlag1=true;
  9.            while(head <= end){
  10.                int middle = (head + end) / 2;
  11.                if(arr2[middle] == number){
  12.                System.out.println("找到指定的元素，索引为：" + middle);
  13.                isFlag = false;
  14.                break; }else if(arr2[middle] > number){
  15.                end = middle - 1;
  16.                }else{//arr3[middle] < number
  17.                head = middle + 1;
  18.                } }
  19.                if(isFlag){
  20.                System.out.println("未找到指定的元素");
  21.                }   
  22.            }

4. 数组元素的排序算法

4-1 冒泡排序

  1. package day07;
  3. public class BuubbleSortTest {
  4. /*
  5.  *数组的冒泡排序 的实现
  6.  * 
  7.  */
  8.     public static void main(String[] args) {
  10.             int[] arr=new int[]{43,32,76,98,-90,-67,-32,33,99};
  12.             //冒泡排序
  13.             for(int i=0;i<arr.length-1;i++){
  14.                 for(int j=0;j<arr.length-1-i;j++){
  15.                     if(arr[j]>arr[j+1]){
  16.                         int temp=arr[j];
  17.                         arr[j]=arr[j+1];
  18.                         arr[j+1]=temp;
  19.                     }
  20.                 }
  21.             }
  25.             for(int i=0;i<arr.length;i++){
  26.                 System.err.print(arr[i]+"\t");
  27.             }
  29.     }
  31. }