钱不翼而飞了吗 - 未名空间MITBBS历史存档

钱不翼而飞了吗# Stock

f*a2010-06-22 07:06

1 楼

没刷过iterator的题，面试被问一个PositiveInteger的Iterator，
就是给你个IntegerIterator，（iterator over an array），写个
PositiveIterator。iterate over positive integer（next， hasNext, remove)
刚一看，觉得还行啊，然后一写，不大对，然后一个中国面试官，还挺照顾，给
我hint，我电话里也听不清楚。。。

f*02010-06-22 07:06

2 楼

我几乎所有的股票都买在这次捞底的最低点,大盘升了将近一半了,我却就挣了个5%不到
,这都咋回事,按大盘的涨率算,我应该挣得不止这么多啊,为啥缩水的.
本来预算要翻一翻的,大盘涨,个股的钱却不翼而飞了?

y*e2010-06-22 07:06

3 楼

哪个公司啊？最近iterator的题大火吧，leetcode大神赶快加进leetcode里吧

h*e2010-06-22 07:06

4 楼

调整呀。。。把水都挤掉了

f*a2010-06-22 07:06

5 楼

公司不重要。。。
我这题是：
given an IntegerIterator （which implements hasNext, next, remove),
implement a PositiveIterator that has hasNext, next, remove

【在 y*****e 的大作中提到】

: 哪个公司啊？最近iterator的题大火吧，leetcode大神赶快加进leetcode里吧

n*s2010-06-22 07:06

6 楼

都给你一个IntegerIterator了。。。

f*a2010-06-22 07:06

7 楼

你implement个看看

【在 n*******s 的大作中提到】

: 都给你一个IntegerIterator了。。。

l*82010-06-22 07:06

8 楼

直接调用IntegerIterator的函数，碰到负数就跳过？

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 你implement个看看

f*a2010-06-22 07:06

9 楼

老兄，我也一开始以为这样，但你想想
1）what if the user calls "hasNext()" gazillion times
2) what if the user calls "next()" directly?
你写一写让我看看

【在 l*****8 的大作中提到】

: 直接调用IntegerIterator的函数，碰到负数就跳过？
:
: /* */) 的大作中提到: 】

m*92010-06-22 07:06

10 楼

先遍历一遍把positive integer找出来放在linked list里？

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 老兄，我也一开始以为这样，但你想想
: 1）what if the user calls "hasNext()" gazillion times
: 2) what if the user calls "next()" directly?
: 你写一写让我看看

s*72010-06-22 07:06

11 楼

好像不难，我写个试试，大家给看看
IntergerIterator iter;
NoSuchElementException e = new NoSuchElementException();
public int next(){
if(!iter.hasNext()) throw e;
int n = iter.next();
return n>0?n:next();
}
public boolean hasNext(){
if(!iter.hasNext()) return false;
int n = iter.next();
return n>0?true:hasNext();
}
public void remove(){
iter.remove();
}
想简单了，hasNext移动iter，见笑了

f*a2010-06-22 07:06

12 楼

你这个就是我一开始以为的。
但你看看你的hasNext, 如果我call hasNext for gazillion times，你的iterator已
经move 了gazillion times了
let's say i call
for (int i = 0; i < 10000; i++) {
iter.hasNext();
}
iter.next(); // u need to return the first positive element
with the way u implemented it, u would return the 10000th positive element

【在 s******7 的大作中提到】

