二叉樹：

二叉樹的每個節點至多有兩個子樹。如這個二叉樹，其中1,2有兩個子樹，3只有左子樹，5有右子樹，4,6,7沒有子樹。

二叉樹有兩種儲存方式：

第一種，陣列表示。用陣列儲存方式就是用一組連續的儲存單元儲存二叉樹的資料元素。

兩顆樹分別用陣列表示為：

用下標就可以直接找到那個節點，也可以找這個節點的左孩子2n+1,右孩子2n+2.找父節點（n-1）/2

但是陣列也有缺陷，比如第二個就會浪費儲存空間。

若設二叉樹的深度為h，除第 h 層外，其它各層 (1~h-1) 的結點數都達到最大個數，第 h 層所有的結點都連續集中在最左邊，這就是完全二叉樹。完全二叉樹就適合用陣列表示。

滿二叉樹就是除了葉結點外每一個結點都有左右子葉且葉結點都處在最底層的二叉樹。也適合用陣列表示。

完全二叉樹不是滿二叉樹，滿二叉樹就是完全二叉樹。

第二種，連結串列儲存表示。其中又有二叉連結串列結構和三叉連結串列結構。

左圖就是二叉連結串列結構，右圖是三叉連結串列結構。

二叉連結串列裡有leftchild指標，rightchild指標和資料。三叉連結串列裡不僅有leftchild指標，rightchild指標和資料還有parent指標，能找到父節點。

二叉的遍歷方式有四種：

第一種：前序遍歷。先訪問根節點，再訪問左子樹，最後訪問右子樹。

第二種：中序遍歷。先訪問左子樹，再訪問根節點，最後訪問右子樹。

第三種：後序遍歷。先訪問左子樹，再訪問右子樹，最後訪問根節點。

第四種：層序遍歷。一層層節點依次遍歷。   

這顆二叉樹的前序遍歷：1-2-4-5-7-3-6

中序遍歷：4-2-5-7-1-6-3

後序遍歷：4-7-5-2-6-3-1

層序遍歷：1-2-3-4-5-6-7

程式碼實現：

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
#include <queue>
template <class T>
struct BinaryTreeNode
{
	T _data;
	BinaryTreeNode<T>* _leftchild;
	BinaryTreeNode<T>* _rightchild;

	BinaryTreeNode(const T& x)//建構函式
		:_data(x)
		, _leftchild(NULL)
		, _rightchild(NULL)
	{}
};

template <class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()//無參建構函式
		:_root(NULL)
	{}
	BinaryTree(T* a, size_t n, const T& invalid = T())//建構函式
	{
		size_t index = 0;
		_root = _GreateTree(a, n, invalid, index);
	}
	BinaryTree(const BinaryTree<T>& t)//拷貝構造
	{
		_root = _copy(t._root);
	}
	BinaryTree<T>& operator=(const BinaryTree<T>& t)
	{
		if (this != &t)
		{
			Node* newRoot = _copy(t._root);
			_Destroy(_root);
			_root = newRoot;
		}
		return *this;
	}
	~BinaryTree()//解構函式
	{
	void _Destory();
	}
	void PrevOrder()//前序遍歷遞迴
	{
		_PrevOrder(_root);
		cout << endl;
	}
	void InOrder()//中序遍歷遞迴
	{
		_InOrder(_root);
		cout << endl;
	}
	void PostOrder()//後序遍歷遞迴
	{
		_PostOrder(_root);
		cout << endl;
	}
	void LeveIOrder()//層序遍歷,運用佇列，以當前層帶下一層
	{
		queue<Node*> q;
		if (_root)
			q.push(_root);
		while (!q.empty())//佇列不為空
		{
			Node* front = q.front();//取隊頭
			cout << front->_data << " ";
			q.pop();//刪除隊頭
			if (front->_leftchild)
				q.push(front->_leftchild);
			if (front->_rightchild)
				q.push(front->_rightchild);
		}
		cout << endl;
	}
	size_t Size()//節點的個數
	{
		return _Size(_root);
	}
	size_t Depth()//樹的深度
	{
		return _Depth(_root);
	}
	size_t LeafSize()//葉子節點的個數
	{
		return _LeafSize(_root);
	}
	size_t GetKLevel(size_t k)//第k層節點的個數
	{
		assert(k > 0);
		return _GetKLevel(_root, k);
	}
	Node* Find(const T& x)//找節點x
	{
		return _Find(_root, x);
	}
