c++二叉树

#ifndef _TREE_H_
#define _TREE_H_
//此类用shared_ptr来管理节点内存，所以要包含<memory>头文件,不需要手动释放内存
#include <memory>
#include <iostream>

using namespace std;

struct Node{
    int key;
    shared_ptr<Node> parent;
    shared_ptr<Node> left;
    shared_ptr<Node> right;
    Node(int k = 0) :key(k), parent(), left(), right() {}
};

typedef shared_ptr<Node> Pnode;

class Tree
{
private:
    Pnode root;
    //返回以current为根节点的所有节点个数
    size_t __nodeSize(Pnode current) const;
    //返回以current为根节点的叶节点（没有左右节点)个数
    size_t __leafSize(Pnode current) const;
    //返回以current为根节点树的深度
    size_t __depth(Pnode current) const;
    //返回k值节点的地址
    const Pnode * __getNodeAddress(int k) const;
    //返回current节点下的最大值的节点
    Pnode __maxNode(Pnode current) const;
    //返回current节点下的最小值节点
    Pnode __minNode(Pnode current) const;
    void showNode(Pnode current) const;
public:
    Tree() :root() {}
    //将k插入树
    void insert(int k);
    //删除值为k的节点
    void delNode(int k);
    //判断是否存在值为k的节点
    bool isExist(int k);
    //树中节点个数
    size_t nodeSize() const;
    //树中叶节点的个数
    size_t leafSize() const;
    //树的深度
    size_t depth() const;
    //树的宽度
    size_t width() const;
    //树的最大值
    int maxVal() const;
    //树的最小值
    int minVal() const;
    //打印所有节点
    void showAll() const;
};


#endif

#include "Tree.h"

//求树的宽度要用到队列
#include <queue>

using namespace std;

//遍历节点
//void static showNode(Pnode current);

void Tree::showNode(Pnode current) const
{
    if (current.get() == NULL)
        return;
    showNode(current->left);
    cout << current->key << " ";
    showNode(current->right);
}

void Tree::showAll() const
{
    showNode(root);
    cout << endl;
}

void Tree::insert(int k)
{
    //智能指针shared_ptr变量的初始化方式
    Pnode new_node(new Node(k));
    Pnode current = root;
    Pnode save = root;    
    while (current)
    {
        save = current;
        if (k < current->key)
            current = current->left;
        else current = current->right;
    }
    new_node->parent = save;
    if (!save)
        root = new_node;
    else if (k < save->key)
        save->left = new_node;
    else save->right = new_node;
}

void Tree::delNode(int k)
{
    //__getNodeAddress返回的是带有顶层const类型的指针,
    //后面要改变指针指向的值，所以要先解除const限制.
    Pnode * pdel = const_cast<Pnode *>(__getNodeAddress(k));
    if (!pdel)
    {
        cout << k << " is not exist!
";
        return;
    }
    //save保存被删节点的父节点
    Pnode save = (*pdel)->parent;
    //被删节点没有子树
    if (!(*pdel)->left.get() && !(*pdel)->right.get())
        *pdel = NULL;
    //被删节点左子树为空
    else if (!(*pdel)->left.get())
    {
        *pdel = (*pdel)->right;
        (*pdel)->parent = save;
    }
    //被删节点右子树为空
    else if (!(*pdel)->right.get())
    {
        *pdel = (*pdel)->left;
        (*pdel)->parent = save;
    }
    //被删节点有左右子树
    else {
        //successor为被删节点的后继
        Pnode successor = __minNode((*pdel)->right);
        successor->left = (*pdel)->left;
        *pdel = (*pdel)->right;
        (*pdel)->parent = save;
    }
}

bool Tree::isExist(int k)
{
    return __getNodeAddress(k) != NULL;
}

size_t Tree::__nodeSize(Pnode current) const
{
    if (!current)
        return 0;
    return 1 + __nodeSize(current->left) + __nodeSize(current->right);
}

