Java Konstruktoren: Tatsächliche und formale Argumentlisten unterscheiden sich in der Länge

Question

So bekam ich eine Aufgabe, in der ich viele Fehler in einem etwas großen und schlampigen Code finden und beheben musste. Ich bin bei dem, was der letzte zu sein scheint, und ich kann die Lösung für diesen nicht finden. Ich habe ähnliche Szenarien gelesen, in denen Leute den gleichen Fehler bekommen, aber ich kann sie nicht mit meinem Code in Verbindung bringen. Dies ist, wo ich den Fehler: Temp = new BinaryNode(AId,AValue);

constructor BinaryNode in class BinaryNode cannot be applied to given types;

Btree Klasse

package evidencia2datos; 


public class BTree { 
private BinaryNode Root; 
    private int NoOfNodes; 

    private BTree() 
     {          
     Root = null; 
     NoOfNodes = 0; 
} 
    //operaciones 
    public boolean IsEmpty() //busca valor en NoOfNodes 
     { 
     return(NoOfNodes == 0); 
     } 

    public BinaryNode gRoot() 
     { 
     return Root; 
     } 

    public int Count() //valor de NoOfNodes 
     { 
     return NoOfNodes; 
     } 

    //size del arbol 
    public int Size(BinaryNode ATree) 
     { 
     if (ATree == null) 
     return 0; 
     else 
     return(1 + Size(ATree.gLeft()) + Size(ATree.gRight())); 
     } 

    //niveles 
    public int Height(BinaryNode ATree) 
     { 
     if (ATree == null) 
     return 0; 
     else 
     return (1 + Math.max(Height(ATree.gLeft()), Height(ATree.gRight()))); 
     } 

    //traversales 
    public void PreOrder(BinaryNode ATree) 
     { 
     if (ATree != null) 
     { 
     System.out.println(ATree.gData()); 
     PreOrder(ATree.gLeft()); 
     PreOrder(ATree.gRight()); 
     } 
     } 

    public void InOrder(BinaryNode ATree) 
     { 
     if (ATree != null) 
     { 
     InOrder(ATree.gLeft()); 
     System.out.println(ATree.gData()); 
     InOrder(ATree.gRight()); 
     } 
     } 

public void PostOrder(BinaryNode ATree) 
     { 
     if (ATree != null) 
     { 
     PostOrder(ATree.gLeft()); 
     PostOrder(ATree.gRight()); 
     System.out.println(ATree.gData()); 
     } 
     } 

//insertar valores 
    public void Insert(int AId, Object AValue) 
     { 



     BinaryNode Temp,Current,Parent; 
     if(Root == null)//tree is empty 
     { 
     Temp = new BinaryNode(AId,AValue); 
     Root = Temp; 
     NoOfNodes++; 
     } 
     else//tree is not empty 
     { 
     Temp = new BinaryNode(AId,AValue); 
     Current = Root; 
     while(true)//never ending while loop 
      { 
      Parent = Current; 
      if(AId < Current.gKey()) 
      {//go left 
      Current = Current.gLeft(); 
       if (Current == null) 
       { 
       Parent.sLeft(Temp); 
       NoOfNodes++; 
       return;//jump out of loop 
       } 
      } 
      else 
      { //go right 
      Current = Current.gRight(); 
      if(Current == null) 
       { 
       Parent.sRight(Temp); 
       NoOfNodes++; 
       return; 
       } 
      } 
      } 
     } 

    } 

    //search 
    public BinaryNode Find(int AKey) 
     { 
     BinaryNode Current = null; 
     if(!IsEmpty()) 
     { 
     Current = Root; //start search at top of tree 
     while(Current.gKey() != AKey) 
      { 
      if(AKey < Current.gKey()) 
      Current = Current.gLeft(); 
      else 
      Current = Current.gRight(); 
      if(Current == null) 
      return null; 
      } 
     } 
     return Current; 
     } 

    //succesor 

    public BinaryNode GetSuccessor(BinaryNode ANode) 
    { 
    BinaryNode Current,Successor,SuccessorParent; 
    Successor = ANode; 
    SuccessorParent = ANode; 
    Current = ANode.gRight(); 
    while(Current !=null) 
     { 
     SuccessorParent = Successor; 
     Successor = Current; 
     Current = Current.gLeft(); 
     } 
    if(Successor != ANode.gRight()) 
     { 
     SuccessorParent.sLeft(Successor.gRight()); 
     Successor.sRight(ANode.gRight()); 
     } 
    return Successor; 
    } 

