Java에서 자체 트리 반복자 구현

Question

트리 탐색을위한 Iterator 인터페이스를 구현하려고합니다. "다음과 같은 오류가 발생합니다."(for Integer node : tr) 및 "treeIterator.java에서 호환되지 않는 유형이 확인되지 않거나 안전하지 않은 작업을 사용합니다." 이 오류를 해결할 수 없습니다. 누군가 문제를 지적 할 수 있습니까?

//class to implement the Iterator interace. 
class InorderItr implements Iterator { 



    public InorderItr(Node root) { 
     st = new Stack<Node>(); 
     this.root = root; 
    } 

    @Override 
    public boolean hasNext() { 
     //has Next 
    } 

    @Override 
    public Integer next(){ 
      //next node 
    } 

    @Override 
    public void remove(){ 
     throw new java.lang.UnsupportedOperationException("Remove not supported."); 
    } 
} 

//This class just makes sure that we use the foreach loop. 
class InorderTreeIterator implements Iterable { 

    Node root = null; 

    public InorderTreeIterator(Node root){ 
     this.root = root; 
    } 

    @Override 
    public Iterator<Integer> iterator(){ 
     try{ 
      return new InorderItr(this.root); 
     } catch(UnsupportedOperationException e){ 
      System.out.println(e.getMessage()); 
      return null; 
     } 
    } 
} 


class treeIterator { 

    public static void main(String arg[]){ 
     treeIterator obj = new treeIterator(); 
     //create tree. 
     InorderTreeIterator tr = new InorderTreeIterator(obj.root); 
     for(Integer node : tr){ 
      System.out.println(node); 
     } 
    } 
} 

추신 : 이것은 반복기 인터페이스를 구현하려는 첫 번째 시도입니다. 내가 따르지 않는 표준 관행이 있다면 지적 해주십시오.

당신은

Answer 1

Iterablegeneric 인터페이스입니다 감사합니다. 즉, 형식 매개 변수를 지정하지 않으면 원시 형식이되고 기본 데이터는 Object으로 처리됩니다.

변경이 다음에

class InorderItr implements Iterator 
class InorderTreeIterator implements Iterable 

에게 :

class InorderItr implements Iterator<Integer> 
class InorderTreeIterator implements Iterable<Integer> 

이 방법은 더 이상 원시 타입 (해당이되지 않은의 경고와 안전하지 않은 작업 컴파일러의 RID를 얻을 현재 제공), Iterator은 기본 데이터 유형이 Integer (Iterator 인터페이스의 type 매개 변수가 기본 데이터 유형이기 때문에)이므로 형식이 일치 함을 컴파일러에 알립니다.

Answer 2

반복기는 제네릭 유형입니다. 당신은 원시 Iterator 유형을 사용하는 경우, 반복자는 객체를 반환하고 루프해야

for (Object node : tr) 

대신 형태 보증 된 일반적인 Iterator<Integer> 사용해야

: 더 나은 이름을 선택, 또한

class InorderItr implements Iterator<Integer> { 

... 

class InorderTreeIterator implements Iterable<Integer> { 

당신의 수업. InorderItr은 InOrderIterator이어야합니다. InorderTreeIterator은 InorderTreeIterable이어야합니다. 반복자가 아닌 것을 "반복자"로 지칭하지 마십시오. 클래스 이름은 대문자로 시작하고 메소드 이름은 소문자로 시작하십시오.

Answer 3

Java 5 이상을 가정 할 때 : Iterator는 실제로 Iterator로 선언됩니다. 여기서 "E"는 Iterator에서 next()가 반환 한 클래스를 나타냅니다. 나는 당신이 원하는 것은 당신이 당신의 코드에서 정수를 왜 이해하지 못하는

public Node next() 

로 선언되어야한다)

InOrderIterator implements Iterator<Node> 

및 다음 (생각; 당신은 명확하게 노드 트리를 반복하려고 시도하고 있습니다. 공간에서

Answer 4

C에서 (좀) 구현 ++

#include<iostream> 
using namespace std; 
struct node 
{ 
    node *left; 
    node *right; 
    node *parent; 
    int data; 
} ; 

class bst 
{ 
public: 
    node *root; 
    node *currNode; 

    bst() 
    { 
     root=NULL; 
     currNode = NULL; 
    } 
    int isempty() 
    { 
     return(root==NULL); 
    } 
    void insert(int item); 
    void inordertrav(); 
    void inorder(node *); 
    int next(); 
    node *nextNode(node *root); 
    void bft(); 
}; 
void bst::insert(int item) 
{ 
    node *p=new node; 
    node *parent; 
    p->data=item; 
    p->left=NULL; 
    p->right=NULL; 
    p->parent = NULL; 
    parent=NULL; 
    if(isempty()) 
     root=p; 
    else 
    { 
     node *ptr; 
     ptr = root; 
     while(ptr!=NULL) 
     { 
      parent = ptr; 
      if(item > ptr->data)   
       ptr = ptr->right; 
      else 
       ptr=ptr->left; 
     } 
     if(item < parent->data) 
     { 
      parent->left = p; 
     } 
     else 
      parent->right = p; 
     p->parent = parent; 
    } 
} 
void bst::inordertrav() 
{ 
    inorder(root); 
} 
void bst::inorder(node *ptr) 
{ 
    if(ptr!=NULL) 
    { 
     inorder(ptr->left); 
     cout<<" "<<ptr->data<<"  "; 
     inorder(ptr->right); 
    } 
} 

int bst::next() 
{ 
// If currNode is NULL and find the left most node using a while loop. 
    if (currNode == NULL) 
    { 
     cout << "First node data" << endl; 
     node *tmp = root; 
     while (tmp->left != NULL) 
      tmp = tmp->left; 

     currNode = tmp; 
     return currNode->data; 
    } 
    cout << endl << "Current Node is - " << currNode->data << endl; 
    if (currNode->right) 
    { 
     node *tmp = currNode->right; 
     while (tmp->left) // find the leftmost node for this right subtree in recursive way without recursion 
      tmp = tmp->left; 
     currNode = tmp; 
     return currNode->data; 
    } 

    if (! currNode->right) // currNode does not have right child 
    { 
     if (currNode->parent->left && currNode->data == currNode->parent->left->data) // CurrNode is the left child 
     { 
      currNode = currNode->parent; 
      return currNode->data; 
     } 
     if (currNode->parent->right && currNode->data == currNode->parent->right->data) //CurrNode is the right child of the parent 
     { 
      //If the parent of the currNode (which is right child) is also a right child 
      //then this currNode is actually a leaf node and it nothing should be returned. 
      if (currNode->parent->parent->right && 
        currNode->parent->parent->right->data == currNode->parent->data) 
      { 
       cout << "The tree has been travered fully"; 
       return -1; 
      } 
      currNode = currNode->parent->parent; 
      return currNode->data; 
     } 
    } 
} 


int main() 
{ 
    bst b; 
    b.insert(52); 
    b.insert(25); 
    b.insert(50); 
    b.insert(40); 
    b.insert(45); 
    b.insert(20); 
    b.insert(75); 
    b.insert(65); 
    b.insert(78); 
    b.insert(23); 
    b.insert(15); 

    cout << "---- In order traversal using iterator -----" << endl; 
    int i; 
    do 
    { 
     i = b.next(); 
     cout << " " << i << " "; 
    }while (i != -1); 
    cout << endl; 
    cout<<endl; 
}