二叉树操作

#include <cstring>
#include <iostream>
#include <stack>
#include <queue>

using namespace std;

class Node
{
public:
    char info[50];
    Node* left;
    Node* right;

    Node(char *i, Node* l, Node* r)
    {
        strcpy(info,i);
        left=l;
        right=r;
    }
};

class BinarSearchTree
{
public:
    Node* ROOT;

public:
    BinarSearchTree():ROOT(NULL){}
    void insert(char* info);
    void find(char* info, Node** parent, Node** location);
    void inorder(Node* ptr);
    void preorder(Node* ptr);
    void postorder(Node* ptr);
    void levelorder(Node* ptr);//层序遍历
    void remove();
    void case_1(Node* parent, Node* current);
    void case_2(Node* parent, Node* current);
    void case_3(Node* parent, Node* current);
};

void BinarSearchTree::find(char* info, Node**parent, Node **currentNode)
{
    *currentNode=ROOT;
    *parent=NULL;

    while((*currentNode!=NULL) && (strcmp((*currentNode)->info, info)!=0))
    {
        *parent=*currentNode;
        if(strcmp(info, (*currentNode)->info)<0)
            *currentNode=(*currentNode)->left;
        else
            *currentNode=(*currentNode)->right;
    }
}

void BinarSearchTree::insert(char* info)
{
    Node* parent=NULL;
    Node* currentNode=NULL;
    Node* temp=NULL;

    find(info,&parent,&currentNode);
    if(currentNode!=NULL)
    {
        cout<<"\nDuplicate words not allowed";
        return;
    }
    else
    {
        temp=new Node(info,NULL,NULL);
        if(parent==NULL)
            ROOT=temp;
        else
            if(strcmp(info,parent->info)<0)
                parent->left=temp;
            else
                parent->right=temp;
    }

}
void BinarSearchTree::preorder(Node* ptr)
{
    if(ptr!=NULL)
    {
        cout<<ptr->info<< " ";
        preorder(ptr->left);
        preorder(ptr->right);
    }
}

//前序遍历打印每个节点的高度
void preorder(Node* ptr, int depth)
{
    if(ptr!=NULL)
    {
        cout<<ptr->info<< depth << " ";
        preorder(ptr->left, depth+1);
        preorder(ptr->right, depth+1);
    }
}

//前序遍历非递归实现
void preorderNorecu(Node* tree)
{
    stack<Node*> stacks;
    if(tree!=NULL)
    {
        while(tree || !stacks.empty())
        {
            while(tree)
            {
                stacks.push(tree);
                cout << tree->info << " ";
                tree=tree->left;
            }
            tree = stacks.top();
            stacks.pop();
            tree=tree->right;
        }
    }
}

void BinarSearchTree::inorder(Node* ptr)
{
    if(ptr!=NULL)
    {
        inorder(ptr->left);
        cout<<ptr->info<<"   ";
        inorder(ptr->right);
    }
}

//中序遍历非递归实现
void inorderNorecu(Node* tree)
{
    stack<Node*> stacks;
    if(tree!=NULL)
    {
        while(tree || !stacks.empty())
        {
            while(tree)
            {
                stacks.push(tree);
                tree=tree->left;
            }
            tree = stacks.top();
            stacks.pop();
            cout << tree->info << " ";
            tree=tree->right;
        }
    }
}

void BinarSearchTree::postorder(Node* ptr)
{
    if(ptr!=NULL)
    {
        postorder(ptr->left);
        postorder(ptr->right);
        cout << ptr->info << "   ";
    }
}

//后序遍历非递归实现
void postorderNorecu(Node* ptr)
{

}

//层序遍历
void BinarSearchTree::levelorder(Node* ptr)
{
    queue<Node*> stacks;
    if(ptr!=NULL)
    {
        stacks.push(ptr);
        while(!stacks.empty())
        {
            Node* node = stacks.front();
            stacks.pop();
            cout << node->info << "   ";
            if(node->left!=NULL)
                stacks.push(node->left);
            if(node->right!=NULL)
                stacks.push(node->right);
        }
    }
}

//计算节点总数
int coutNodeNum(Node* tree)
{
    if(tree==NULL)
        return 0;
    else
        if(tree->left==NULL&&tree->right==NULL)
            return 1;
        else
            return coutNodeNum(tree->left)+coutNodeNum(tree->right)+1;
}

//树高度
int treeDepth(Node* tree)
{
    if(tree==NULL)
        return 0;
    else
    {
        int leftdepth = treeDepth(tree->left);
        int rightdepth = treeDepth(tree->right);
        return 1+ (leftdepth>rightdepth?leftdepth:rightdepth);
    }
}

