数据结构——二叉树 （例题+代码）

目录

1、先说什么是树？

2、对于一个二叉树书上还有很多概念(需要掌握)；

3、设计一个二叉树的节点

4、设计一个二叉树；

 （1）顺序存储

 （2）链式存储

5、有了二叉树表示，应该怎样表示出来（打印）

（1）前序遍历打印（递归）

（1）前序遍历打印（非递归）

（2）中序遍历打印（递归）

（2）中序遍历打印（非递归）

（3）后续遍历打印（递归）

（3）后续遍历打印（非递归）

5、常见的二叉树构建问题

（1）已知前序后续构建二叉树

（2）已知后续中序构建二叉树

6、常见的二叉树打印问题

（1）Z字型打印

（2）水平打印二叉树

7、判断是否是满二叉树

8、判断是否是完全二叉树

---

1、先说什么是树？

树是什么?简单来说，它是一种数据结构，就如单链表来说，每个节点都至少有这几个点；数值、后继节点指针、（有时候会有前驱结点指针）；对于树来说，也是每个节点按照不同于链表连接方式连接；

首先看一张图，也就是下面所要讲解所有代码都要用的例子；

这个图可以看出一个最基本的二叉树节点，至少含有；一个值、一个左孩子、一个右孩子；其他的树比如，T树、红黑树、B+树、B-树、等也就是对该节点的扩充，但是重要的是整体模型还是如此；对于树的来说，就是对树节点的连接不同；

2、对于一个二叉树书上还有很多概念(需要掌握)；

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

根结点：根节点没有前驱结点。
除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。因此，树是递归定义的。
节点的度：一个节点含有的子树的个数称为该节点的度； 
叶节点：度为0的节点称为叶节点； 
非终端节点或分支节点：度不为0的节点；
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 
兄弟节点：具有相同父节点的节点互称为兄弟节点； 
树的度：一棵树中，最大的节点的度称为树的度；
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；
堂兄弟节点：双亲在同一层的节点互为堂兄弟；
节点的祖先：从根到该节点所经分支上的所有节点；
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
森林：由m棵互不相交的树的集合称为森林
 

3、设计一个二叉树的节点

有了二叉树的概念，设计出一个二叉树首先得设计一个树的节点；用结构体变量来定义一个节点。

typedef char ElemType;
typedef struct BtNode
{
	ElemType val;
	struct BtNode* Leftchild;;
	struct BtNode* Rightchild;
}BtNode,*BinaryNode;

4、设计一个二叉树；

有了节点，设计一个二叉树，就是怎样连接的问题了；

 （1）顺序存储

 以该图表示 也就是按照二叉树表示，每个下标都表示出来，也就是下标和树每个节点对相对应：

 （2）链式存储

 用代码表示：

为了后续代码遍历：先写出一个购买节点的函数

BtNode* Buynode()
{
	BtNode* s = (BtNode*)malloc(sizeof(BtNode));
	if (nullptr == s) exit(1);
	memset(s, 0, sizeof(BtNode));
}

BtNode* CBTree()
{
	BtNode* s = nullptr;
	ElemType elem;
	cin >> elem;
	if (elem != '#')
	{
		s = Buynode();
		s->val = elem;
		s->Leftchild = CBTree();
		s->Rightchild = CBTree();
	}
	return s;
}
int main（）
{
  BinaryNode ubuntu= CBTree();//ABC##DE##F##G#H##
  return 0;
}

5、有了二叉树表示，应该怎样表示出来（打印）

  对于二叉树来说，有三种顺序遍历打印；也有递归和非递归来区分，对于递归来说很简单；对于非递归来说；可以用栈来表示；

（1）前序遍历打印（递归）

void PrOrder(BtNode* p)
{
	if (p != nullptr)
	{
		cout << p->val <<" ";
		PrOrder(p->Leftchild);
		PrOrder(p->Rightchild);
	}
}

（1）前序遍历打印（非递归）

      使用栈来实现前序遍历的非递归；

void  NicePreOreder(BtNode* ptr)//非递归先序遍历
{
	if (ptr == NULL) return;
	std::stackst;
	while (ptr != NULL || !st.empty())
	{
		while (ptr != NULL)
		{
			st.push(ptr);
			cout << ptr->val;
			ptr = ptr->Leftchild;
		}
		ptr = st.top(); st.pop();
		ptr = ptr->Rightchild;
	}
	cout << endl;
}

（2）中序遍历打印（递归）

void InOrder(BtNode* p)
{
	if (p != nullptr)
	{
		InOrder(p->Leftchild);
		cout << p->val << " ";
		InOrder(p->Rightchild);
	}
}

（2）中序遍历打印（非递归）

void NiceInOreder(BtNode* ptr)//非递归中序遍历
{
	if (ptr == nullptr) return ;
	stack st;
	while (ptr != nullptr || !st.empty())
	{
		while (ptr != nullptr)
		{
			st.push(ptr);
			ptr = ptr->Leftchild;
		}
		ptr = st.top(); st.pop();
		cout << ptr->val << " ";
		ptr = ptr->Rightchild;
	}
}

（3）后续遍历打印（递归）

void PaOrder(BtNode* p)
{
	if (p != nullptr)
	{
		PaOrder(p->Leftchild);
		PaOrder(p->Rightchild);
		cout << p->val << " ";
	}
}

（3）后续遍历打印（非递归）