size_t Tree::nodeSize() const
{
    return __nodeSize(root);
}

size_t Tree::__leafSize(Pnode current) const
{
    if (current.get() == NULL)
        return 0;
    if (current->left.get() == NULL && current->right.get() == NULL)
        return 1;
    return __leafSize(current->left) + __leafSize(current->right);
}

size_t Tree::leafSize() const
{
    return __leafSize(root);
}

size_t Tree::__depth(Pnode current) const
{
    if (!current)
        return 0;
    size_t leftSize = 1 + __depth(current->left);
    size_t rightSize = 1 + __depth(current->right);
    return leftSize > rightSize ? leftSize: rightSize;
}

size_t Tree::depth() const
{
    return __depth(root);
}

size_t Tree::width() const
{
    if (!root)
        return 0;
    Pnode current = root;
    int maxNode = 1;
    int ct = 0;
    queue<Pnode> qu;
    qu.push(current);
    while (qu.size() != 0)
    {
        ct = qu.size();
        for (int i = 0; i < ct; i++)
        {
            current = qu.front();
            qu.pop();
            if (current->left.get() != NULL)
                qu.push(current->left);
            if (current->right.get() != NULL)
                qu.push(current->right);
        }
        maxNode = maxNode > qu.size() ? maxNode : qu.size();
    }
    return maxNode;
}

/*
* 此处返回指针是考虑到方便delNode调用，内存本身的地址和内存指向的值会带来很大困惑，
* 要仔细品味,此前写delNode方法从节点本身来考虑，反复建立节点关系，写下的代码长度
* 大概是现在delNode长度的2倍,效率也会打折扣.
*/
const Pnode  * Tree::__getNodeAddress(int k) const
{
    Pnode ret = root;
    Pnode save = {};
    if (root->key == k)
        return &root;
    while (1)
    {
        save = ret;
        if (k < ret->key)
        {
            if (!(ret = ret->left).get())
                break;
            if (ret->key == k)
                return &(save->left);
        }
        else {
            if(!(ret = ret->right).get())
                break;
            if (ret->key == k)
                return &(save->right);
        }
    }
    return NULL;
}

Pnode Tree::__maxNode(Pnode current) const
{
    
    while (current->right.get() != NULL)
        current = current->right;
    return current;
}

Pnode Tree::__minNode(Pnode current) const
{
    while (current->left.get() != NULL)
        current = current->left;
    return current;
}

int Tree::maxVal() const
{
    if (root.get() == NULL)
        return 0x80000000;
    return __maxNode(root)->key;
}

int Tree::minVal() const
{
    if (root.get() == NULL)
        return 0x7FFFFFFF;
    return __minNode(root)->key;
}

#include <iostream>
#include "Tree.h"

using namespace std;

void showArray(int * arr, int n);
void loadArrayToTree(Tree & t, int * arr, int n);

const int ASIZE = 13;

int main()
{
    int arr[ASIZE] = { 54,19,18,39,76,15,80,70,25,41,83,79,71 };
    cout << "show array: 
";
    showArray(arr, ASIZE);
    Tree t;
    loadArrayToTree(t, arr, ASIZE);
    cout << "show Tree: 
";
    t.showAll();
    cout << "nodeSize() = " << t.nodeSize() << endl;
    cout << "leafSize() = " << t.leafSize() << endl;
    cout << "depth() = " << t.depth() << endl;
    cout << "width() = " << t.width() << endl;
    cout << "isExist(41) = " << t.isExist(41) << endl;
    t.delNode(41);
    t.showAll();
    cout << "nodeSize() = " << t.nodeSize() << endl;
    cout << "isExist(41) = " << t.isExist(41) << endl;
    cout << "isExist(80) = " << t.isExist(80) << endl;


    return 0;
}

void showArray(int * arr, int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;
}

void loadArrayToTree(Tree & t, int * arr, int n)
{
    for (int i = 0; i < n; i++)
        t.insert(arr[i]);
}