: 好像不难，我写个试试，大家给看看
: IntergerIterator iter;
: NoSuchElementException e = new NoSuchElementException();
: public int next(){
: if(!iter.hasNext()) throw e;
: int n = iter.next();
: return n>0?n:next();
: }
: public boolean hasNext(){
: if(!iter.hasNext()) return false;

n*s2010-06-22 07:06

13 楼

不对。
先调用hasNext()，已经把下一个正整数取出来了。再调用next()，又跳到下一个正整
数了，明显错过了一个正整数。

【在 s******7 的大作中提到】

: 好像不难，我写个试试，大家给看看
: IntergerIterator iter;
: NoSuchElementException e = new NoSuchElementException();
: public int next(){
: if(!iter.hasNext()) throw e;
: int n = iter.next();
: return n>0?n:next();
: }
: public boolean hasNext(){
: if(!iter.hasNext()) return false;

n*s2010-06-22 07:06

14 楼

用一个stack来保存hasNext()取出的正整数就可以了。
每次调用hasNext()，检查stack是否为空。空的话取出下一个正整数压入stack。不为
空返回stack顶上元素。
每次调用next()，也检查stack是否为空，不为空pop stack即可。

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 你这个就是我一开始以为的。
: 但你看看你的hasNext, 如果我call hasNext for gazillion times，你的iterator已
: 经move 了gazillion times了
: let's say i call
: for (int i = 0; i < 10000; i++) {
: iter.hasNext();
: }
: iter.next(); // u need to return the first positive element
: with the way u implemented it, u would return the 10000th positive element

f*a2010-06-22 07:06

15 楼

should be queue?
哎， leetcode上做过那个binary tree的iterator，也是stack。。。

【在 n**s 的大作中提到】

: 用一个stack来保存hasNext()取出的正整数就可以了。
: 每次调用hasNext()，检查stack是否为空。空的话取出下一个正整数压入stack。不为
: 空返回stack顶上元素。
: 每次调用next()，也检查stack是否为空，不为空pop stack即可。
:
: /* */) 的大作中提到: 】

n*s2010-06-22 07:06

16 楼

其实简单的，不需要用queue，也不需要用stack。
就一个变量即可。0代表空，正数代表对应正整数。

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: should be queue?
: 哎， leetcode上做过那个binary tree的iterator，也是stack。。。

A*g2010-06-22 07:06

17 楼

hasNext实际上是去call integeriterator的next,加一个buffer，把读出的数放里面
Next先去看buffer，如果空，再去用hasNext把下一个搞出来
我上礼拜二面试做了一个类似的题，现在看起来，这个东西挺流行啊。
当时也是没一次写对，被找了错，改了才通过。

R*d2010-06-22 07:06

18 楼

方便起见，就用了ArrayList，不过意思是一样的。
public class PositiveIntegerIterator
{
private int prev = -1;
private Iterator it;
public PositiveIntegerIterator(Iterator it){
this.it = it;
}
public boolean hasNext(){
if(prev > 0){
return true;
}
while(it.hasNext()){
prev = it.next();
if(prev > 0){
return true;
}
}
return false;
}
public Integer next(){
int num;
if(prev > 0){
num = prev;
prev = -1;
return num;
}
if(this.hasNext()){
num = prev;
prev = -1;
return num;
}
return null;
}
public void remove(){
if(prev > 0){
prev = -1;
it.remove();
}else if(it.hasNext()){
prev = -1;
it.remove();
}
}
public static void main(String[] args){
ArrayList arr = new ArrayList();
arr.add(1);
arr.add(-2);
arr.add(3);
arr.add(7);
arr.add(-4);
Iterator it = arr.iterator();
PositiveIntegerIterator lPositiveIntegerIterator = new
PositiveIntegerIterator(it);
while(lPositiveIntegerIterator.hasNext()){
System.out.println(lPositiveIntegerIterator.next());
}
}
}

n*s2010-06-22 07:06

19 楼

一个简单的做法。
class PositiveIterator {
public:
PositiveIterator (IntegerIterator & it) : m_it(it), m_cur_val(0) {}
bool hasNext() {
if (m_cur_val) {
return true;
}

while (m_it.hasNext()) {
int tmp = m_it.next()
if (tmp>0) {
m_cur_val = tmp;
return true;
}
}
return false;
}
int next() {
if(m_cur_val || hasNext()) {
int tmp = m_cur_val;
m_cur_val=0;
return tmp;
}
return 0;
}
void remove() {
if(m_cur_val || hasNext()) {
m_cur_val=0;
m_it.remove();
}
}
private:
int m_cur_val;
IntegerIterator m_it;
};

f*a2010-06-22 07:06

20 楼

我后来也是这么写，然后碰到next（），就直接return 那个Integer，但发现如果
next（）； next（）；就不对了
其实，只要把那个变量change 成0 at the end of next就行了
private Integer x;
boolean hasNext（） {
if (x == null) {
while (itr.hasNext()) {
Integer y = itr.next();
if (y > 0) { x = y; return true;}
}
return false;
} else {
return true;
}
}
int next() {

if (hasNext()) {
int tmp = x;
x = null;
return tmp;

}
else
throw...
}

【在 n**s 的大作中提到】

: 其实简单的，不需要用queue，也不需要用stack。
: 就一个变量即可。0代表空，正数代表对应正整数。
:
: /* */) 的大作中提到: 】

