[package codex; public class StringUtil { public StringUtil() { // TODO Auto-generated constructor stub } /** * @param args */ public static void main(Stri
public class Lesson{
public static void main(String [] args){
//二维数组的声明方式：
//数据类型 [][] 数组名称 = new 数据类型 [长度][长度] ;
//数据类型 [][] 数组名称 = {{123},{456}} ;
int [][] num = new int [3][3]; //定义了三行三列的二维数组
num[0][0] = 1; //给第一行第一个元素赋值
num[0][1] = 2; //给第一行第二个元素赋值
num[0][2] = 3; //给第一行第三个元素赋值
num[1][0] = 4; //给第二行第一个元素赋值
num[1][1] = 5; //给第二行第二个元素赋值
num[1][2] = 6; //给第二行第三个元素赋值
num[2][0] = 7; //给第三行第一个元素赋值
num[2][1] = 8; //给第三行第二个元素赋值
num[2][2] = 9; //给第三行第三个元素赋值
for(int x = 0; x
for(int y = 0; y
System.out.print(num[x][y]);
}
System.out.println("/n");
}
}
}
//数组值arr[x][y]表示指定的是第x行第y列的值。
//在使用二维数组对象时，注意length所代表的长度，
//数组名后直接加上length(如arr.length)，所指的是有几行(Row)；
//指定索引后加上length(如arr[0].length)，指的是该行所拥有的元素，也就是列(Column)数目。
//1.二维数组的定义
//2.二维数组的内存空间
//3.不规则数组
package me.array;
public class Array2Demo{
public static void main(String[] args){
//定义二维数组
int[ ] [ ] arr={{1,2,3},{4,5,6}};
//静态初始化
//打印出二维数组
for(int i=0;i
for(int j=0;j
System.out.print(arr[i][j]+" ");
}
//输出一列后就回车空格
System.out.println();
}
}
}
在描述算法之前，先看看下面的5*5的表格： 1 3 4 10 11 2 5 9 12
19
6 8 13 18 20 7 14 17 21 24 15 16 22 23 25
上面的表格很容易看出规律。就是从左上角第一个格开始(起始为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
由于是先从上到下(1可以看做是从上到下)，再从下到上，很象一条蛇，因此，该数字表格也可称为蛇形矩阵。现在要与一个方法(或函数)，方法的参数是一个int类型，表示n，方法返回一个二维数组，表示要获得的往返接力数字表格。
实际上，这个算法并不复杂，只需要从分别获得1至n^2中每个数字对应的二维数组的坐标就可以了。先拿这个5行5列的表格来说，求出上面每组数组对应的坐标(起始位置为0)。
第0组
第1组
第2组
第3组
第4组
第5组
第6组
第7组
第8组
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
(0,0)
(1,0) (0,1)
(0,2) (1,1) (2,0)
(3,0) (2,1) (1,2) (0,3)
(0,4) (1,3) (2,2) (3,1) (4,0)
(4,1) (3,2) (2,3) (1,4)
(2,4) (3,3) (4,2)
(4,3) (3,4)
(4,4)
从上面的从标可以看出一个规律。 左上角的半个表格(以对角线分界)的横坐标和纵坐标从0开始，每一组增1，直到增至表格的边界(n - 1)，而且是交替的，也就是说，偶数行是列增，行减小，行+列=组的索引。而右下角的4组数字虽然行、列也是交替增长的，但递减的行或列总是从(n - 1)开始(对于本例，是从4开始)，而递增的行或列总是从index - n + 1开始，其中index表示组的索引。这就可以得出一个算法。实现代码如下：
public static int[][] getGrid(int n)
{
int[][] array = new int[n][n];
int row = 0, col = 0, m = 1;
// 用于控制奇偶组，false表示偶组，true表示奇组
boolean isRow = false;
// i表示当前组的索引，从0开始
for (int i = 0; i
{
row = i;
while (row >= ((i
{
// 如果处理的是右下角表格中的数字，行或列最大不能超过n-1
if (row > (n - 1))
row = n - 1;
col = i - row;
if (isRow)
array[row][col] = m;
else // 将row变成列，将col变成行
array[col][row] = m;
m++;
row--;
}
// 切换奇偶组
isRow = !isRow;
}
return array;
}
另一种算法
上面实现的算法需要循环N*N次才可以生成蛇形矩阵。但仔细分析一下，还可以稍微变换一下这个算法，使循环次数减小至N*N/2。我们上学时曾学过用高斯的方法计算1+2+3+...+100， 1 + 100 = 101，2 + 99 = 101，...，50+51 = 101，因此，结果是101 * 50 = 5050。很方便。我们这个算法也可采用类似的方法。仔细观察上面5*5的数字表格发现，算出左上角的矩阵中每一个数字后，都可以直接获得右下角度某个位置的数字。例如在(0,0)位置的1，可以向到(4,4)位置的25，(1,2)位置的9可以得到(3,2)位置的17。我们发现，每一对数之和都为26。而且它们坐标的关系是(row,col)，(n - row - 1, n - col - 1)。因此，只要得到左上角的半个矩阵，就可以得出右下角的另外半个矩阵。如果n为奇数，对角线中间的一个数(在5*5的矩阵中是13)与之对应的数是其自身。好，我们看看改进的算法的实现：
public static int[][] getGrid1(int n)
{
int[][] array = new int[n][n];
int row = 0, col = 0, m = 1;
int number1 = (n * n / 2 + n * n % 2);
int number2 = n * n + 1;
boolean isRow = false;
// number1表示要计算的蛇形矩阵中最大的数字，对于5*5矩阵来说该数是13
for (int i = 0; m
{
row = i;
while (row >= 0)
{
col = i - row;
if (isRow)
{
array[row][col] = m;
// 填充与m对应的另外一个数
array[n - row - 1][n - col - 1] = number2 - m;
}
else
{
array[col][row] = m;
// 填充与m对应的另外一个数
array[n - col - 1][n - row - 1] = number2 - m;
}
m++;
if(m >= number1) break;
row--;
}
isRow = !isRow;
}
return array;
}
上面的算法虽然将循环次数减少了一半，但每次循环的计算量增加了，因此，算法总体效率并没有提高。至于使用哪个算法，可根据实际情况决定。
如果想输出n=10的数字表格，可以使用int[][] grid = getGrid(10)或int[][] grid1 = getGrid1(10)，会得到同样的结果。输出grid和grid1，看看是不是下面的结果：
1 3 4 10 11 21 22 36 37 55 2 5 9 12 20 23 35 38 54 56 6 8 13 19 24 34 39 53 57 72 7 14 18 25 33 40 52 58 71 73 15 17 26 32 41 51 59 70 74 85 16 27 31 42 50 60 69 75 84 86 28 30 43 49 61 68 76 83 87 94 29 44 48 62 67 77 82 88 93 95 45 47 63 66 78 81 89 92 96 99 46 64 65 79 80 90 91 97 98 100
不规则二维数组 http://blog.csdn.net/incyanggan/article/details/9819005
[今天看文档，发现某个topic的实现抽象出来就是二维数组配合上其它数据结构的操作，心血来潮再次回顾了一把可爱的core java，昨天面试一个来应聘的3年高级工程师，问了个很
[java]
view plain
copy
?
//1.二维数组的定义
//2.二维数组的内存空间
//3.不规则数组
package me.array;
public class Array2Demo{
public static void main(String[] args){
//创建和打印不规则二维数组
int arr[ ][ ];
arr=new int[3][];//现在说明为不规则数组
arr[0]=new int[10];//arr[0]指向另一个一位数组
arr[1]=new int[3];
arr[2]=new int[4];
//赋值
for(int i=0;i
for(int j=0;j
arr[i][j]=j;
}
}
//输出
for(int i=0;i
for(int j=0;j
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
/*输出结果：
0 1 2 3 4 5 6 7 8 9
0 1 2
0 1 2 3
*///
}
}
[java]
view plain
copy
?
//3.编写一个方法，返回double型二维数组，数组通过解析字符串参数获得。
//如"1,2;3,4,5;6,7,8"
//d[0,0]=1.0 d[0,1]=2.0 d[1,0]=3.0 ....
package me.parser;
public class TestString{
public static void main(String[] args){
//1.用字符串分解split(";")成三个字符串数组
//2.再分解split(",")
//声明一个二维数组用来装分解好的字符
String s="1,2;3,4,5;6,7,8";
//以split()方法 分解
String[] sFirst=s.split(";");
String[][] word=new String[sFirst.length][];
int flag=0;
for(int i=0;i
//打印出已经分开的
//System.out.println(sFirst[i]);
/*这条语句输出
1,2
3,4,5
6,7,8
*///接下来在按照 ,分开他们放入一个一维数组
String[] sSecond=sFirst[i].split(",");
//~ System.out.println(sSecond.length);
//~ /*输出:
//~ 2
//~ ---------------------------------
//~ 3
//~ ---------------------------------
//~ 3
//~ ---------------------------------
//~ *///说明每次sSencond这个一维数组的长度不同
word[i]=new String[sSecond.length];//这步确定行不规则数组的每行长度
//为这个数组赋值
for(int j=0;j
word[i][j]=sSecond[j];
}
System.out.println("---------------这是第"+(i+1)+"次循环-------------------");
}
//输出二维数组
System.out.println("输出二维数组-------------------");
for(int i=0;i
for(int j=0;j
System.out.print(word[i][j]+" ");
}
System.out.println();
}
/*结果：
---------------这是第1次循环-------------------
---------------这是第2次循环-------------------
---------------这是第3次循环-------------------
输出二维数组-------------------
1 2
3 4 5
6 7 8
输出二维数组-------------------
*///
}
}
[今天才发现对于二维数组不支持如下的定义，否则赋值的时候报错 ： String javaArray[][] = new String[2][2]; 和 String[][] strArray = new String[2][2]; 应该是如下，
扫一扫
701
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