void  LastInOrder(BtNode* ptr)//后续非递归
{
	if (ptr == nullptr) return;
	stackst;
	BtNode * tmp = nullptr;
	while (ptr != nullptr || !st.empty())
	{
		while (ptr != nullptr)
		{
			st.push(ptr);
			ptr = ptr->Leftchild;
		}
		ptr = st.top();
		if (ptr->Rightchild == nullptr || ptr->Rightchild == tmp)
		{
			tmp = ptr;
			cout << ptr->val << " ";
			st.pop();
			ptr = nullptr;
		}
		else
		{
			ptr = ptr->Rightchild;
		}
	}
}

5、常见的二叉树构建问题

    char ps[] = { "ABCDEFGH" };//前
    char is[] = { "CBEDFAGH" };//中
    char ls[] = { "CEFDBHGA" };//后

（1）已知前序后续构建二叉树

BtNode* CreatePI(const char* ps, const char* is, int n)//前中构建
{
	BtNode* s = nullptr;
	if (n >= 1)
	{
		s = Buynode();
		s->val = ps[0];
		int pos = FindIs(is, n, ps[0]);
		if (pos == -1) exit(1);
		s->Leftchild = CreatePI(ps + 1, is, pos);
		s->Rightchild = CreatePI(ps + pos + 1, is + pos + 1, n - pos - 1);
	}
	return s;
}

（2）已知后续中序构建二叉树

BtNode* CreateIL(const char* is, const char* ls, int n)//后中建立
{
	BtNode* s = nullptr;
	if (n >= 1)
	{
		s = Buynode();
		s->val = ls[n - 1];
		int pos = FindIs(is, n, ls[n-1]);
		if (pos == -1) exit(1);
		s->Leftchild = CreateIL(is, ls, pos);
		s->Rightchild = CreateIL(is + pos + 1, ls + pos, n - pos - 1);
	}
	return s;
}

6、常见的二叉树打印问题

（1）Z字型打印

void ZLevelOder(BtNode* ptr)
{
	if (nullptr == ptr) return;
	stackst1;
	stackst2;
	st1.push(ptr);
	while (!st1.empty() || !st2.empty())
	{
		while (!st1.empty())
		{
			ptr = st1.top(); st1.pop();
			cout << ptr->val << " ";
			if (ptr->Leftchild != nullptr)
			{
				st2.push(ptr->Leftchild);
			}
			if (ptr->Rightchild != nullptr)
			{
				st2.push(ptr->Rightchild);
			}
		}
		cout << endl;
		while (!st2.empty())
		{
			ptr = st2.top(); st2.pop();
			cout << ptr->val << " ";
			if (ptr->Rightchild != nullptr)
			{
				st1.push(ptr->Rightchild);
			}
			if (ptr->Leftchild != nullptr)
			{
				st1.push(ptr->Leftchild);
			}
		}
		cout << endl;
	}
}

（2）水平打印二叉树

void LevelOder(BtNode* ptr)
{
	if (nullptr == ptr) return;
	queue qu;
	queue qu1;
	qu.push(ptr);
	while (!qu.empty() || !qu1.empty())
	{
		while (!qu.empty())
		{
			ptr = qu.front(); qu.pop();
			cout << ptr->val << " ";
			if (ptr->Leftchild != nullptr)
			{
				qu1.push(ptr->Leftchild);
			}
			if (ptr->Rightchild != nullptr)
			{
				qu1.push(ptr->Rightchild);
			}
		}
		cout << endl;
		while (!qu1.empty())
		{
			ptr = qu1.front(); qu1.pop();
			cout << ptr->val << " ";
			if (ptr->Leftchild != nullptr)
			{
				qu.push(ptr->Leftchild);
			}
			if (ptr->Rightchild != nullptr)
			{
				qu.push(ptr->Rightchild);
			}
		}
		cout << endl;
	}
}

7、判断是否是满二叉树

bool Is_FullBinaryTree(BtNode* ptr)
{
	bool tag = true;
	if (ptr == NULL)return tag;
	queueaqu;
	queuebqu;
	int s = 1;
	aqu.push(ptr);
	while (!aqu.empty() || !bqu.empty())
	{
		if (s != aqu.size())
		{
			tag = false;
			break;
		}
		while (!aqu.empty())
		{
			ptr = aqu.front(); aqu.pop();
			if (ptr->Leftchild != NULL)bqu.push(ptr->Leftchild);
			if (ptr->Rightchild != NULL)bqu.push(ptr->Rightchild);
		}
		s += s;
		if (s != bqu.size())
		{
			tag = false;
			break;
		}
		while (!bqu.empty())
		{
			ptr = bqu.front(); bqu.pop();
			if (ptr->Leftchild != NULL)aqu.push(ptr->Leftchild);
			if (ptr->Rightchild != NULL)aqu.push(ptr->Rightchild);
		}
		s += s;
	}
	return tag;
}

8、判断是否是完全二叉树

bool Is_CompBinaryTree(BtNode* ptr)
{
	bool tag = true;
	if (ptr == nullptr) return tag;
	queuequ;
	qu.push(ptr);
	while (!qu.empty())
	{
		ptr = qu.front(); qu.pop();
		if (ptr == nullptr) break;
		qu.push(ptr->Leftchild);
		qu.push(ptr->Rightchild);
	}
	while (!qu.empty())
	{
		if (qu.front() != nullptr)
		{
			tag = false;
			break;
		}
		qu.pop();
	}
}