Java：搜索節點樹結構的算法

Question

我正在用Java開發“家譜”程序，但我無法將自己的頭纏在搜索節點的算法上。

節點由名稱組成，並鏈接到伙伴，同級，子級和整數標識符。

我正在嘗試的算法已經走到了盡頭，我將非常感謝朝着正確方向發展。

基本上，每個節點都有一個數字標識符，我希望能夠讓用戶輸入一個數字，在樹中搜索每個節點，然后將一個節點插入為匹配節點的子節點，同級節點或伙伴。 樹形結構示例：

請注意，由於這是一項作業，因此我無法更改結構

Alice[2] <--partner-- John[1] 
                         |
                       Ted[3] --sibling--> Eric[4] --sibling--> Joanne[5]
                         |
                       Joe[6] --sibling--> Bret[7]

FamilyTree類別 ：

public class FamilyTree {

  private class FamilyTreeNode{ 
    private int identifier ;
    private String Name ;
    private FamilyTreeNode partner;
    private FamilyTreeNode sibling;
    private FamilyTreeNode child;

}

private FamilyTreeNode ancestor;
private FamilyTreeNode currentNode ;
private int indexNumber = 1;



public FamilyTree(){
    this.ancestor = new FamilyTreeNode();
    this.ancestor.Name = Input.getString("Enter ancestors Name: ");     
    this.ancestor.identifier = 0;
}

public FamilyTreeNode addChild(){       
    //Set up variables and create new node

    currentNode = ancestor;
    boolean matchFound = false ;
    FamilyTreeNode newFamilyNode = new FamilyTreeNode() ;
    newFamilyNode.Name = Input.getString("Enter Name");     
    //

    //Checking for existing Name        
    if(currentNode.child != null){
        currentNode = currentNode.child;        
        if(currentNode.Name.compareToIgnoreCase(newFamilyNode.Name) == 0){
            matchFound = true;
        }       
        while(currentNode.sibling != null){
            currentNode = currentNode.sibling;
            if(currentNode.Name.compareToIgnoreCase(newFamilyNode.Name) == 0){
                matchFound = true;
            }               
        }       
    }
    //      
    //Check for existing siblings, add to end of list
    currentNode = ancestor;

    if(currentNode.child == null){  
        newFamilyNode.identifier = indexNumber;
        currentNode.child = newFamilyNode ;
    }else{
        currentNode = currentNode.child;
        while (currentNode.sibling != null){                
            currentNode = currentNode.sibling;}
            if(matchFound == false){            
                indexNumber++;
                newFamilyNode.identifier = indexNumber;
                currentNode.sibling = newFamilyNode;
            }
            else{                   
                System.out.println("Name already exists");
            }
        }           
    //      
    return newFamilyNode ;
}

public FamilyTreeNode addPartner(){
     currentNode = ancestor ;
     FamilyTreeNode newPartnerNode = new FamilyTreeNode() ; 
     int currentNodeIdentifier;
     int partnerIdentifier;
     boolean insertPointFound = false ;
     display();
     partnerIdentifier = Input.getInteger("Input partner ID");
     while(insertPointFound == false){
         if(partnerIdentifier == currentNode.identifier){


         }else{
             currentNode
         }


     }



    return newPartnerNode;


}






public void display(){      
    currentNode = ancestor;
    System.out.println(currentNode.Name + " " + currentNode.identifier);
    if(currentNode.child != null){
        currentNode = currentNode.child;
        System.out.println(currentNode.Name + " " + currentNode.identifier);
            while(currentNode.sibling != null){
                currentNode = currentNode.sibling;
                System.out.println(currentNode.Name + " " + currentNode.identifier);
                }   

        }
    }
}

Answer 1

假設所有標識符都是唯一的，則可以使用任何樹遍歷算法來實現搜索。 這是一個示例DFS，可以解決您的問題（您可以根據需要修改此功能）。

boolean[] visited = new boolean[n];  // n is no. of nodes in the tree

public FamilyTreeNode dfs(FamilyTreeNode root, int searchKey) {
    if(root == null) {
        return null;
    }
    if(root.identifier == searchKey) {
        return root;
    }
    visited[root.identifier] = true;
    FamilyTreeNode next = null;
    if((root.partner != null) && (!visited[root.partner.identifier])) {
        next = dfs(root.partner, searchKey);
    }
    if(next != null) return next;
    if((root.sibling != null) && (!visited[root.sibling.identifier])) {
        next = dfs(root.sibling, searchKey);
    }
    if(next != null) return next;
    if((root.child != null) && (!visited[root.child.identifier])) {
        next = dfs(root.child, searchKey);
    }
    return next;
}