一、问题描述
杨辉三角定义如下：
复制代码
1
/ \
1 1
/ \ / \
1 2 1
/ \ / \ / \
1 3 3 1
/ \ / \ / \ / \
1 4 6 4 1
/ \ / \ / \ / \ / \
1 5 10 10 5 1
把每一行看做一个list，试写一个 Iterator，不断输出下一行的 list：
java
复制代码
# 期待输出:
# [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、首尾两个元素固定是1
2、下一行的序列生成依赖于上一行
3、下一行实际需要生成的元素个数，是上一行序列长度-1
就比如
1,1\] -\> \[1,2,1\] L = \[1,1\] 2 = L\[0\]+L\[1\] result = \[1\]+\[2\]+\[1\]=\[1,2,1\] 需要生成 2 一个元素
```java
List in = Arrays.asList(1,1);
List out = new ArrayList<>();
out.add(1);
for (int i = 0; i < ( in.size()-1); i++) {
out.add(in.get(i)+in.get(i+1));
}
out.add(1);
System.out.println(out);
```
\[1,2,1\] -\> \[1,3,3,1\] L = \[1,2,1\] 3 = L\[0\]+L\[1\] 3 = L\[1\]+L\[2\] result = \[1\]+\[3,3\]+\[1\] 需要生成 3,3 两个元素
```java
List in = Arrays.asList(1,2,1);
List out = new ArrayList<>();
out.add(1);
for (int i = 0; i < ( in.size()-1); i++) {
out.add(in.get(i)+in.get(i+1));
}
out.add(1);
System.out.println(out);
```
从 \[1\] -\> \[1,1\] 是否也符合这个表达式呢？
```java
List in = Arrays.asList(1);
List out = new ArrayList<>();
out.add(1);
for (int i = 0; i < ( in.size()-1); i++) {
out.add(in.get(i)+in.get(i+1));
}
out.add(1);
System.out.println(out);
```
至此，除了杨辉三角的第一行序列 \[1\]，我们得到了一个通用的表达式，第一行序列 \[1\]，就让它直接返回就好。
```java
if (idx==0) {
return in;
}
List out = new ArrayList<>();
out.add(1);
for (int i = 0; i < ( in.size()-1); i++) {
out.add(in.get(i)+in.get(i+1));
}
out.add(1);
return out;
```
## 三、代码实现
```java
package com.study.algorithm;
import java.util.*;
public class TriangleIter implements Iterator> {
// 杨辉三角要展示几层
private Integer n;
private Integer idx = 0;
private List list = new ArrayList<>();
public TriangleIter(Integer n) {
this.n = n;
// 初始化第一个列表 [1]
list.add(1);
}
@Override
public boolean hasNext() {
return idx < n;
}
@Override
public List next() {
list = generate(list);
idx++;
return list;
}
private List generate(List in) {
if (idx==0) {
return in;
}
List out = new ArrayList<>();
out.add(1);
for (int i = 0; i < ( in.size()-1); i++) {
out.add(in.get(i)+in.get(i+1));
}
out.add(1);
return out;
}
public static void main(String[] args) {
TriangleIter iter = new TriangleIter(10);
while(iter.hasNext()){
System.out.println(iter.next());
}
}
}
```
## 四、语言比较
我用 Python 写过杨辉三角的列表生成式：
```python
L = [1] + [ L[i]+L[i+1] for i in range( len(L)-1 ) ] + [1]
```
并尝试用 Java 的流式计算来实现：
```java
List out =
IntStream.concat(
IntStream.of(1),
IntStream.concat(IntStream.range(0, in.size() - 1).map(i -> in.get(i) + in.get(i + 1)),
IntStream.of(1))
).boxed().collect(Collectors.toList());
```
发现并没有比 for 循环简洁多少。
Python 的语言表达能力确实很强。