c*e2010-06-22 07:06

21 楼

就跟read4一样呗　hasnext()的数先存着

l*82010-06-22 07:06

22 楼

用两个index，一个指向当前，一个指向next

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 我后来也是这么写，然后碰到next（），就直接return 那个Integer，但发现如果
: next（）； next（）；就不对了
: 其实，只要把那个变量change 成0 at the end of next就行了
: private Integer x;
: boolean hasNext（） {
: if (x == null) {
: while (itr.hasNext()) {
: Integer y = itr.next();
: if (y > 0) { x = y; return true;}
: }

f*a2010-06-22 07:06

23 楼

哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
做一做，也就熟了。

【在 l*****8 的大作中提到】

: 用两个index，一个指向当前，一个指向next
:
: /* */) 的大作中提到: 】

s*72010-06-22 07:06

24 楼

嗯，看到了，想简单了
单独一个变量记录下个一个正数, 不过remove有问题，因为hasNext过后，指针到下一
个正数，就没办法删掉上一个next过的正数
比如 1,-1,2
next(); // get 1，iter到1后面
hasNext(); // test 2, iter到2后面
remove(); 删掉2，没法删掉1
这个题估计不考虑remove, 或者根据implementation来写具体的remove
class PositiveIterator{
IntergerIterator iter;
int nextPositive;
Integer P;
NoSuchElementException e = new NoSuchElementException();
public PositiveIterator(IntegerIterator iter){
this.iter=iter;
nextPositive = -1;
}
public int next(){
if(hasNext()) {
int ret = nextPositive;
nextPositive = -1;
return ret;
}
else throw e;
}
private int findNextPositive(){
if(!iter.hasNext()) return -1;
int n = iter.next();
if(n>0) return n;
return findNextPositive();
}
public boolean hasNext(){
if(nextPositive>0) return true;
nextPositive = findNextPositive();
return nextPositive>0;
}
public void remove(){
}
}

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

I*s2010-06-22 07:06

25 楼

这个C＋＋版本的应该可以。但是这个remove() 函数是不是效率会有点低O(n).
// Iterator: input: int array of positive/negative int, output: positive int.
class Iterator {
vector A;
int i;
int nextVal;
bool hasNextVal;
void getNext() {
while (i < A.size() && A[i] <= 0) { ++ i; }
if (i == A.size()) {
hasNextVal = false;
return;
}
hasNextVal = true;
nextVal = A[i ++];
}
public:
Iterator(vector &v) {
A = v;
i = 0;
getNext();
}
bool hasNext() { return hasNextVal; }

int next() {
if (! hasNext()) { return -1; }
int v = nextVal; getNext(); return v;
}
};

y*s2010-06-22 07:06

26 楼

写了一个，没有考虑remove的情况。请大家指正：
private class PositiveIterator implements Iterator {
private Iterator iter = new IntegerIterator();
private int curr = -1;
public boolean hasNext() {
while (iter.hasNext() && curr < 0) {
curr = iter.next();
}
if (curr < 0)
return false;
else
return true;
}
public int next() {
if (!hasNext())
throw new NoSuchElementException();
int res = curr;
curr = -1;
return res;
}
}

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

m*g2010-06-22 07:06

27 楼

1. 写一个nextPositiveInt(); 里面用next()找到下一下positive int, 然后返回给调
用者
2. 用一个变量保存上次找到的positive int
3. hasNext 查一下有没有上次找到的positive int, 有就true, otherwise call
nextPositiveInt(), 然后保存起来，没找到就返回false
4. next查一下有没有保存的positive int, 有就直接返回，否则call
nextPositiveInt（）

d*i2010-06-22 07:06

28 楼

不要说next不对我觉得getnext这样也不对吧我理解只有调了next iterator才会移动
假如1 2 -1 连续调第二次getnext的时候还是要返回true 而不是返回false 对吧

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

e*u2010-06-22 07:06

29 楼

是不是就是filter_Iterator? 是不是要加个peek(),还有hasPeek()...

m*52010-06-22 07:06

30 楼

Java:
public class PositiveIterator {
public static void main(String[] args) {
List list = new ArrayList();
for(int i = 0; i < 10; i++) {
list.add(i);
list.add(-i);
}
System.out.println(list.toString());
PositiveIterator posIter = new PositiveIterator(list.iterator());
for(int i = 0; i < 100; i++)
System.out.println(posIter.hasNext());

while(posIter.hasNext()) {
System.out.print(posIter.next() + ", ");
}
}
private final Iterator iter;
private int curr = -1;
public PositiveIterator(Iterator iter) {
this.iter = iter;
}
public boolean hasNext() {
if(curr > 0)
return true;
while(iter.hasNext()) {
int val = iter.next();
if (val > 0) {
curr = val;
return true;
}
}
return false;
}
public int next() {
int res = curr;
curr = -1;
return res;
}

f*a2010-06-22 07:06

31 楼

没刷过iterator的题，面试被问一个PositiveInteger的Iterator，
就是给你个IntegerIterator，（iterator over an array），写个
PositiveIterator。iterate over positive integer（next， hasNext, remove)
刚一看，觉得还行啊，然后一写，不大对，然后一个中国面试官，还挺照顾，给
我hint，我电话里也听不清楚。。。

y*e2010-06-22 07:06

32 楼

哪个公司啊？最近iterator的题大火吧，leetcode大神赶快加进leetcode里吧

f*a2010-06-22 07:06

33 楼

公司不重要。。。
我这题是：
given an IntegerIterator （which implements hasNext, next, remove),
implement a PositiveIterator that has hasNext, next, remove