     public boolean Delete (int AKey) 
    { 
    BinaryNode Current, Parent; 
    boolean IsLeftChild = true; 
    Current = Root; 
    Parent = Root; 
    while (Current.gKey() != AKey) 
     { 
     Parent = Current; 
     if (AKey < Current.gKey()) 
     { 
     IsLeftChild = true; 
     Current = Current.gLeft(); 
} 
     else 
     { 
     IsLeftChild = false; 
     Current = Current.gRight(); 
     } 
     if(Current == null) 
     return false; 
     } 
     // if no children delete the node 
     if (Current.gLeft() == null && Current.gRight() == null) 
     { 
     if (Current == Root) 
      Root = Current.gLeft(); 
     else 
      if (IsLeftChild) 
      Parent.sLeft(Current.gRight()); 
      else 
      Parent.sRight(Current.gRight()); 
     } 
     // if no right child replace with left subtree 
     else 
     { 
     if (Current.gRight() == null) 
      { 
      if (Current == Root) 
    Root = Current.gRight(); 
      else 
      if (IsLeftChild) 
       Parent.sLeft(Current.gLeft()); 
      else 
       Parent.sRight(Current.gLeft()); 
      } 
     // if no left child replace with right subtree 
     else 
      { 
      if (Current.gLeft() == null) 
      { 
      if (Current == Root) 
       Root = Current.gLeft(); 
      else 
       if (IsLeftChild) 
       Parent.sLeft(Current.gRight()); 
       else 
       Parent.sRight(Current.gRight()); 
      } 
      // two children so replace in order of successor 
      else 
      { 
      BinaryNode Successor = GetSuccessor(Current); 
      if (Current == Root) 
       Root = Successor; 
      else 
       if (IsLeftChild) 
       Parent.sLeft(Successor); 
       else 
       Parent.sRight(Successor); 
      Successor.sLeft(Current.gLeft()); 
      } 
      } 
     } 
    NoOfNodes--; 
    return true; 
    } 

    public static void main(String[] args) { 
    BTree MyTree = new BTree();     
    BinaryNode NodeAt;       

    MyTree.Insert(12,"Jorge"); 
    MyTree.Insert(4,"Andres"); 
    MyTree.Insert(11,"Javier"); 
    MyTree.Insert(1,"Jose"); 
    MyTree.Insert(100,"Paty"); 
    MyTree.Delete(1); 
    MyTree.InOrder(MyTree.gRoot());  
    NodeAt = MyTree.Find(11); 

    if(NodeAt !=null) 
     System.out.println("Data in Node with Key 11 = " + NodeAt.gData()); 
    System.exit(0); 
    } 

} 

BinaryNode Klasse sagen

package evidencia2datos; 

public class BinaryNode { 
    private int Key; 
    private Object Data; 
    private BinaryNode Left; 
    private BinaryNode Right; 

    public BinaryNode() 
    { 
    java.util.Scanner scaniar = new java.util.Scanner(System.in); 
    System.out.print("Enter in Key Value: "); 
    Key = scaniar.nextInt(); 
    System.out.print("Enter in data: "); 
    Data = scaniar.nextInt(); 
    Left = null; 
    Right = null; 
} 


    //get 
    public int gKey() 
    { 
    return Key; 
    } 

    public Object gData() 
    { 
    return Data; 
    } 

    public BinaryNode gLeft() 
    { 
    return Left; 
    } 
    public BinaryNode gRight() 
    { 
    return Right; 
    } 

    //set 
    public void sKey(int AValue) 
    { 
    Key = AValue; 
    } 

    public void sData(Object AValue) 
    { 
    Data = AValue; 
    } 

    public void sLeft(BinaryNode AValue) 
    { 
    Left = AValue; 
    } 

    public void sRight(BinaryNode AValue) 
    { 
    Right = AValue; 
    } 


} 

Answer 1

Sie können einen neuen BinaryNode Konstruktor erstellen, die

zwei Argumente nimmt

BinaryNode(){ 
    ... 
} 

//Este es el nuevo constructor, como se puede observar 
//toma dos argumentos 
BinaryNode (int k, Object d){ 
    key = k; 
    data = d; 
    ... 
} 

Ich hoffe, das wird dir helfen.