二叉树的创建、（七种）遍历

这一篇博客主要总结一下二叉树的创建、遍历以及整个流程。

会对二叉树的遍历进行总结，二叉树可是有七种（三大类）遍历方式的！

科普：

树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。

二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。

（一）、二叉树的创建

1、二叉树的存储结构

跟很多其它模型一样，也有顺序和链式两种方式。前者虽然使用简单，但是存在浪费空间的问题，举个例子，下图的二叉树，用顺序的方式存储(0表示空，没有子树)是:

1 2 3 4 5 6 7 0 0 0 0 8 0 0 0

是不是相当浪费空间呢。

 （1）、顺序存储：  

（对完全二叉树来说，可以充分利用存储空间，但对于一般的二叉树，只有少数的存储单元被利用）

1. typedef struct   
2. {  
3.     ElemType data[MaxSize];  
4.     int n;  
5. }SqBTree;

（2）、链式存储结构

是一类重要的数据结构，其形式定义如下：

template<class T>
struct  BinaryTreeNode//三元组创建节点（二叉树节点）
{
	BinaryTreeNode(const T& data)
    : _data(data)//数据域
	, _pLeft(NULL)//左孩子指针
	, _pRight(NULL)//右孩子指针
    {}
	T _data;
	BinaryTreeNode<T>* _pLeft;
	BinaryTreeNode<T>* _pRight;

};

通过读入一个字符串，建立二叉树的算法如下：

void _CreatTree( BinaryTreeNode<T>*& pRoot, const T arr[], size_t size, size_t& index)//按先序创建二叉树
	{
		if (index<size && arr[index] != '#')
		{
			pRoot = new BinaryTreeNode<T>(arr[index]);
			_CreatTree(pRoot->_pLeft, arr, size, ++index);
			_CreatTree(pRoot->_pRight, arr, size, ++index);
		}
	}

#include<iostream>
using namespace std;
#pragma once

template<class T>
struct  BinaryTreeNode//三元组创建节点（二叉树节点）
{
	BinaryTreeNode(const T& data)
    : _data(data)//数据域
	, _pLeft(NULL)//左孩子指针
	, _pRight(NULL)//右孩子指针
    {}
	T _data;
	BinaryTreeNode<T>* _pLeft;
	BinaryTreeNode<T>* _pRight;

};
	

template<class T>
class BinaryTree
{
public:
	BinaryTree()//构造函数 ——空树
		:_pRoot(NULL)
	{}

	BinaryTree(const T arr[], size_t size)//构造函数---创建树
	{
		size_t index = 0;
		_CreatTree(_pRoot, arr, size, index);
	}

	void _CreatTree( BinaryTreeNode<T>*& pRoot, const T arr[], size_t size, size_t& index)//按先序创建二叉树
	{
		if (index<size && arr[index] != '#')
		{
			pRoot = new BinaryTreeNode<T>(arr[index]);
			_CreatTree(pRoot->_pLeft, arr, size, ++index);
			_CreatTree(pRoot->_pRight, arr, size, ++index);
		}
	}

	BinaryTree(const BinaryTree<T>& t)//拷贝构造函数
	{
		_pRoot = _CopyTree(t.pRoot);
	}

	BinaryTreeNode<T>*  _CopyTree(BinaryTreeNode<T>*& pRoot)
	{
		BinaryTreeNode<T>* newpRoot = NULL;
		if (pRoot)
		{
			newpRoot = new BinaryTreeNode<T>(pRoot->data);
			newpRoot->_pLeft = _CopyTree(pRoot->_pLeft);
			newpRoot->_pRight = _CopyTree(pRoot->_pRight);
		}
		return newpRoot;
	}

    BinaryTree<T>& operator=(const BinaryTree<T>& t)//赋值运算符重载
	{
		if (this != &t)
		{
			_DestroyTree(_pRoot);
			_pRoot = _CopyTree(t.pRoot);
		}
		return *this;
	}

	~BinaryTree()//析构函数
	{
		_DestroyTree(_pRoot);
	}

