红黑树无效转换

Question

我无法越过红黑树的初始化。 每当我编译时，都会出现以下错误。

redBlackTree.h:81:28: error: invalid conversion from ‘long int’ to ‘nodeColor’ [-fpermissive]
  nodeType<myType> *x = new nodeType<myType>;
                            ^
redBlackTree.h:10:8: error: invalid conversion from ‘long int’ to ‘nodeColor’ [-fpermissive]
 struct nodeType
        ^
redBlackTree.h:81:28: note: synthesized method ‘nodeType<int>::nodeType()’ first required here 
  nodeType<myType> *x = new nodeType<myType>;

我也无法搜索树以确保树中尚未存在值。 我可以想到当前的方法，但是我仍然在树中得到重复的结果。

if(nd != NULL)
{
if(nd->keyValue == x)
    return true;

return ((search(x, nd->right)) || (search(x, nd->left)));
}

return false;

它在插入功能下。 可能是我声明变量的方式吗？ 我们应该遵循一个特定的模板，它说要创建一个新的nodeType，但不能这样做。 删除它会导致程序出现段错误。

#ifndef REDBLACKTREE_H
#define REDBLACKTREE_H
#include <iostream>
#include <sstream>
using namespace std;

enum nodeColor { RED, BLACK };

template<class myType>
struct nodeType
{
    myType  keyValue = keyValue;
    nodeColor color = NULL;
    nodeType *left = NULL;
    nodeType *right = NULL;
    nodeType *parent = NULL;
};

template <class myType> 
class redBlackTree
{

public:

    redBlackTree(){};
    ~redBlackTree();
    void destroyTree();
    unsigned int countNodes() const;
    unsigned int height() const;
    void printTree() const;
    void insert(myType);
    bool search(myType);

private:
    nodeType<myType> *root = NULL;
    bool search(myType, nodeType<myType> *);
    void destroyTree(nodeType<myType> *);
    unsigned int countNodes(nodeType<myType> *) const;
    unsigned int height(nodeType<myType> *) const;
    void printTree(nodeType<myType> *) const;
    void rightRotate(nodeType<myType> *);
    void leftRotate(nodeType<myType> *);

};

//template <class myType>
//redBlackTree<myType>::redBlackTree():root(NULL)
//{
//};
template <class myType> 
redBlackTree<myType>::~redBlackTree()
{
    destroyTree();
}
template <class myType>
void redBlackTree<myType>::destroyTree()
{
    destroyTree(root);
};
template <class myType>
unsigned int redBlackTree<myType>::countNodes() const
{
    return countNodes(root);
};
template <class myType>
unsigned int redBlackTree<myType>::height() const
{
    return height(root);
};
template <class myType>
void redBlackTree<myType>::printTree() const
{
    printTree(root);
};
template <class myType>
void redBlackTree<myType>::insert(myType value)
{
    if(search(value))
        return;

    nodeType<myType> *x = new nodeType<myType>;
    x->right = NULL;
    x->left = NULL;
    x->parent = NULL;
    x->keyValue = value;
    x->color = RED;

    if(root == NULL)
    {
        root = x;
        x->color = BLACK;
        return;
    }

    nodeType<myType> *curr = root;
    if(curr->keyValue > x->keyValue)
    {   
        curr->left = x;
        x->parent = curr;
        x->color = RED;
    }
    else
    {
        curr->right = x;
        x->parent = curr;
        x->color = RED;
    }

    while(x != root && x->parent->color == RED)
    {
        if(x->parent == x->parent->parent->left)
        {
            if(x->parent->parent->right != NULL && x->parent->parent->color == RED)
            {
                x->parent->color = BLACK;
                x->parent->parent->right->color = BLACK;
                x->parent->parent->color = RED;
                x = x->parent->parent;
            }
            else
            {
                if(x == x->parent->right)
                {
                    x = x->parent;
                    leftRotate(x);
                }

                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                rightRotate(x->parent->parent);
            }
        }
        else
        {
            if(x->parent->parent->left != NULL && x->parent->parent->color == RED)
            {
                x->parent->color = BLACK;
                x->parent->parent->left->color = BLACK;
                x->parent->parent->color = RED;
                x = x->parent->parent;
            }
            else
            {
                if(x == x->parent->right)
                {
                    x = x->parent;
                    rightRotate(x);
                }

                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                leftRotate(x->parent->parent);
            }
        }

        if(x == root)
            x->color = BLACK;
    }

};

template <class myType>
bool redBlackTree<myType>::search(myType x)
{
    search(x, root);
};

template <class myType>
bool redBlackTree<myType>::search(myType x, nodeType<myType> *nd)
{
    if(nd == NULL)
        return 0;

    search(x, nd->left);
    search(x, nd->right);

    if(nd->keyValue == x)
    return true;

    else
    return false;
};
template <class myType>
void redBlackTree<myType>::destroyTree(nodeType<myType> *node)
{
    if(node==NULL)
        return;

    destroyTree(node->left);
    destroyTree(node->right);
    delete node;    

};
template <class myType>
unsigned int redBlackTree<myType>::countNodes(nodeType<myType> *nd) const
{
    if(nd==NULL)
        return 0;

    return (countNodes(nd->left) + countNodes(nd->right) + 1);
};
template <class myType>
unsigned int redBlackTree<myType>::height(nodeType<myType> *nd) const
{
    int leftHeight = 0;
    int rightHeight = 0;
    if(nd==NULL)
        return 1;

    leftHeight = leftHeight + height(nd->left);
    rightHeight = rightHeight + height(nd->right);

    if(leftHeight == rightHeight)
        return leftHeight;
    else if(leftHeight > rightHeight)
        return leftHeight;
    else
        return rightHeight;
};
template <class myType>
void redBlackTree<myType>::printTree(nodeType<myType> *nd) const
{
    if(nd == NULL)
        return;

    printTree(nd->left);
    cout << nd->keyValue;
    printTree(nd->right);
    cout << nd->keyValue;
};
template <class myType>
void redBlackTree<myType>::rightRotate(nodeType<myType> *y)
{

    nodeType<myType> *x = y->left;
    x->left = x->right;

    if(x->right != NULL)
        x->right->parent = y;

    x->parent = y->parent;

    if(x->parent == NULL)
        root = x;
    else if(y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;

    x->right = y;
    y->parent = x;

};
template <class myType>
void redBlackTree<myType>::leftRotate(nodeType<myType> *x)
{
    nodeType<myType> *y = y->right;
    x->right = y->left;

    if(x->right != NULL)
        root = y;
    else if(x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;

    x->left = x;
    x->parent = y;

};

#endif

Answer 1

该问题是由以下行引起的：

nodeColor color = NULL;

NULL不是color的有效值。 使用有效的值，例如：

nodeColor color = RED;

---

另外，线

myType  keyValue = keyValue;

将会是一个问题。 它初始化keyValue与未初始化值keyValue 。使的该行东西RHS更合适，如：

myType  keyValue = {};

---

您错过了第一个search功能的return 。

template <class myType>
bool redBlackTree<myType>::search(myType x)
{
   return search(x, root);
   // ^^
}

---

你不需要; 在成员函数定义的末尾。 您已经在某些函数定义中使用了它们。 您应该删除它们。