二叉树

复习二叉树

1.插入

1>左 < 本节点 < 右 大小排序

2>只指针的指针可以改变指针

2.删除

1>没有子节点

直接删除

2>有一个节点

让该该节点的父节点指向，该节点的子节点

3>有二个节点

找出该节点右子树最小值的节点，置换值。并删除置换的节点

#ifndef _ZB_BINARYTREE_
#define _ZB_BINARYTREE_
#include <iostream>

struct AllocNode
{
AllocNode(){}
~AllocNode(){}
void* Allocator(size_t len) { return new char[len]; }
void Free(void *ptr, size_t len = 0) { delete[] ptr; ptr = nullptr; }
void Swip(){}
};

template<typename ValTy>
struct TreeNode
{
typedef TreeNode<ValTy>* Node_Ptr;

TreeNode(const ValTy& data)
:MyData(data), MyRight(nullptr), MyLeft(MyLeft)
{}

ValTy MyData;
Node_Ptr MyRight;
Node_Ptr MyLeft;
};

template<typename ValTy, typename Alloc = AllocNode>
class BinaryTree
{
typedef TreeNode<ValTy> MyBase;
typedef typename MyBase::Node_Ptr Node_Ptr;
typedef typename size_t size_type;
public:
BinaryTree()
:MyRoot(nullptr),MyCount(0)
{
MyRoot = nullptr;
MyCount = 0;
}

~BinaryTree()
{
clear(MyRoot);
}

void clear()
{
clear(MyRoot);
}

void eraser(const ValTy& data)
{
eraser(data, MyRoot);
_incsize(-1);
}

void insert(const ValTy& data)
{
insert(&MyRoot, _buynode(data));
_incsize(1);
}

void travel(int i)
{
switch (i)
{
case 1:travelFront(MyRoot); break;
case 2:travelMidlle(MyRoot); break;
case 3:travelBack(MyRoot); break;
default:
break;
}
std::cout << endl;
}
private:
Node_Ptr eraser(const ValTy& data, Node_Ptr pRoot)
{
if (!pRoot)
{
return nullptr;
}

Node_Ptr del_node;
if (data < pRoot->MyData)
{
pRoot->MyLeft = eraser(data, pRoot->MyLeft);
}
else if (data > pRoot->MyData)
{
pRoot->MyRight = eraser(data, pRoot->MyRight);
}
else
{
if (pRoot->MyLeft && pRoot->MyRight)
{
del_node = find_min(pRoot->MyRight);
pRoot->MyData = del_node->MyData;
pRoot->MyRight = eraser(pRoot->MyData, pRoot->MyRight);
}
else
{
del_node = pRoot;
if (nullptr == pRoot->MyLeft)
{
pRoot = pRoot->MyRight;
}
else if (nullptr == pRoot->MyRight)
{
pRoot = pRoot->MyLeft;
}
MyAlloc.Free(del_node);
}
}
return pRoot;
}

Node_Ptr find(const ValTy& data, Node_Ptr pRoot)
{
if (!pRoot)
{
return nullptr;
}
if (data < pRoot->MyData)
{
find(data, pRoot->MyLeft);
}
else if (data > pRoot->MyData)
{
find(data, pRoot->MyRight);
}
else
{
return pRoot;
}
}

Node_Ptr find_min(Node_Ptr pRoot)
{
if (!pRoot)
{
return nullptr;
};
if (nullptr == pRoot->MyLeft)
{
return pRoot;
}
else
{
find_min(pRoot->MyLeft);
}
return nullptr;
}

Node_Ptr find_max(Node_Ptr pRoot)
{
NULL_RETURN_VOID(pRoot);
if (nullptr == pRoot->MyRight)
{
return pRoot;
}
else
{
find_max(pRoot->MyRight);
}
return nullptr;
}

void insert(Node_Ptr *pRoot, Node_Ptr pNew)
{
if (nullptr == *pRoot)
{
//只有二维指针可以改变指针的值
*pRoot = pNew;
return;
}

if (pNew->MyData < (*pRoot)->MyData)
{
insert(&(*pRoot)->MyLeft, pNew);
}
else
{
insert(&(*pRoot)->MyRight, pNew);
}
}

void clear(Node_Ptr pNode)
{
if (nullptr != pNode)
{
clear(pNode->MyLeft);
clear(pNode->MyRight);
MyAlloc.Free(pNode);
_incsize(-1);
return;
}
}

void travelMidlle(Node_Ptr pNode)
{
if (!pNode)
{
return;
}
travelMidlle(pNode->MyLeft);
std::cout << pNode->MyData << '\t';
travelMidlle(pNode->MyRight);
}

void travelBack(Node_Ptr pNode)
{
if (!pNode)
{
return;
}
travelBack(pNode->MyLeft);
travelBack(pNode->MyRight);
std::cout << pNode->MyData << '\t';
}

void travelFront(Node_Ptr pNode)
{
if (!pNode)
{
return;
}
std::cout << pNode->MyData << '\t';
travelFront(pNode->MyRight);
travelFront(pNode->MyLeft);
}

Node_Ptr _buynode(const ValTy& data)
{
Node_Ptr pNew = (Node_Ptr)MyAlloc.Allocator(sizeof(MyBase));
pNew->MyData = data;
pNew->MyRight = nullptr;
pNew->MyLeft = nullptr;
return pNew;
}

void _incsize(size_type nCount)
{
MyCount += nCount;
}
private:
Alloc MyAlloc;
Node_Ptr MyRoot;
size_type MyCount;
};
#endif//_ZB_BINARYTREE_