	void _DestroyTree(BinaryTreeNode<T>*& pRoot)//释放节点的函数
	{
		if (pRoot)
		{
			_DestroyTree(pRoot->_pLeft);
			_DestroyTree(pRoot->_pRight);
			delete pRoot;
			pRoot = NULL;
		}
	}

private:
	BinaryTreeNode<T>* _pRoot;
};
int main()
{
	char arr[] = { '0', '1', '3', '#', '#', '4', '#', '#', '2', '5' };
	BinaryTree<char> t (arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

（二）、二叉树的遍历：（具体的七种遍历方式）

遍历是对树的一种最基本的运算，所谓遍历二叉树，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。

（1）、前序遍历递归形式

//前序遍历（递归）
	void PreOrder()
	{
		cout << "PreOrder:" << endl;
		_PreOrder(_pRoot);
	}
	void _PreOrder(BinaryTreeNode<T>* pRoot)
	{
		if (pRoot)
		{
			cout << pRoot->_data << " ";
			_PreOrder(pRoot->_pLeft);
			_PreOrder(pRoot->_pRight);
		}
	}

//中序遍历（递归）
	void InOrder()
	{
		cout << "InOrder:" << endl;
		_InOrder(_pRoot);
	}
	void _InOrder(BinaryTreeNode<T>* pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			_InOrder(pRoot->_pRight);
		}
	}
	

//后序遍历（递归）
    void PostOrder()
	{
		cout << "PostOrder:" << endl;
		_PostOrder(_pRoot);
	}
	void _PostOrder(BinaryTreeNode<T>* pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
		    _InOrder(pRoot->_pRight);	
			cout << pRoot->_data << " ";
		}
	}

//层序遍历（非递归---------队列）(水平输出，一层一层的输出)
	void LeverOrder()
	{
		cout << "LeverOrder:" << endl;
		_LeverOrder(_pRoot);
	}
	void _LeverOrder(BinaryTreeNode<T>* pRoot)
	{
		queue <BinaryTreeNode<T>*> q;
		if (pRoot)
		{
			q.push(pRoot);
		}
		while (!q.empty())
		{
			BinaryTreeNode<T>* pCur = q.front();
			cout << pCur->_data << " ";
			if (pCur->_pLeft)
			{
				q.push(pCur->_pLeft);
			}
			if (pCur->_pRight)
			{
				q.push(pCur->_pRight);
			}
			q.pop();
		}
	}

//新的前序遍历（非递归—————栈）根 左 右
	void PreOrder_Nor()
	{
		cout << "PreOrder_Nor:" << endl;
		_PreOrder_Nor(_pRoot);
	}
	void _PreOrder_Nor(BinaryTreeNode<T>* pRoot)
	{
		stack<BinaryTreeNode<T>*> s;
		if (pRoot)
		{
			s.push(pRoot);
		}
		while (!s.empty())
		{
			BinaryTreeNode<T>* pCur = s.top();
			cout << pCur->_data << " ";
			s.pop();
			if (pCur->_pRight)
			{
				s.push(pCur->_pRight);
			}
			if (pCur->_pLeft)
			{
				s.push(pCur->_pLeft);
			}
			
        }
	}

//新的中序遍历——（非递归——利用栈）左 根 右
	void InOrder_Nor()
	{
		cout << "InOrder_Nor:" << endl;
		_InOrder_Nor(_pRoot);
	}
	void _InOrder_Nor(BinaryTreeNode<T>* pRoot)
	{
		stack<BinaryTreeNode<T>* > s;
		BinaryTreeNode<T>* pCur = pRoot;
		while (pCur||!s.empty())
		{ 
			while (pCur)
			{
				s.push(pCur);
				pCur = pCur->_pLeft;
			}
			if (!s.empty())
			{
				BinaryTreeNode<T>* pTop = s.top();
				cout << pTop->_data << " ";
				s.pop();
				pCur= pTop->_pRight;
			}
		}
	}

//新的后序遍历-----(非递归——利用栈) 左 右 根
	void PostOrder_Nor()
	{
		cout << "PostOrder_Nor:" << endl;
		_PostOrder_Nor(_pRoot);
	}

	void _PostOrder_Nor(BinaryTreeNode<T>* pRoot)
	{
		stack<BinaryTreeNode<T>* > s;
		BinaryTreeNode<T>* pCur = pRoot;
		BinaryTreeNode<T>* pRev = NULL;
		while (pCur || !s.empty())
		{
			while (pCur)
			{
				s.push(pCur);
				pCur = pCur->_pLeft;
			}
			BinaryTreeNode<T>* pTop = s.top();
			if (pTop->_pRight == NULL || pTop->_pRight == pRev)
			{
				cout << pTop->_data << " ";
				s.pop();
				pRev=pTop;
			}
			else
			{
				pCur = pTop->_pRight;
			}
		}
	}