devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

二维数组(Dyadic Array)

作者：IT小白 | 2024-03-26 21:01:10

赞

踩

二维数组

二维数组(Dyadic Array)

一维数组 : 数组中直接存放数据

二维数组 : 数组中存放数组

二维数组可以看成以数组为元素的数组。就是一个特殊的一维数组,其每一个元素都是一个一维数组

String[][] str = new String[3][4];//String类型二维数组举例

  • 1

其实多维数组不仅仅只有二维数组,还有三维数组,四维数组…, 但是三维以上很少见到,所以大家重点了解二维数组即可.

1.举例

int [][] a = {{1,2},{3,4,0,9},{5,6,7}};

  • 1

在这里插入图片描述

2.二维数组的声明

		数据类型  变量名;     -->变量声明
        数据类型[] 数组名;    -->一维数组声明
        数据类型[][] 数组名;  -->二维数组声明

  • 1
  • 2
  • 3

3.二维数组的初始化

3.1.动态初始化

数组定义与为数组元素分配空间和赋值的操作分开进行

数据类型[][] 数组名 = new 数据类型[一维][二维];

  • 1

注意:这种初始化方式,每一个内层的二位数组长度相同

int[][] a=new int[3][2];
a[0][0] = 1;
a[0][1] = 2;

  • 1
  • 2
  • 3

在这里插入图片描述

动态初始化  : 创建二维数组的同时赋值(内部一维数组创建+每一个一维数组中的数据)
    创建外层二维数组同时创建内层每一个一维刷组+没有赋值数据,存在默认值
    	数据类型[][] 数组名 = new 数据类型[外层二维数组长度][内层一维数组长度];
	创建外层二维数组,内层每一个一维数组在后续确定时单独创建+赋值数据
        数据类型[][] 数组名 = new 数据类型[外层二维数组长度][];

  • 1
  • 2
  • 3
  • 4
  • 5
int[][] a=new int[3][];
arr[0]=new int[2];
arr[1]=new int[]{3,4,5,6};
arr[2]=new int[]{7,8,9};
arr[0][0] = 1;
arr[0][1] = 2;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在这里插入图片描述

3.2.静态初始化

在定义数组的同时就为数组元素分配空间并赋值

数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
数据类型[][] 数组名 = {{...},{...},{...}}; --简化写法

  • 1
  • 2
int[][] arr1=new int[][]{{5,4,8},{3,8},{1}};
char[][] arr2={{'a'},{'b','c'}};

  • 1
  • 2

4.二维数组的使用

  • 根据索引进行使用
  • 数组数组名 [外层二维索引] [内层一维索引]

4.1.数组的遍历

双重循环实现多维数组的遍历

/*
    二维数组的遍历方式 :
        1.for
        2.foreach
        以上两种循环任意嵌套
 */
public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6}};
		//	for循环嵌套加强for
        //for-->foreach
        for(int i=0;i<arr.length;i++){//
            for(int j:arr[i]){
                System.out.println(j);
            }
        }
		//	两个加强for嵌套
        //foreach-->foreach
        for(int[] a:arr){
            for(int i:a){
                System.out.println(i);
            }
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
public class AraayEachTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7}};
        //for嵌套for
       for (int i = 0; i < arr.length; i++) {
           for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
       }
        //System.out.println(Arrays.deepToString(arr));//返回指定数组内容的字符串表示形式。
        //for 嵌套each
       for (int i = 0; i < arr.length; i++) {
            for (int a:arr[i]
                ) {
                System.out.println(a);
            }
        }
//        //each 嵌套each
//        for (int[] a:arr
//             ) {
//            for (int b:a
//                 ) {
//                System.out.println(b);
//            }
//        }
//        //each 嵌套for
//        for (int[] i:arr
//             ) {
//            for (int j = 0; j < i.length; j++) {
//                System.out.println(i[j]);
//            }
//        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

Arrays中提供操作多维数组的方法:

package com.arraytest;

import java.util.Arrays;//它提供的所有方法都是静态的。