void BinarSearchTree::remove()
{
    if(ROOT==NULL) /* Checks whether the tree is empty */
    {
        cout<<"\nTree is empty\n";
        return;
    }

    Node *parent,*currentNode;
    char element[50];
    cout<<"\nEnter the word to be deleted: ";
    cin>>element;

    find(element,&parent,&currentNode);
    if(currentNode==NULL)
    {
        cout<<"\nWord not found in the dictionary"<<endl;
        return;
    }

    if (currentNode->left==NULL && currentNode->right==NULL)//叶子节点
    {
        case_1(parent,currentNode);
    }
    else 
        if (currentNode->left!=NULL && currentNode->right==NULL)//含左子树
        {
            case_2(parent,currentNode);
        }
        else 
            if (currentNode->left==NULL && currentNode->right!=NULL)//含右子树
            {
                case_2(parent,currentNode);
            }
            else//含左右子树
                case_3(parent,currentNode);

}

//叶子节点
void BinarSearchTree::case_1(Node* parent, Node* current)
{
    if (parent==NULL)
    {
        ROOT=NULL;
    }
    else
    {
        if(current==parent->left)
            parent->left=NULL;
        else
            parent->right=NULL;
    }
    delete current;
}

//含左子树或者右子树
void BinarSearchTree::case_2(Node* parent, Node* current)
{
    Node* child;
    if(current->left!=NULL)
        child=current->left;
    else
        child=current->right;

    if(parent==NULL)
        ROOT=child;
    else
        if(current==parent->left)
            parent->left=child;
        else
            parent->right=child;

    delete current;
}

//含左右子树
void BinarSearchTree::case_3(Node* parent, Node* current)
{
    Node* inorder_suc, *inorder_parent;

    inorder_parent = current;
    inorder_suc=current->right;
    while(inorder_suc->left!=NULL)
    {
        inorder_parent=inorder_suc;
        inorder_suc=inorder_suc->left;
    }
    strcpy(current->info, inorder_suc->info);
    if(inorder_suc->left==NULL && inorder_suc->right==NULL)
        case_1(inorder_parent,inorder_suc);
    else
        case_2(inorder_parent,inorder_suc);

}

//最大深度
int maxDepth(Node* root)
{
    if (root == NULL) 
    {
         return 0;
    }
    else
    {
        int leftdepth = maxDepth(root->left);
        int rightdepth = maxDepth(root->right);
        return 1+ (leftdepth>rightdepth?leftdepth:rightdepth);
    }
}

//最小深度
int minDepth(Node* root)
{
    if (root == NULL) 
    {
        return 0;
    }
    else
    {
        int leftdepth = minDepth(root->left);
        int rightdepth = minDepth(root->right);
        return 1+ (leftdepth<rightdepth?leftdepth:rightdepth);
    }
}

//判断是否是平衡二叉树
bool isbalanceTree(Node* tree)
{
    if (tree==NULL)
        return true;
    else
    {
        int maxdepth = maxDepth(tree);
        int mindepth = minDepth(tree);
        return (maxdepth-mindepth)<=1;
    }

}

//比较树是否相等
int compTree(Node *tree1, Node *tree2)  
{  
     if(tree1==NULL &&tree2==NULL)
         return 1;
     if(tree1==NULL || tree2==NULL)
         return 0;
     if(strcmp(tree1->info,tree2->info)!=0)  
         return 0;

    if(compTree(tree1->left,tree2->left)&&compTree(tree1->right,tree2->right)||
       compTree(tree1->left,tree2->right)&&compTree(tree1->right,tree2->left))
           return 1;

    return 0;  
}

//根据前序创建二叉树
void createTreeByPreorder(Node* &node, char *arr, int &current)
{
    if(arr[current]=='#')
        node=NULL;
    else
    {
        char arr2[2]={arr[current],'\0'};
        node = new Node(arr2, NULL, NULL);
        createTreeByPreorder(node->left,arr,++current);
        createTreeByPreorder(node->right,arr,++current);
    }
}

//根据层序创建二叉树
void createTreeByLevelorder(Node* &node, char *arr, int current)
{
    if(arr[current]=='#')
        node=NULL;
    else
    {
        char arr2[2]={arr[current],'\0'};
        node = new Node(arr2, NULL, NULL);
        createTreeByLevelorder(node->left,arr,2*current+1);
        createTreeByLevelorder(node->right,arr,2*current+2);
    }
}

