Here is a problem about the constructor. Why this error apears and how can I sol

Question

Here is a problem about the constructor. Why this error apears and how can I solve this problem?

Here is the constructor:

OurCSCE310Tree::OurCSCE310Tree( OurCSCE310Tree& other){
delete parent;
delete left;
delete right;
value = other.getValue();
parent = other.getParent();
left = other.getLeft();
right = other.getRight();
}

void OurCSCE310Tree::operator=( OurCSCE310Tree& other){
delete parent;
delete left;
delete right;
value = other.getValue();
parent = other.getParent();
left = other.getLeft();
right = other.getRight();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////

Here is where the error loacates

void OurCSCE310Tree::rotateLeft(){
   cout << "!!!" << endl;
   OurCSCE310Tree node1(*(this->getRight())); //ERROR
   OurCSCE310Tree node2(*this);
   this->getParent()->setRight(node2.getRight());
   this->setParent(node2.getRight());
   this->getRight()->getLeft()->setParent(node1.getParent());
   this->getRight()->setLeft(this);
   this->getRight()->setParent(node2.getParent());
   this->setRight(node1.getLeft());
}

Here is the information about this error:

no matching function for call to 'OurCSCE310Tree::OurCSCE310Tree(OurCSCE310Tree* const)'   

no matching function for call to 'OurCSCE310Tree::OurCSCE310Tree(OurCSCE310Tree*)'   

Explanation / Answer

#include "OurCSCE310Tree.h"
#include <iostream>
using namespace std;

int main(){
OurCSCE310Tree tree;
tree.insert( 19 );
tree.insert( 23 );
tree.insert( 31 );
tree.insert( 37 );
tree.deleteNode( 11 );
tree.deleteNode( 37 );
tree.deleteNode( 4 );
tree.deleteNode( 23 );
tree.printPreorder();
cout << endl;
tree.printInorder();
cout << endl;
tree.printPostorder();
cout << endl;
return 0;
}

OurCSCE310Tree.cpp

#include "OurCSCE310Tree.h"
#include <iostream>
#include <cmath>
using namespace std;

OurCSCE310Tree::OurCSCE310Tree(){
value = 0;
parent = NULL;
left = NULL;
right = NULL;
}

OurCSCE310Tree::OurCSCE310Tree( const OurCSCE310Tree& other){
delete parent;
delete left;
delete right;
value = other.value;
parent = other.parent;
left = other.left;
right = other.right;
}

void OurCSCE310Tree::operator=( const OurCSCE310Tree& other){
delete parent;
delete left;
delete right;
value = other.value;
parent = other.parent;
left = other.left;
right = other.right;
}

OurCSCE310Tree::~OurCSCE310Tree(){
delete left;
left = NULL;
delete right;
right = NULL;
}

OurCSCE310Tree* OurCSCE310Tree::getParent(){
return parent;
}

OurCSCE310Tree* OurCSCE310Tree::getLeft(){
return left;
}

OurCSCE310Tree* OurCSCE310Tree::getRight(){
return right;
}

int OurCSCE310Tree::getValue(){
return value;
}

void OurCSCE310Tree::setParent( OurCSCE310Tree* par ){
parent = par;
}

void OurCSCE310Tree::setLeft( OurCSCE310Tree* lft ){
left = lft;
}

void OurCSCE310Tree::setRight( OurCSCE310Tree* rght ){
right = rght;
}

void OurCSCE310Tree::setValue( int val ){
value = val;
}

void OurCSCE310Tree::insert( int val ){
if( !getValue() ){
    setValue( val );
}
else if( val < getValue() && !getLeft() ){
    left = new OurCSCE310Tree();
    left->setParent( this );
    left->setValue( val );
}
else if( val > getValue() && !getRight() ){
    right = new OurCSCE310Tree();
    right->setParent( this );
    right->setValue( val );
}
else if( val < getValue() ){
    left->insert( val );
}
else{
    right->insert( val );
}

if( getLeft() && getRight() && left->getHeight() > ( right->getHeight() + 2 ) || !getRight() && getLeft() && left->getHeight() > 2 ){
    rotateRight();
}

if( getLeft() && getRight() && right->getHeight() > ( left->getHeight() + 2 ) || !getLeft() && getRight() && getRight()->getHeight() > 2 ){
    rotateLeft();
}
}

void OurCSCE310Tree::printPreorder(){
if( getValue() ){
    cout << getValue();
}
if( getLeft() ) {
      if (getLeft()->getValue() == NULL) {
          getLeft()->printPreorder();
      }
      else {
        cout << ",";
        getLeft()->printPreorder();
      }
}
if( getRight() ){
    if(getRight()->getValue() == NULL){
        getRight()->printPreorder();
    }
    else {
        cout << ",";
        getRight()->printPreorder();
    }
}
}

void OurCSCE310Tree::printInorder(){
    if( getLeft() ) {
        if (getLeft()->getValue() == NULL) {
            getLeft()->printInorder();
        }
        else {
            getLeft()->printInorder();
            cout << ",";
        }
    }
if( getValue() ){
    cout << getValue();
}
    if( getRight() ){
        if(getRight()->getValue() == NULL){
            getRight()->printInorder();
        }
        else {
            getRight()->printInorder();
            cout << ",";
        }
    }
}

void OurCSCE310Tree::printPostorder(){
    if( getLeft() ) {
        if (getLeft()->getValue() == NULL) {
            getLeft()->printPostorder();
        }
        else {
            getLeft()->printPostorder();
            cout << ",";
        }
    }
    if( getRight() ){
        if(getRight()->getValue() == NULL){
            getRight()->printPostorder();
        }
        else {
            getRight()->printPostorder();
            cout << ",";
        }
    }
if( getValue() ){
      cout << getValue();
}
}

int OurCSCE310Tree::getHeight(){
if( getLeft() && !getRight() ){
    return getLeft()->getHeight() + 1;
}
else if( getRight() && !getLeft() ){
    return getRight()->getHeight() + 1;
}
else if( getRight() && getLeft() ){
    return fmax( getRight()->getHeight() , getLeft()->getHeight() ) + 1;
}
else if( getValue() && !getLeft() && !getRight() ){
    return 1;
}
return 0;
}

// *Works on some, produces massive numbers on others
void OurCSCE310Tree::rotateLeft() {

    OurCSCE310Tree *temp = getRight();                                //Hold pointer to n's right child
    setRight(temp->getLeft());                                       // Move temp 's left child to right child of n
    if (temp->getRight() != NULL)                                   // If the left child does exist
        temp->getRight()->setParent(getRight()->getParent());        // Reset the left child's parent
    if (getParent() == NULL) {                                      // If n was the root
        setParent(temp);                                                 // Make temp the new root
        temp->setParent(NULL);                                       // Root has no parent
    }
    else if (getParent()->getLeft() == getRight()->getParent()) {    // If n was the left child of its' parent
        getParent()->setLeft(temp);                                     // Make temp the new left child
    }
    else {                                                           // If n was the right child of its' parent
        getParent()->setRight(temp);                                 // Make temp the new right child
    }
    temp->setLeft(getRight()->getParent());                          // Move n to left child of temp
    setParent(temp);                                                 // Reset n's parent

}

// *Works on some, produces massive numbers on others
void OurCSCE310Tree::rotateRight(){

    right = new OurCSCE310Tree();
    right = getRight();
    left = right->getRight();
    right->setRight(right->getParent());
    left = right->getLeft();
    parent = right->getParent();
    value = right->getValue();
    right = right->getRight();

}

// Works on almost every test case AS IS
void OurCSCE310Tree::deleteNode( int key ){
   // If the current node is the key, delete it
    if(getValue() == key){
        setValue(NULL);
    }
  
   // If the key is smaller than the root's value, then it's in the left sub-tree (if it exists)
   else if( key < getValue() && getLeft() ){
        left->deleteNode(key);
    }
  
   // If the key is larger than the root's value, then it's in the right sub-tree (if it exists)
    else if( key > getValue() && getRight() ){
        right->deleteNode(key);
    }

}

OurCSCE310Tree.h
#ifndef OURCSCE310TREE_H
#define OURCSCE310TREE_H
using namespace std;

class OurCSCE310Tree{
public:
OurCSCE310Tree(void);
OurCSCE310Tree(const OurCSCE310Tree&);
~OurCSCE310Tree(void);
void operator=(const OurCSCE310Tree&);
OurCSCE310Tree* getParent(void);
OurCSCE310Tree* getLeft(void);
OurCSCE310Tree* getRight(void);
int getValue(void);
void setParent(OurCSCE310Tree*);
void setLeft(OurCSCE310Tree*);
void setRight(OurCSCE310Tree*);
void setValue(int);
void insert(int);
void printPreorder(void);
void printInorder(void);
void printPostorder(void);
void rotateLeft(void);
void rotateRight(void);
void deleteNode(int);
int getHeight();

private:
int value;
OurCSCE310Tree* parent;
OurCSCE310Tree* left;
OurCSCE310Tree* right;
};

#endif

Related Questions

Navigate

• Browse (All)
• Browse H
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.