【c++】構建一棵簡單的二叉樹
阿新 • • 發佈：2019-02-02
本文主要講了如何使用c++來構建一個二叉樹類，以及一些功能演算法的實現。文中大部分函式的思想都是遞迴，其中賦值運算子過載有傳統寫法和現代寫法兩個版本，層序遍歷是非遞迴，前、中、後序遍歷有遞迴和非遞迴兩個版本。
1、建構函式（遞迴）
2、拷貝建構函式（遞迴）
3、解構函式（遞迴）
4、賦值運算子過載（傳統/現代）
5、前中後序遍歷（遞迴/非遞迴）
6、層序遍歷（非遞迴）
7、查詢第k層結點個數（遞迴）
8、精確查詢值為x的結點，並返回當前結點的指標（遞迴）
9、查詢葉子結點個數（遞迴）
10、查詢結點總個數（遞迴）
11、計算樹的深度（遞迴）
樹的結點型別，每個結點都需要有一個指向右孩子的指標，一個指向左孩子的指標，以及一個數據。（當然，如果你想構造三叉樹的話，也可以增加一個指向父節點的指標。）
這裡我寫出了結點的建構函式，方便我們在建立樹的時候使用。
注意：這棵樹我使用了模板
template<typename T>
struct BinaryTreeNode
{
BinaryTreeNode<T>* _left;//左孩子
BinaryTreeNode<T>* _right;//右孩子
T _data;//資料
BinaryTreeNode(T data = T())//結點自己的建構函式，T()為一個匿名物件。
:_left(NULL)//初始化為空
, _right(NULL)
, _data(data)
{}
};
typedef BinaryTreeNode<T> Node;當我們向寫二叉樹類的時候，直接給類設定一個根結點，以這個根結點為基礎，構建二叉樹。
class BinaryTree
{
public:
private:
BinaryTreeNode<T>* _root;//根節點
};
1、建構函式 BinaryTree(const T* a, size_t size,int index, const T& invalid)
建構函式有4個引數，T型別的指標a，傳參時傳一個數組，負責傳入資料。size儲存陣列a 的大小，index記錄下標，invalid表示非法值。
BinaryTree(const T* a, size_t size,int index, const T& invalid)
{
_root = _MakeTree(a,size,index,invalid);
}
你會看到上面有許多NULL，這些NULL我們就可以理解為非法值invalid。這棵樹的前序遍歷為: 1 2 3 NULL NULL 4 NULL NULL 5 6 最後一個結點不需要非法值，到時候直接建立即可。 與上對應，我們傳陣列時，應該傳的值即為 int a[10] = {1,2,3,'#','#',4,'#','#',5,6}。非法值的值可以隨意設，這裡我設為‘#’，注意，你向以什麼的樣的順序建樹，就以什麼樣的順序傳參，事先要約定好。（這裡我用的是前序） 遞迴：當我們從陣列讀取到一個數據時，我們先要判斷這個值是不是合法，如果合法則new出一個結點並初始化作為當前結點，此時，進入左孩子遞迴函式讀取下一個資料（++index），並把這個函式的返回值鏈到當前結點root的left，同理，將右孩子遞迴函式的返回值鏈到當前結點的right。如果不合法則return，返回上一層函式。最後我們會得到一個根節點，例圖中的1。 _MakeTree函式實現:
Node* _MakeTree(const T* a, size_t size, int& index, const T& invalid)
{
Node *root = NULL;
if (index < size && a[index] != invalid)
{
root = new Node(invalid);
root->_data = a[index];
root->_left = _MakeTree(a, size, ++index, invalid);
root->_right = _MakeTree(a, size, ++index, invalid);
}
return root;
}2、拷貝建構函式 同上，同樣實現一個遞迴函式，返回值仍為Node*
BinaryTree(const BinaryTree<T>& t)
{
_root = CopyTree(t._root);
}Node* CopyTree(const BinaryTreeNode<T>* _root)3、
{
if (_root == NULL)
{
return NULL;
}
Node* root = new Node(_root->_data);
root->_left = CopyTree(_root->_left);
root->_right = CopyTree(_root->_right);
return root;
}3、解構函式 同上，但是解構函式不需要返回值。
~BinaryTree()
{
Destroy(_root);
}void Destroy( Node* _root)
{
Node* tmp = _root;
if (tmp == NULL)//如果根結點為空，則不需要delete，直接return。
return;
Destroy(tmp->_left);
Destroy(tmp->_right);
delete tmp;
tmp = NULL;
}BinaryTree<T>& operator=(BinaryTree<T> t)
{
if (this != &t)//自賦值的優化
{
std::swap(_root, t._root);
}
return *this;
}①前序 這個我就不再多說了，構造，拷貝構造，析構，都是利用前序遍歷的道理來做的。當前結點-->左子樹-->右子樹。 程式碼：
void PrevOrder()
{
_PrevOrder(_root);
cout << endl;
}_PrevOrder()
void _PrevOrder(Node* _root)
{
Node* tmp = _root;
if (tmp == NULL)
{
return;
}
cout << tmp->_data << " ";
_PrevOrder(tmp->_left);
_PrevOrder(tmp->_right);
}判斷當前結點是否為空，為空的話，不處理，直接返回。先遞迴訪問當前結點左子樹，當左子樹處理完畢，再依次返回處理當前結點，再遞迴訪問當前結點右子樹。
void InOrder()
{
_InOrder(_root);
cout << endl;
}void _InOrder(Node* _root)
{
Node* tmp = _root;
if (tmp == NULL)
{
return;
}
_InOrder(tmp->_left);
cout << tmp->_data << " ";
_InOrder(tmp->_right);
}③後序 判斷當前結點是否為空，為空的話，不處理，直接返回。不為空的話，先遞迴訪問當前結點節點的左子樹，再遞迴訪問當前結點根節點的右子樹，最後訪問當前結點。
void PostOrder()
{
_PostOrder(_root);
cout << endl;
}void _PostOrder(Node* _root)
{
Node* tmp = _root;
if (tmp == NULL)
{
return;
}
_PostOrder(tmp->_left);
_PostOrder(tmp->_right);
cout << tmp->_data << " ";
}
程式碼：
void PrevOrder_NonR()
{
Node* cur = _root;
stack<Node*> s;
if (cur == NULL)
{
return;
}
while (cur || !s.empty())
{
while (cur)
{
s.push(cur);
cout << cur->_data << " ";
cur = cur->_left;
}
Node* top = s.top();
s.pop();
cur = top->_right;
}
cout << endl;
}中序和後序的道理與上相同，只是當前節點的輸出做了小小的改動。下面直接貼出程式碼 ②中序（非遞迴）
void InOrder_NonR()
{
Node* cur = _root;
stack<Node*> s;
if (cur == NULL)
{
return;
}
while (cur || !s.empty())
{
while (cur)
{
s.push(cur);
cur = cur->_left;
}
Node* top = s.top();
cout << top->_data << " ";
s.pop();
cur = top->_right;
}
cout << endl;
}void PostOrder_NonR()
{
Node* cur = _root;
Node* prev = NULL;
stack<Node*> s;
while (cur || s.empty())
{
while (cur)
{
s.push(cur);
cur = cur->_left;
}
Node* top = s.top();
//如果右樹為空或者右樹已經訪問過，則訪問當前結點，並出棧
//如果右樹不為空並且沒有訪問過，則訪問右樹
if (top->_right == NULL || prev == top->_right)
{
cout << top->_data << " ";
prev = top;
s.pop();//返回父節點
}
else
{
cur = top->_right;
}
}
cout << endl;
}7、層序遍歷 顧名思義。層序遍歷就是按層來訪問一顆樹，一次訪問一層。這裡我們用到了一個佇列。
程式碼：
void _LevelOrder(Node* _root)
{
Node *tmp = _root;
queue<Node*> q;
q.push(tmp);
while (!q.empty())
{
Node* top = q.front();
q.pop();
cout << top->_data << " ";
if (top->_left)
{
q.push(top->_left);
}
if (top->_right)
{
q.push(top->_right);
}
}
}8、查詢第k層節點個數 這個問題，我們只需要查詢第k-1層有多少個孩子就行了。 同樣為遞迴，前序。
size_t FindKlevel(size_t k)
{
return _FindKlevel(_root,k);
}_FindKlevel()
size_t _FindKlevel(Node* _root,size_t k)
{
Node *cur = _root;
if (cur == NULL || k < 0)
{
return 0;
}
if (k == 1)
{
return 1;
}
size_t left = _FindKlevel(cur->_left, k-1);
size_t right = _FindKlevel(cur->_right, k-1);
return left + right;
}Node* Find(const T& x)
{
return _Find(_root,x);
}Node* _Find(Node* _root,const T& x)
{
Node* ret = NULL;
Node* cur = _root;
if (cur == NULL)
{
return NULL;
}
if (cur->_data == x)
{
ret = cur;
}
else
{
ret = _Find(cur->_left,x);
if (ret == NULL)
{
ret = _Find(cur->_right,x);
}
}
return ret;
}10、查詢結點總個數。 結點總個數 = 當前節點個數+左子樹節點個數+右子樹節點個數。 前序遞迴查詢，若當前節點為空，返回，不為空則加1，--->遞迴左子樹----->遞迴右子樹。
size_t Size()
{
return _Size(_root);
}size_t _Size( BinaryTreeNode<T>* _root )
{
size_t ret = 0;
if (_root == NULL)
{
return ret;
}
ret++;
ret += _Size(_root->_left);
ret += _Size(_root->_right);
}size_t Depth()
{
return _Depth(_root);
}size_t _Depth(Node* _root)
{
if (_root == NULL)
{
return 0;
}
int left = _Depth(_root->_left) + 1;
int right = _Depth(_root->_right) + 1;
return left > right ? left : right;
}。請大家採用批評的態度來看這篇博文，博主水平也一般。。。。