protected:
	Node* _copy(Node* root)//拷貝
	{
		if (root == NULL)
			return NULL;
		Node* newNode = new Node(root->_data);
		newNode->_leftchild = _copy(root->_leftchild);
		newNode->_rightchild =_copy(root->_rightchild);
		return newNode;
	}
	void _Destroy(Node* root)//銷燬
	{
		if (root == NULL)
			return;
		_Destroy(root->_leftchild);
		_Destroy(root->_rightchild);
		delete root;
	}
	Node* _Find(Node* root, const T& x)//找節點x的呼叫函式
	{
		if (root == NULL)
			return NULL;
		if (root->_data == x)
			return root;
		Node* tmp = _Find(root->_leftchild, x);
		if (tmp)
			return tmp;
		return _Find(root->_rightchild, x);
	}
	size_t _GetKLevel(Node* root,size_t k)//第k層節點的呼叫函式
	{
		if (root == NULL)
			return 0;
		if (k == 1)
		{
			return 1;
		}
		return _GetKLevel(root->_leftchild, k - 1) + _GetKLevel(root->_rightchild, k - 1);
	}
	size_t _LeafSize(Node* root)//葉子節點的呼叫函式
	{
		if (root == NULL)
			return 0;
		if (root->_leftchild == NULL && root->_rightchild == NULL)
		{
			return 1;
		}
		return _LeafSize(root->_leftchild) + _LeafSize(root->_rightchild);
	}
	size_t _Depth(Node* root)//樹的深度呼叫函式
	{
		if (root == NULL)
			return 0;
		int left = _Depth(root->_leftchild);
		int right = _Depth(root->_rightchild);
		return left > right ? left + 1: right + 1;
	}
	size_t _Size(Node* root)//節點的個數
	{
		if (root == NULL)
			return 0;
		return (_Size(root->_leftchild) + _Size(root->_rightchild))+1;
	}
	void _PostOrder(Node* root)//後序遍歷呼叫函式
	{
		if (root == NULL)
			return;
		_PostOrder(root->_leftchild);
		_PostOrder(root->_rightchild);
		cout << root->_data << " ";
	}
	void _InOrder(Node* root)//中序遍歷的呼叫函式
	{
		if (root == NULL)
			return;
		_InOrder(root->_leftchild);
		cout << root->_data << " ";
		_InOrder(root->_rightchild);
	}
	void _PrevOrder(Node* root)//前序遍歷的呼叫函式
	{
		if (root == NULL)
			return;
		cout << root->_data << " ";
		_PrevOrder(root->_leftchild);
		_PrevOrder(root->_rightchild);
	}
	Node* _GreateTree(T* a, size_t n, const T& invalid, size_t& index)//建構函式的呼叫函式
	{
		Node* root = NULL;
		if ((index< n) && (a[index] != invalid))
		{
			root = new Node(a[index]);
			root->_leftchild = _GreateTree(a, n, invalid, ++index);
			root->_rightchild = _GreateTree(a, n, invalid, ++index);
		}
		return root;
	}
protected:
	Node* _root;
};

void BinaryTreeTest()//測試
{
	int a[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	BinaryTree<int> t1(a, sizeof(a) / sizeof(a[0]), '#');
	t1.PrevOrder();
	t1.LeveIOrder();
	t1.InOrder();
	t1.PostOrder();
	cout << "節點的個數：" << t1.Size() << endl;
	cout << "深度：" << t1.Depth() << endl;
	cout << "葉子節點的個數：" << t1.LeafSize() << endl;
	cout << "第k層：" << t1.GetKLevel(2) << endl;
	BinaryTree<int> t2(t1);
	t2.PostOrder();
	BinaryTree<int> t3;
	t3 = t1;
}

int main()
{
	BinaryTreeTest();
	return 0;
}