【在 y*****e 的大作中提到】

: 哪个公司啊？最近iterator的题大火吧，leetcode大神赶快加进leetcode里吧

n*s2010-06-22 07:06

34 楼

都给你一个IntegerIterator了。。。

f*a2010-06-22 07:06

35 楼

你implement个看看

【在 n*******s 的大作中提到】

: 都给你一个IntegerIterator了。。。

l*82010-06-22 07:06

36 楼

直接调用IntegerIterator的函数，碰到负数就跳过？

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 你implement个看看

f*a2010-06-22 07:06

37 楼

老兄，我也一开始以为这样，但你想想
1）what if the user calls "hasNext()" gazillion times
2) what if the user calls "next()" directly?
你写一写让我看看

【在 l*****8 的大作中提到】

: 直接调用IntegerIterator的函数，碰到负数就跳过？
:
: /* */) 的大作中提到: 】

m*92010-06-22 07:06

38 楼

先遍历一遍把positive integer找出来放在linked list里？

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 老兄，我也一开始以为这样，但你想想
: 1）what if the user calls "hasNext()" gazillion times
: 2) what if the user calls "next()" directly?
: 你写一写让我看看

s*72010-06-22 07:06

39 楼

好像不难，我写个试试，大家给看看
IntergerIterator iter;
NoSuchElementException e = new NoSuchElementException();
public int next(){
if(!iter.hasNext()) throw e;
int n = iter.next();
return n>0?n:next();
}
public boolean hasNext(){
if(!iter.hasNext()) return false;
int n = iter.next();
return n>0?true:hasNext();
}
public void remove(){
iter.remove();
}
想简单了，hasNext移动iter，见笑了