//根据后续遍历创建树,左右根->根右左
void createTreeByPostorder(Node* &node, char *arr, int &current)
{
    if(arr[current]=='#')
        node=NULL;
    else
    {
        char arr2[2]={arr[current],'\0'};
        node = new Node(arr2, NULL, NULL);
        createTreeByPreorder(node->right,arr,++current);
        createTreeByPreorder(node->left,arr,++current);
    }
}

//根据前序中序创建二叉树
void createTreeByPreInOrder(Node* &node, char *preorder, char* inorder, int len)
{
    if (len<=0)
    {
        node=NULL;
        return;
    }
    else
    {
        char arr2[2]={preorder[0],'\0'};
        node = new Node(arr2, NULL, NULL);

        for(char* temp=inorder;temp<inorder+len;temp++)
            if(*temp==preorder[0])
                break;
        int k=temp-inorder;
        createTreeByPreInOrder(node->left,preorder+1,inorder,k);
        createTreeByPreInOrder(node->right,preorder+1+k,temp+1,len-k-1);
    }
}

//根据中序后序创建二叉树
void createTreeByPostInorder(Node* &node, char* postorder, char *inorder, int len)
{
    if (len<=0)
    {
        node=NULL;
        return;
    }
    else
    {
        char arr2[2]={postorder[len-1],'\0'};
        node = new Node(arr2, NULL, NULL);
        
        for(char* temp=inorder;temp<inorder+len;temp++)
            if(*temp==postorder[len-1])
                break;
            int k=temp-inorder;
            createTreeByPostInorder(node->left,postorder,inorder,k);
            createTreeByPostInorder(node->right,postorder+k,temp+1,len-k-1);
    }
}

//交换左右子树
void change_left_right(Node* &node)
{
    if(node)
    {
        change_left_right(node->left);
        change_left_right(node->right);
        Node* temp = node->left;
        node->left=node->right;
        node->right=temp;
    }
}

//打印树
void display(BinarSearchTree& b)
{
    cout << "InOrder:  ";
    b.inorder(b.ROOT);
    cout << endl;

    cout << "PreOrder: ";
    b.preorder(b.ROOT);
    cout << endl;

    cout << "PostOrder:";
    b.postorder(b.ROOT);
    cout << endl;

    cout << "LevelOrder:";
    b.levelorder(b.ROOT);
    cout << endl;
}


int main()
{
//     char *str[]={"E","B","H","A","C","D","F","G","I","J"};
//     BinarSearchTree b;
//     for (int i=0;i<10;i++)
//     {
//         b.insert(str[i]);
//     }
//     display(b);
//     b.remove();
//     display(b);

//     char prorder[]="ABDCE";
//     char iorder[]="DBAEC";
//     Node *treeroot;
//     BinarSearchTree b4;
//     createTreeByPreInOrder(treeroot,prorder,iorder,5);
//     b4.ROOT=treeroot;
//     display(b4);

//      char poorder[]="CGEFDBA";
//      char iorder []="CBEGDFA";
//      Node *treeroot;
//      BinarSearchTree b4;
//      createTreeByPostInorder(treeroot,poorder,iorder,7);
//      b4.ROOT=treeroot;
//      display(b4);



//     cout <<"\n--------------------------------------";
// 
//     char levelorder[]="ABCD#E#######";
//     BinarSearchTree b3;
//     Node *levelroot;
//     createTreeByLevelorder(levelroot,levelorder,0);
//     b3.ROOT=levelroot;
//     display(b3);


    char arr[]="ABC##DE#G##F###";
    //char arr[]="ABDHL###I##E#J##CF#K##G##";
    int current=0;
    Node *root;
    createTreeByPreorder(root,arr,current);
    BinarSearchTree b1;
    b1.ROOT=root;
    display(b1);

    cout << endl;

    preorderNorecu(b1.ROOT);

    cout << endl;
    inorderNorecu(b1.ROOT);

    cout << "\nNodeNum=" << coutNodeNum(b1.ROOT);
    cout << "\nTreeDepth=" << treeDepth(b1.ROOT);

    cout << "\n";
    preorder(b1.ROOT,1);

    cout <<"\n";
    cout<<isbalanceTree(b1.ROOT);

//     cout << endl;
// 
//     change_left_right(b1.ROOT);
//     display(b1);
// 
//     current=0;
//     Node *root2;
//     char arr2[]="A#BDF##EG###C##";
//     createTreeByPostorder(root2,arr2,current);
//     BinarSearchTree b2;
//     b2.ROOT=root;
//     display(b2);
//  
//  cout << compTree(b1.ROOT,b2.ROOT) <<endl;
    for (int i=0;i<10;i++)
    {
        cout << i << " " ;
    }

    return 0;
}