public class AraayEachTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7}};
        int[][] arr2 = {{1,2,3},{4,5},{6,7}};
        int[][] arr1 = {{1,2,3},{4,5},{6,7}};
        int[] arr3 = {3,1,5,8,9};
        System.out.println(arr1);//打印对象地址
        System.out.println(Arrays.deepToString(arr1));//返回指定数组的“深层内容”的字符串表示形式
        System.out.println(arr== arr2);//false   地址不一样
        System.out.println(Arrays.equals(arr,arr2));//false
        System.out.println(Arrays.deepEquals(arr,arr2));//如果两个数组彼此深度相等，则返回 true
        //将数组升序排序
        System.out.println(Arrays.toString(arr3));
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //二进制搜索指定值
        System.out.println(Arrays.binarySearch(arr3,8));//数值8在下标3的位置
        System.out.println(Arrays.binarySearch(arr3,10));//-6如果不存在,返回 -插入点-1
        System.out.println(Arrays.binarySearch(arr3,100));//-6
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
import java.lang.reflect.Array;
import java.util.Arrays;

/*
    Arrays :
        该类包含用于操作数组的各种方法（例如排序和搜索）。
        java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有但不限于以下功能:
         给数组赋值：通过fill方法。
         对数组排序：通过sort方法,按升序。
         比较数组：通过equals方法比较数组中元素值是否相等。
         查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

 */
public class Class001_Arrays {
    public static void main(String[] args) {
        int[] arr1 ={3,1,5,2,4};
        int[] arr2 ={3,1,5,2,4};
        int[] arr5 ={13,1,5,2,14};

        int[][] arr3 = {{1,2,3},{4,5},{6}};
        int[][] arr4 = {{1,2,3},{4,5},{6}};

        //static String toString(int[] a) 返回指定数组内容的字符串表示形式。
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr3));

        //static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。
        System.out.println(Arrays.deepToString(arr3));

        //static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
        System.out.println(arr1==arr2);
        System.out.println(Arrays.equals(arr1,arr2));

        //static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。
        System.out.println(Arrays.deepEquals(arr3,arr4));

        //static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) 如果指定范围内的两个指定的int数组彼此 相等 ，则返回true。
        System.out.println(Arrays.equals(arr2,1,4,arr5,1,4));

        //static void fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
        //static void fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。
        //注意 : 一般指定结束索引位置都不包含
        int[] arr6 = new int[10];
        System.out.println(Arrays.toString(arr6));
        Arrays.fill(arr6,100);
        System.out.println(Arrays.toString(arr6));
        Arrays.fill(arr6,3,6,1);
        System.out.println(Arrays.toString(arr6));

        //static void sort(int[] a) 将指定的数组按升序排序。
        System.out.println(Arrays.toString(arr1));
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        //static void sort(int[] a, int fromIndex, int toIndex) 按升序对数组的指定范围进行排序。
        System.out.println(Arrays.toString(arr2));
        Arrays.sort(arr2,1,4);
        System.out.println(Arrays.toString(arr2));
        //定义字符数组|字符串数组|double数组,使用Arrays.sort对其数据做升序排序

        //static int binarySearch(int[] a, int key) 使用二进制搜索算法在指定的int数组中搜索指定的值。
        System.out.println(Arrays.binarySearch(arr1,6));  //如果不存在,返回-插入点-1

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

5.附部分练习题

5.1 二维数组遍历求和操作：

用二重循环求出二维数组b所有元素的和

package com.task.d11_array;
/*6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
 int[][] b={{11},{21,22},{31,32,33}}*/