f*a2010-06-22 07:06

40 楼

你这个就是我一开始以为的。
但你看看你的hasNext, 如果我call hasNext for gazillion times，你的iterator已
经move 了gazillion times了
let's say i call
for (int i = 0; i < 10000; i++) {
iter.hasNext();
}
iter.next(); // u need to return the first positive element
with the way u implemented it, u would return the 10000th positive element

【在 s******7 的大作中提到】

: 好像不难，我写个试试，大家给看看
: IntergerIterator iter;
: NoSuchElementException e = new NoSuchElementException();
: public int next(){
: if(!iter.hasNext()) throw e;
: int n = iter.next();
: return n>0?n:next();
: }
: public boolean hasNext(){
: if(!iter.hasNext()) return false;

n*s2010-06-22 07:06

41 楼

不对。
先调用hasNext()，已经把下一个正整数取出来了。再调用next()，又跳到下一个正整
数了，明显错过了一个正整数。

【在 s******7 的大作中提到】

: 好像不难，我写个试试，大家给看看
: IntergerIterator iter;
: NoSuchElementException e = new NoSuchElementException();
: public int next(){
: if(!iter.hasNext()) throw e;
: int n = iter.next();
: return n>0?n:next();
: }
: public boolean hasNext(){
: if(!iter.hasNext()) return false;

n*s2010-06-22 07:06

42 楼

用一个stack来保存hasNext()取出的正整数就可以了。
每次调用hasNext()，检查stack是否为空。空的话取出下一个正整数压入stack。不为
空返回stack顶上元素。
每次调用next()，也检查stack是否为空，不为空pop stack即可。

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 你这个就是我一开始以为的。
: 但你看看你的hasNext, 如果我call hasNext for gazillion times，你的iterator已
: 经move 了gazillion times了
: let's say i call
: for (int i = 0; i < 10000; i++) {
: iter.hasNext();
: }
: iter.next(); // u need to return the first positive element
: with the way u implemented it, u would return the 10000th positive element

f*a2010-06-22 07:06

43 楼

should be queue?
哎， leetcode上做过那个binary tree的iterator，也是stack。。。

【在 n**s 的大作中提到】

: 用一个stack来保存hasNext()取出的正整数就可以了。
: 每次调用hasNext()，检查stack是否为空。空的话取出下一个正整数压入stack。不为
: 空返回stack顶上元素。
: 每次调用next()，也检查stack是否为空，不为空pop stack即可。
:
: /* */) 的大作中提到: 】

n*s2010-06-22 07:06

44 楼

其实简单的，不需要用queue，也不需要用stack。
就一个变量即可。0代表空，正数代表对应正整数。

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: should be queue?
: 哎， leetcode上做过那个binary tree的iterator，也是stack。。。

A*g2010-06-22 07:06

45 楼

hasNext实际上是去call integeriterator的next,加一个buffer，把读出的数放里面
Next先去看buffer，如果空，再去用hasNext把下一个搞出来
我上礼拜二面试做了一个类似的题，现在看起来，这个东西挺流行啊。
当时也是没一次写对，被找了错，改了才通过。

R*d2010-06-22 07:06

46 楼

方便起见，就用了ArrayList，不过意思是一样的。
public class PositiveIntegerIterator
{
private int prev = -1;
private Iterator it;
public PositiveIntegerIterator(Iterator it){
this.it = it;
}
public boolean hasNext(){
if(prev > 0){
return true;
}
while(it.hasNext()){
prev = it.next();
if(prev > 0){
return true;
}
}
return false;
}
public Integer next(){
int num;
if(prev > 0){
num = prev;
prev = -1;
return num;
}
if(this.hasNext()){
num = prev;
prev = -1;
return num;
}
return null;
}
public void remove(){
if(prev > 0){
prev = -1;
it.remove();
}else if(it.hasNext()){
prev = -1;
it.remove();
}
}
public static void main(String[] args){
ArrayList arr = new ArrayList();
arr.add(1);
arr.add(-2);
arr.add(3);
arr.add(7);
arr.add(-4);
Iterator it = arr.iterator();
PositiveIntegerIterator lPositiveIntegerIterator = new
PositiveIntegerIterator(it);
while(lPositiveIntegerIterator.hasNext()){
System.out.println(lPositiveIntegerIterator.next());
}
}
}

n*s2010-06-22 07:06

47 楼

一个简单的做法。
class PositiveIterator {
public:
PositiveIterator (IntegerIterator & it) : m_it(it), m_cur_val(0) {}
bool hasNext() {
if (m_cur_val) {
return true;
}

while (m_it.hasNext()) {
int tmp = m_it.next()
if (tmp>0) {
m_cur_val = tmp;
return true;
}
}
return false;
}
int next() {
if(m_cur_val || hasNext()) {
int tmp = m_cur_val;
m_cur_val=0;
return tmp;
}
return 0;
}
void remove() {
if(m_cur_val || hasNext()) {
m_cur_val=0;
m_it.remove();
}
}
private:
int m_cur_val;
IntegerIterator m_it;
};

f*a2010-06-22 07:06

48 楼

我后来也是这么写，然后碰到next（），就直接return 那个Integer，但发现如果
next（）； next（）；就不对了
其实，只要把那个变量change 成0 at the end of next就行了
private Integer x;
boolean hasNext（） {
if (x == null) {
while (itr.hasNext()) {
Integer y = itr.next();
if (y > 0) { x = y; return true;}
}
return false;
} else {
return true;
}
}
int next() {

if (hasNext()) {
int tmp = x;
x = null;
return tmp;

}
else
throw...
}

【在 n**s 的大作中提到】

: 其实简单的，不需要用queue，也不需要用stack。
: 就一个变量即可。0代表空，正数代表对应正整数。
:
: /* */) 的大作中提到: 】

