二叉数的构造和遍历（递归与非递归）

1.定义：二叉数是（Binary Tree）是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉数），或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉数组成。

2.二叉数的特点：

        每个结点最多有两颗子树，所以二叉数中不存在度大于2的结点。注意不是只有两颗子树，而是最多有。没有子树或者有一颗树都是可以的。

        左子树和右子树都是有顺序的，次序不能任意颠倒。就像人双手、双脚，但显然左手左脚和右手右脚是不一样的，右手戴左手套，右脚穿左鞋都会及其别扭。

        即使树中某结点只有一颗子树，也要区分它是左子树还是右子树。

3.二叉数具有五种基本形态

        空二叉数、只有一个根结点、根结点只有左子树、根结点只有右子树、根结点既有左子树又有右子树。

递归方法建立、遍历二叉数

class Node
{
public:
	Node():m_left(nullptr),m_right(nullptr){}
	Node(char v):m_value(v),m_left(nullptr), m_right(nullptr){}
	char m_value;
	Node* m_left;
	Node* m_right;
};
class Tree
{
public:
    Tree():m_root(NULL){}
    Node*Create(const char*&str);
    void preOrder(Node*root);
    void InOrder(Node*root);
    void PostOrder(Node*root);
    int size(Node*root);
    int h(Node*root);
    Node*search(Node*root,char v);
    Node*m_root;
};
Node*Tree::create(const char*&str)
{
		if (*str == '#')
		{
			return NULL;
		}
		else
		{
			Node* root = new Node(*str);
			root->m_left = Create(++str);
			root->m_right = Create(++str);
			return root;
		}
}
void Tree::preOrder(Node*root)
{
    if (root!=NULL)
    {
        cout<<root->m_value<<" ";
        preOrder(root->m_left);
        preOrder(root->m_right);
    }
}
void Tree::InOrder(Node*root)
{
    if (root!=NULL)
    {
        InOrder(root->m_left);
        cout<<root->m_value<<" ";
        InOrder(root->m_right);
    }
}
void Tree::PostOrder(Node*root)
{
    if (root!=NULL)
    {
        PostOrder(root->m_left);
        PostOrder(root->m_right);
        cout<<root->m_value<<" ";
    }
}
int Tree::size(Node*root)
{
    if (root==nullptr)
    {
        return 0;
    }
    else
        return size(root->m_left)+size(root->m_right)+1;
}
int Tree::h(Node*root)
{
    if (root==nullptr)
    {
        return 0;
    }
    int L=h(root->m_left);
    int R=h(root->m_right);
    return L>R?(L+1):(R+1);
}
Node* Tree::search(Node*root,char v)
{
    Node*p=nullptr;
    if (root==nullptr)
    {
        return nullptr;
    }
    if (root->m_value==v)
    {
        return root;
    }
    p=search(root->m_left,v);
    if (p!=nullptr)
    {
        return p;
    }
    return search(root->m_right,v);
}
void main()
{
	Tree t;
	const char* str = "ABDG##I###CE#J##F##";
	t.m_root = t.Create(str);
	cout << "PreOrder:";
	t.preOrder(t.m_root);
	cout << endl;
	cout << "InOrder:";
	t.InOrder(t.m_root);
	cout << endl;
	cout << "PostOrder:";
	t.PostOder(t.m_root);
	cout << endl;
	cout<<t.size(t.m_root)<<" ";
	cout << endl;
	cout << t.h(t.m_root) << " ";
	cout << endl;
	Node*p=t.search(t.m_root,'C');
	if (p)
	{
		cout << p->m_value << " ";
	}
}

运行结果：

 非递归实现二叉数的先序、中序、后序、层次遍历

class Node
{
public:
	Node():m_left(nullptr),m_right(nullptr){}
	Node(char v):m_value(v),m_left(nullptr), m_right(nullptr){}
	char m_value;
	Node* m_left;
	Node* m_right;
};
class Tree
{
public:
	Tree():m_root(nullptr){}
	void CreatePre(Node*& root, const char*& str);
	Node* m_root;
	void PreOrder();
	void InOrder();
	void postOrder();
	void LecerOrder();
};
void Tree::CreatePre(Node*& root, const char*& str)
	{
		if (*str == '#')
		{
			root = nullptr;
		}
		else
		{
			root = new Node(*str);
			CreatePre(root->m_left, ++str);
			CreatePre(root->m_right, ++str);
		}
	}
void Tree::PreOrder()
{
	Node* p = m_root;
	stack<Node*> q;
	if (p != nullptr)
	{
		q.push(p);
		while (!q.empty())
		{
			Node* front = nullptr;
			front = q.top();
			cout << front->m_value << " ";
			q.pop();
			if (front->m_right != nullptr)//陷入右孩子为了将左边访问完，能够再找到右孩子
			{
				q.push(front->m_right);
			}
			if (front->m_left != nullptr)
			{
				q.push(front->m_left);
			}
		}
	}
}
void Tree::InOrder()
{
	Node* p = m_root;
	stack<Node*> q;
	while (p || !q.empty())
	{
		while(p)
		{
			q.push(p);
			p = p->m_left;
		}
		Node* front = q.top();
		cout << front->m_value << " ";
		q.pop();
		p = front->m_right;//将操作移到当前的右子树
	}
	cout << endl;
}
void Tree::postOrder()
{
	Node* pre = nullptr;
	stack<Node*> q;
	Node* top = nullptr;
	if (m_root != nullptr)
	{
		q.push(m_root);
		while (!q.empty())
		{
			top = q.top();
			if ((top->m_left == nullptr && top->m_right == nullptr) || ( pre != nullptr&&top->m_left==pre || pre != nullptr && top->m_right == pre))
			{
				cout << top->m_value << " ";
				q.pop();
				pre = top;
			}
			else
			{
				if (top->m_right)
				{
					q.push(top->m_right);
				}
				if (top->m_left)
				{
					q.push(top->m_left);
				}
			}
		}
	}
}
void Tree::LecerOrder()
{
	queue<Node*>qq;
	Node* front = nullptr;
	if (m_root != nullptr)
	{
		qq.push(m_root);
		while (!qq.empty())
		{
			front = qq.front();
			cout << front->m_value << " ";
			qq.pop();
			if (front->m_left)
			{
				qq.push(front->m_left);
			}
			if (front->m_right)
			{
				qq.push(front->m_right);
			}
		}
	}
	cout << endl;
}
void main()
{
	Tree t;
	const char* str = "ABDG##I###CE#J##F##";
	t.CreatePre(t.m_root,str);
	cout << "PreOrder:";
	t.PreOrder();
	cout << endl;
	cout << "InOrder:";
	t.InOrder();
	cout << endl;
	cout << "postOrder";
	t.postOrder();
	cout << endl;
	cout << "LeverOrder";
	t.LecerOrder();
	cout << endl;
}

运行结果：