public class Sum06 {//双层普通for循环
    public static void main(String[] args) {
        int sum = 0;//计数器
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for (int i = 0; i < b.length; i++) {//遍历外层二维数组
            for (int j = 0; j < b[i].length; j++) {//遍历内层一维数组
                sum += b[i][j];//两个下标位置识别一个数
            }
        }
        System.out.println(sum);//输出150
    }
}
/*接下来其余三种组合的循环遍历*/
class S2{//第二种,普通for,内层嵌套foreach
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for (int i = 0; i < b.length; i++) {//外层普通for
            for (int j:b[i]) {//内层增强for
                sum += j;//每次循环出一个数j
            }
        }
        System.out.println(sum);//输出150
    }
}
class S3{//第三种两层foreach循环嵌套
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for(int[] a:b){//外层循环,得到一个数组,因此用int[]类型接收,数组名是a
            for(int i:a){//内层循环,a数组,得到每一个值
                sum += i;
            }
        }
        System.out.println(sum);
    }
}
class S4{//第四种 外层foreach 嵌套内层for循环
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for(int[] a:b){
            for (int i = 0; i < a.length; i++) {//循环遍历a数组
                sum += a[i];//得到每一个索引i位置的元素
            }
        }
        System.out.println(sum);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

5.2 数组查找操作：

定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

package com.task.d11_array;

import java.util.Scanner;

/*1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。*/
public class Check01 {
    public static void main(String[] args) {
        String[] arr = new String[10];//定义长度为10的一维字符串数组
        arr[0] = "lbj";//给数组赋值
        arr[1] = "kb";
        arr[2] = "kd";
        arr[3] = "cp3";
        arr[4] = "kaka";
        arr[5] = "messi";
        arr[6] = "ad";
        arr[7] = "kg";
        arr[8] = "dw";
        arr[9] = "msn";
        Scanner sc = new Scanner(System.in);//创建对象
        System.out.println("请输入需要查找的内容:");
        String in = sc.next();//使用功能,接收键盘输入信息
        boolean flag = false;//布尔类型声明并赋值
        for(String s:arr){//foreach遍历
            if(s.equals(in)){//用equals方法比较是否对象深度内容相同
                flag = true;
            }
        }
        if(flag){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
        
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
/*数组排序及元素查找*/
public class ArrOrder {
    public static void main(String[] args) throws Exception{//main方法,抛出异常
        int[] arr = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
        Arrays.sort(arr);//sort方法给数组排序
        printArr("数组排序结果是:",arr);
        System.out.println("-----------换行----------");
        int index = Arrays.binarySearch(arr,4);//查找数组中元素
        System.out.println("元素4的下标位置是"+index);
    }
    private static void printArr(String str,int[] arr){
        System.out.println(str+"[数组长度:"+ arr.length +"]");
        for (int i:arr
             ) {
            System.out.print(" "+i);
        }
    }
}
/*数组排序结果是:[数组长度:10]
 -9 -7 -3 -2 0 2 4 5 6 8-----------换行----------
元素4的下标位置是6*/

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

5.3 获取数组最大值和最小值操作

package com.task.d11_array;
/*获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写
函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小
的数，并统计其中>=60的有多少个。*/
public class GetMaxMin02 {
    public static void main(String[] args) {
        int[] arr = getArray(100);
        printArr(arr);
        int min = getMin(arr);
        int max = getMax(arr);
        System.out.println("数组中最大值和最小值分别是"+max+"和"+min);
        int count = count(arr,60);
        System.out.println("数组中大于或者等于60的数的个数是"+count);
    }
    //创建一个数组对象,并且初始化50个随机数
    public static int[] getArray(int n){
        int[] arr = new int[50];//静态声明,长度50个
        for (int i = 0; i < 50; i++) {//遍历
            arr[i] = (int)(n*Math.random());//给每个索引赋值随机数
        }
        return arr;
    }
    //数组遍历
    private static void printArr(int[] arr){
        System.out.println("输出数组元素");
        for (int i = 0; i < arr.length; i++) {
            if(i%10 == 0){
                System.out.println();
            }
            System.out.print(arr[i]+"\t");
        }
    }
    //最大值
    private static int getMax(int[] arr){
        int max = arr[0];
        for(int m:arr){
            if(max < m){
                max = m;
            }
        }
        return max;
    }
    //最小值
    private static int getMin(int[] arr){
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
    //统计数组中大于等于60
    public static int count(int[] arr,int num){
        int count = 0;
        for(int v:arr){
            if(v >= num){
                count++;
            }
        }
        return count;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
/*数组倒序实例*/
public class ReverseTest {
    private static int[] reverse;

    public static void main(String[] args) {
        int[] arr1 = {1,3,4,7,9};
        for(int i:arr1){
            System.out.print(i+" ");//不换行遍历输出原来数组内容
        }
        System.out.println("\n");
        arr1 = ReverseTest.reverse(arr1);
        for(int i: arr1){
            System.out.print(i+" ");
        }
    }

    public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组
        int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变
        for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) {
            res[j] = arr[i];//新数组最后一位就等于原数组第一位
        }
        return res;//返回新数组
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

5.4 获取数组长度

/*获取数组长度*/
public class Arr_Length {
    public static void main(String[] args) {
        String[][] str = new String[3][8];
        System.out.println("第一维数组长度是:"+str.length);
        System.out.println("第二维数组长度是:"+str[0].length);
/*第一维数组长度是:3
第二维数组长度是:8*/
        int[][] arr = {{1,2},{3,4,5},{6,7,8,9}};
        int rows = arr.length;//行的长度
        int cols = arr[0].length;//列的长度
        int c = arr[1].length;
        int co = arr[2].length;
        System.out.println(rows);//3
        System.out.println(cols);//2
        System.out.println(c);//3
        System.out.println(co);//4
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

5.5 数组反转

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/*数组倒序实例*///数组反转
public class ReverseTest {
    private static int[] reverse;
		//方法一测试
    public static void main(String[] args) {
        int[] arr1 = {1,3,4,7,9};
        for(int i:arr1){
            System.out.print(i+" ");//不换行遍历输出原来数组内容
        }
        System.out.println("\n");
        arr1 = ReverseTest.reverse(arr1);//调用方法一
        for(int i: arr1){
            System.out.print(i+" ");
        }
        System.out.println("----------");
        
        //调用方法二测试
        int[] arr3 = {1,2,3,4};
        rever(arr3,arr3.length);
        /*9 7 4 3 1 反转后的数组是:
            1 3 4 7 9 */
        System.out.println("===========");
        
        //调用方法三测试
        int[] arr4 = {10,11,12,14,17};
        runoobtest(arr4,arr4.length);
        System.out.println("---------");
		
        //方法四测试
        Integer[] arr2 = {1,2,3,4,5};
        re(arr2);//[5, 4, 3, 2, 1]
    }
    
    //方法一
    public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组
        int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变
        for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) {
            res[j] = arr[i];//新数组最后一位就等于原数组第一位
        }
        return res;//返回新数组
    }
    
    //方法二:
    public static void rever(int[] arr,int n){
        int[] arr1 = new int[n];
        int j = n;
        for (int i = 0; i < n; i++) {
            arr1[j-1] = arr[i];
            j--;
        }
        System.out.println("反转后的数组是:");
        for (int i = 0; i < n; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
    
    //方法三:
    public static void runoobtest(int[] arr,int n){
        //0和n-1换,1和n-1-1换,2和-n-1-2换
        int c;
        for (int i = 0; i < n/2 ; i++) {

             c = arr[i];
            arr[i] = arr[n-i-1];
            arr[n-i-1] = c;
        }
        System.out.println("新数组是:\n");
            for (int j = 0; j < n; j++) {
                System.out.print(arr[j]+" ");
            }
    }
    
    //方法四:
    static void re(Integer arr[]){
        Collections.reverse(Arrays.asList(arr));
        System.out.println(Arrays.asList(arr));
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82

5.6 杨辉三角

public class YangHuiTest {
    public static void main(String[] args) {
        int[][] arr = new int[10][];
        arr[0] = new int[]{1};
        arr[1] = new int[]{1,1};
        for (int i = 2; i < arr.length; i++) {
            arr[i] = new int[i+1];
            arr[i][0] = arr[i][i] = 1;
            for (int j = 1; j < i; j++) {
                arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
            }
        }
        for (int[] arr1:arr
             ) {
            for (int i:arr1
                 ) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
}

//打印结果如下
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

寄 语:

我们与成功之间并不遥远，
许多非凡的成就只不过是简单坚持的结果， 关键是要守住你的初心~``

​

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号