c*e2010-06-22 07:06

49 楼

就跟read4一样呗　hasnext()的数先存着

l*82010-06-22 07:06

50 楼

用两个index，一个指向当前，一个指向next

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 我后来也是这么写，然后碰到next（），就直接return 那个Integer，但发现如果
: next（）； next（）；就不对了
: 其实，只要把那个变量change 成0 at the end of next就行了
: private Integer x;
: boolean hasNext（） {
: if (x == null) {
: while (itr.hasNext()) {
: Integer y = itr.next();
: if (y > 0) { x = y; return true;}
: }

f*a2010-06-22 07:06

51 楼

哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
做一做，也就熟了。

【在 l*****8 的大作中提到】

: 用两个index，一个指向当前，一个指向next
:
: /* */) 的大作中提到: 】

s*72010-06-22 07:06

52 楼

嗯，看到了，想简单了
单独一个变量记录下个一个正数, 不过remove有问题，因为hasNext过后，指针到下一
个正数，就没办法删掉上一个next过的正数
比如 1,-1,2
next(); // get 1，iter到1后面
hasNext(); // test 2, iter到2后面
remove(); 删掉2，没法删掉1
这个题估计不考虑remove, 或者根据implementation来写具体的remove
class PositiveIterator{
IntergerIterator iter;
int nextPositive;
Integer P;
NoSuchElementException e = new NoSuchElementException();
public PositiveIterator(IntegerIterator iter){
this.iter=iter;
nextPositive = -1;
}
public int next(){
if(hasNext()) {
int ret = nextPositive;
nextPositive = -1;
return ret;
}
else throw e;
}
private int findNextPositive(){
if(!iter.hasNext()) return -1;
int n = iter.next();
if(n>0) return n;
return findNextPositive();
}
public boolean hasNext(){
if(nextPositive>0) return true;
nextPositive = findNextPositive();
return nextPositive>0;
}
public void remove(){
}
}

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

I*s2010-06-22 07:06

53 楼

这个C＋＋版本的应该可以。但是这个remove() 函数是不是效率会有点低O(n).
// Iterator: input: int array of positive/negative int, output: positive int.
class Iterator {
vector A;
int i;
int nextVal;
bool hasNextVal;
void getNext() {
while (i < A.size() && A[i] <= 0) { ++ i; }
if (i == A.size()) {
hasNextVal = false;
return;
}
hasNextVal = true;
nextVal = A[i ++];
}
public:
Iterator(vector &v) {
A = v;
i = 0;
getNext();
}
bool hasNext() { return hasNextVal; }

int next() {
if (! hasNext()) { return -1; }
int v = nextVal; getNext(); return v;
}
};

y*s2010-06-22 07:06

54 楼

写了一个，没有考虑remove的情况。请大家指正：
private class PositiveIterator implements Iterator {
private Iterator iter = new IntegerIterator();
private int curr = -1;
public boolean hasNext() {
while (iter.hasNext() && curr < 0) {
curr = iter.next();
}
if (curr < 0)
return false;
else
return true;
}
public int next() {
if (!hasNext())
throw new NoSuchElementException();
int res = curr;
curr = -1;
return res;
}
}

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

m*g2010-06-22 07:06

55 楼

1. 写一个nextPositiveInt(); 里面用next()找到下一下positive int, 然后返回给调
用者
2. 用一个变量保存上次找到的positive int
3. hasNext 查一下有没有上次找到的positive int, 有就true, otherwise call
nextPositiveInt(), 然后保存起来，没找到就返回false
4. next查一下有没有保存的positive int, 有就直接返回，否则call
nextPositiveInt（）

d*i2010-06-22 07:06

56 楼

不要说next不对我觉得getnext这样也不对吧我理解只有调了next iterator才会移动
假如1 2 -1 连续调第二次getnext的时候还是要返回true 而不是返回false 对吧

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

e*u2010-06-22 07:06

57 楼

是不是就是filter_Iterator? 是不是要加个peek(),还有hasPeek()...

m*52010-06-22 07:06

58 楼

Java:
public class PositiveIterator {
public static void main(String[] args) {
List list = new ArrayList();
for(int i = 0; i < 10; i++) {
list.add(i);
list.add(-i);
}
System.out.println(list.toString());
PositiveIterator posIter = new PositiveIterator(list.iterator());
for(int i = 0; i < 100; i++)
System.out.println(posIter.hasNext());

while(posIter.hasNext()) {
System.out.print(posIter.next() + ", ");
}
}
private final Iterator iter;
private int curr = -1;
public PositiveIterator(Iterator iter) {
this.iter = iter;
}
public boolean hasNext() {
if(curr > 0)
return true;
while(iter.hasNext()) {
int val = iter.next();
if (val > 0) {
curr = val;
return true;
}
}
return false;
}
public int next() {
int res = curr;
curr = -1;
return res;
}

a*e2010-06-22 07:06

59 楼

其他都好做 remove 才是大问题。
除非有 pee（）

c*e2010-06-22 07:06

60 楼

如果只是传入一个IntegerIterator，这是不可能做到的，. Iterator 是不能拷贝的
，一旦move to next(), 就没法实现remove()
你确定你的条件是正确的？？

/* */) 的大作中提到: 】

【在 f********a 的大作中提到】

: 哪来index。。。。，不烦了，觉得面试，碰到自己不熟的，就这么挂了。。。
: 做一做，也就熟了。

M*w2010-06-22 07:06

61 楼

class PositiveIterator: public IntegerIterator
{
private:
bool Isnextpos;
int nextPos;
bool getNextPos()
{
while(1)
{
if(!getNext()) return false;
int val = getNext();
if(val>0)
{
isNextPos = true;
nextpos = val;
return true;
}
}
return false;
}
Public:
PositiveIterator
{
IsNextpos = getNextPos();
}
bool hasnextpos()
{
return IsNextPos;
}
int nextpos()
{
val = nextpos;
IsNextpos = getNextPos();
return val;
}
}

【在 l*****8 的大作中提到】

: 用两个index，一个指向当前，一个指向next
:
: /* */) 的大作中提到: 】