高级数据结构 | 创建二叉树 —递归与非递归实现：先序中序创建、中序后序创建 ...

最新推荐文章于 2022-11-05 17:00:50 发布
最新推荐文章于 2022-11-05 17:00:50 发布
阅读量2.7k 收藏 14
点赞数 3
分类专栏： 数据结构与算法 文章标签： 二叉树 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43919932/article/details/105372349
版权

对于使用二叉链表结构存储的二叉树，我们通常使用“递归—先序”的方式创建，并且在输入树中结点的数据时需要人为的加入‘#’以表示叶子节点（度为0的点）。

而我们知道，给定一个二叉树的中序遍历序列和其他任意一种优先深度遍历方式的序列都可以得到其完整的二叉树结构，那么我们能不能使用计算机来完成这一转化呢？

换言之，我们本章重点为：

  1. 使用先序和中序创建二叉树
  2. 使用中序和后序创建二叉树

文章目录

一、使用递归创建二叉树
先序中序创建二叉树

通过先序的第一个元素可知整棵树的根结点。而对于中序遍历来说，根结点在其序列中间位置。

  • 因此我们可以通过一个根节点将中序划分为两个部分，根节点之前，跟结点之后。
    例如：对于序列 ABDECF(先)、DBEACF(中)来说
    先：ABDECF 得到根结点 ⇒ A
    中：DBEACF
    对于结点A来说，这是一个树的根，也是一个树分叉的位置。
  • 如果我们利用分治的思想，把左边和右边分别再次使用相同的方法递归下去。那么最终就可以完整复原树的每一个结点和上面的分叉。

实现如下：

/* 找“根”结点的下标 */
int FindIndex(const ElemType* istr, int n, ElemType x)
{
	int pos = -1;
	for (int i = 0; i < n; ++i)
	{
		if (istr[i] == x)
		{
			pos = i;
			break;
		}
	}
	return pos;
}
struct BtNode* CreatePI(const char* pstr, const char* istr,int n)
{
	struct BtNode* s = NULL;
	if (n > 0)
	{
		s = Buynode();
		s->data = *pstr;
		int pos = FindIndex(istr,n,*pstr);	// 找当前规模的“根”的下标
		if (pos == -1) exit(0);
		s->leftchild = CreatePI(pstr + 1, istr, pos);//存储左边部分
		s->rightchild = CreatePI(pstr + pos + 1, istr + pos + 1, n - pos - 1);//存储右边部分
	}
	return s;
}
struct BtNode* CreateTreePI(const char *pstr,const char *istr,int n)
{
	if (NULL == pstr || NULL == istr || n < 1) return NULL;
	return CreatePI(pstr, istr, n);
}
中序后序创建二叉树

先序和后序是两种相反的遍历方式，先序：根左右，后序：左右根。

有趣的是，我们可以通过同样的算法完成中序、后序创建二叉树的过程，只需要在把后序颠倒过来。

那么，按照后序遍历的最后一个元素我们可以得到根结点，按照根结点可以把中序划分为两段。同样的我们使用分治的思想可以很方便的完成对二叉树的创建。

实现如下：

struct BtNode* CreateIL(const char* istr, const char* lstr, int n)
{
	struct BtNode* s = NULL;
	if (n > 0)
	{
		s = Buynode();
		s->data = lstr[n - 1];
		int pos = FindIndex(istr, n, lstr[n - 1]);	// 找叶子结点下标
		if (pos == -1) exit(0);
		s->leftchild = CreateIL(istr , lstr, pos);
		s->rightchild = CreateIL(istr + pos + 1, lstr + pos, n - pos - 1);
	}
	return s;
}
struct BtNode* CreateTreeIL(const char* istr, const char* lstr, int n)
{
	if (NULL == istr || NULL == lstr || n < 1) return NULL;
	return CreateIL(istr, lstr, n);
}
二、非递归创建二叉树

使用递归的好处在于递归可以自动回退回上一层的状态，而我们一般把递归改非递归的思路都是引入一种新的数据结构模拟这种回退的功能。

  • 先序遍历其实每一步都找的是根节点，只是第一个元素是整棵树的根节点，第二个元素是左子树的根节点，第三个元素是左子树的左子树的根节点。

  • 中序遍历可以看做是每一步都在遍历叶子结点，第一个元素是最左边子树的叶子结点，第二个元素是上一层子树的叶子结点… …

先序中序遍历思路：
因此，我们可以使用先序遍历，每次沿着“根”的左子树向下遍历，直到遇到叶子结点，也就是第一个中序遍历的元素。然后我们回退至上一层，回退至与中序的第二个元素结点相同处，找到一个有分叉的“根”节点，再继续以此根的右子树向下遍历，如此循环下去最终遍历完整个树。

在此遍历的过程中，我们已经完成了对二叉树的建立。在此过程中通过保存每次遍历的结点的值与中序序列进行比较，我们可以准确的回退至上一层的根结点处，继续沿着根的另一边子树遍历。

中序后序遍历思路：
后序遍历倒置过来后，首位元素即是我们的根节点元素，第二位元素即是此“根”下右子树的最右边的叶子结点。先序在首次遍历时从左子树最左边的叶子结点处开始，刚好与后序相反。

综上，相对于先序中序的遍历，我们只需做一些小小的改动即可。从后续序列末端开始遍历，与中序序列的末端进行比较，建立的二叉树的顺序是先右子树，再左子树。

先序中序创建二叉树

非递归的先序中序创建二叉树，实现如下：

#include <stack>		// 使用C++库中提供的数据结构——栈
/* 非递归 --先序中序 */
struct BtNode* NiceCreatePI(const char* pstr, const char* istr, int n)
{
	std::stack<struct BtNode*> st;
	bool flag = false;
	int i = 0, j = 0;		// i 指向先序，j 指向中序
	struct BtNode* root = Buynode();
	root->data = pstr[0];
	st.push(root);
	for (i = 1; i < n; ++i)
	{
		struct BtNode* s = Buynode();
		s->data = pstr[i];

		struct BtNode* tmp = NULL;
		while (j < n - 1 && st.top()->data == istr[j])	// 判断是否遇到分叉(“根”)
		{
			while (!st.empty() && st.top()->data == istr[j])	// 向上找有分叉的“根”
			{
				tmp = st.top();		// 该结点(“根”)有右子树
				st.pop();
				++j;
			}
			if (tmp != NULL)
			{
				tmp->rightchild = s;	// 把该结点添加至右子树
				if (i == n - 1) { flag = true; break; }
				st.push(s);				// 入栈	
				s = Buynode();
				s->data = pstr[++i];
			}
		}

		if (flag)	break;	// 创建完成，退出
		st.top()->leftchild = s;
		st.push(s);		// 入栈


	}
	return root;
}
struct BtNode* NiceCreateTreePI(const char* pstr, const char* istr, int n)
{
	if (NULL == pstr || NULL == istr || n < 1) return NULL;
	return NiceCreatePI(pstr, istr, n);
}
中序后序创建二叉树

非递归的中序后序创建二叉树，实现如下：

#include <stack>		// 使用C++库中提供的数据结构——栈
/* 非递归 --中序后序 */
struct BtNode* NiceCreateIL(const char* istr, const char* lstr, int n)
{
	std::stack<struct BtNode*> st;
	bool flag = false;
	int i = n, j = n;		// i 指向后序，j 指向中序
	struct BtNode* root = Buynode();
	root->data = lstr[n];
	st.push(root);
	for (i = n - 1; i >= 0; --i)
	{
		struct BtNode* s = Buynode();
		s->data = lstr[i];

		struct BtNode* tmp = NULL;
		while (j > 0 && st.top()->data == istr[j])	// 判断是否遇到分叉(“根”)
		{
			while (!st.empty() && st.top()->data == istr[j])	// 向上找有分叉的“根”
			{
				tmp = st.top();		// 该结点(“根”)有左子树
				st.pop();
				--j;
			}
			if (tmp != NULL)
			{
				tmp->leftchild = s;	// 把该结点添加至左子树
				if (i == 0) { flag = true; break; }
				st.push(s);				// 入栈
				s = Buynode();
				s->data = lstr[--i];

			}
		}

		if (flag) break;
		st.top()->rightchild = s;
		st.push(s);		// 入栈

	}
	return root;
}

struct BtNode* NiceCreateTreeIL(const char* istr, const char* lstr, int n)
{
	if (NULL == istr || NULL == lstr || n < 1) return NULL;
	return NiceCreateIL(istr, lstr, n - 1);
}
三、测试用例

输出形如 ABC##DE##F##G#H# 格式的先序序列字符串。

void strPreOrder(struct BtNode* p)
{
	if (NULL != p)
	{
		printf("%c", p->data);
		strPreOrder(p->leftchild);
		strPreOrder(p->rightchild);
	}
	else printf("#");
}

这里主要测试五种类型的二叉树，分别是普通的二叉树、只有左子树的二叉树、只有右子树的二叉树，根节点没有右子树的二叉树、根节点左子树的二叉树。


	//const char pstr[] = "ABCDEFGH"; //先序序列   		//   	     A
	//const char istr[] = "CBEDFAGH"; //中序序列   		//        B    G
	//const char lstr[] = "CEFDBHGA"; //后序序列   		//     C   D     H
														//        E  F 



		//左单 链表
	//const char pstr[] = "ABCDEFGH"; //先序序列   		//          A
	//const char istr[] = "HGFEDCBA"; //中序序列   		//         B
	//const char lstr[] = "HGFEDCBA"; //后序序列  		//        C
														//       D
														//      E
														//     F
														//    G
														//   H



		//右单 链表
	//const char pstr[] = "ABCDEFGH"; //先序序列   	   //     A
	//const char istr[] = "ABCDEFGH"; //中序序列   	   //      B
	//const char lstr[] = "HGFEDCBA"; //后序序列   	   //      	C
													   //      	 D
													   //      	  E
													   //      	   F
													   //      	    G
													   //      	     H



	//const char pstr[] = "ABCDEFGH"; //先序序列   	    //             A
	//const char istr[] = "DCFEGHBA"; //中序序列   	    //           B
	//const char lstr[] = "DFHGECBA"; //后序序列  	    //         C
													    //      D     E
													    //	        F    G
													    //		           H





	//const char pstr[] = "ABCDFE"; //先序序列			 //			A
	//const char istr[] = "ABFDCE"; //中序序列			 //			 B
	//const char lstr[] = "FDECBA"; //后序序列			 //			  C
														 //			D   E
														 //		 F 
	

	// {先序，中序，后序}
	const char*str[][20] = { 
	{"ABCDEFGH","CBEDFAGH","CEFDBHGA"},			// 普通二叉树
	{"ABCDEFGH","HGFEDCBA","HGFEDCBA"},			// 只有左子树，单链表结构
	{"ABCDEFGH","ABCDEFGH","HGFEDCBA"},			// 只有右子树，单链表结构
	{"ABCDEFGH","DCFEGHBA","DFHGECBA"},			// 根节点没有右子树
	{"ABCDFE","ABFDCE","FDECBA"}				// 根节点没有左子树
	};

全部代码：

#include <iostream>
#include <vector>


using namespace std;

typedef char ElemType;
typedef struct BtNode
{
	struct BtNode* leftchild;
	struct BtNode* rightchild;
	ElemType data;
}BtNode, * BinaryTree;

/* 购买结点,便于后期维护有关结点的申请的问题 */
struct BtNode* Buynode()
{
	struct BtNode* s = (struct BtNode*)malloc(sizeof(struct BtNode));
	if (NULL == s)	exit(1);
	memset(s, 0, sizeof(struct BtNode));
	return s;
}

void Freenode(struct BtNode* p)
{
	free(p);
}

/* 先序遍历 */
void PreOrder(struct BtNode* p)
{
	if (NULL != p)
	{
		printf("%c ", p->data);
		PreOrder(p->leftchild);
		PreOrder(p->rightchild);
	}
}


/* 中序遍历 */
void InOrder(struct BtNode* p)
{
	if (NULL != p)
	{
		InOrder(p->leftchild);
		printf("%c ", p->data);
		InOrder(p->rightchild);
	}
}


/* 后序遍历 */
void PastOrder(struct BtNode* p)
{
	if (NULL != p)
	{
		PastOrder(p->leftchild);
		PastOrder(p->rightchild);
		printf("%c ", p->data);
	}
}




#include <stack>		// 使用C++库中提供的数据结构——栈
/* 非递归 --先序中序 */
struct BtNode* NiceCreatePI(const char* pstr, const char* istr, int n)
{
	std::stack<struct BtNode*> st;
	bool flag = false;
	int i = 0, j = 0;		// i 指向先序，j 指向中序
	struct BtNode* root = Buynode();
	root->data = pstr[0];
	st.push(root);
	for (i = 1; i < n; ++i)
	{
		struct BtNode* s = Buynode();
		s->data = pstr[i];

		struct BtNode* tmp = NULL;
		while (j < n - 1 && st.top()->data == istr[j])	// 判断是否遇到分叉(“根”)
		{
			while (!st.empty() && st.top()->data == istr[j])	// 向上找有分叉的“根”
			{
				tmp = st.top();		// 该结点(“根”)有右子树
				st.pop();
				++j;
			}
			if (tmp != NULL)
			{
				tmp->rightchild = s;	// 把该结点添加至右子树
				if (i == n - 1) { flag = true; break; }
				st.push(s);				// 入栈	
				s = Buynode();
				s->data = pstr[++i];
			}
		}

		if (flag)	break;	// 创建完成，退出
		st.top()->leftchild = s;
		st.push(s);		// 入栈


	}
	return root;
}
struct BtNode* NiceCreateTreePI(const char* pstr, const char* istr, int n)
{
	if (NULL == pstr || NULL == istr || n < 1) return NULL;
	return NiceCreatePI(pstr, istr, n);
}


#include <stack>		// 使用C++库中提供的数据结构——栈
/* 非递归 --中序后序 */
struct BtNode* NiceCreateIL(const char* istr, const char* lstr, int n)
{
	std::stack<struct BtNode*> st;
	bool flag = false;
	int i = n, j = n;		// i 指向后序，j 指向中序
	struct BtNode* root = Buynode();
	root->data = lstr[n];
	st.push(root);
	for (i = n - 1; i >= 0; --i)
	{
		struct BtNode* s = Buynode();
		s->data = lstr[i];

		struct BtNode* tmp = NULL;
		while (j > 0 && st.top()->data == istr[j])	// 判断是否遇到分叉(“根”)
		{
			while (!st.empty() && st.top()->data == istr[j])	// 向上找有分叉的“根”
			{
				tmp = st.top();		// 该结点(“根”)有左子树
				st.pop();
				--j;
			}
			if (tmp != NULL)
			{
				tmp->leftchild = s;	// 把该结点添加至左子树
				if (i == 0) { flag = true; break; }
				st.push(s);				// 入栈
				s = Buynode();
				s->data = lstr[--i];

			}
		}

		if (flag) break;
		st.top()->rightchild = s;
		st.push(s);		// 入栈

	}
	return root;
}

struct BtNode* NiceCreateTreeIL(const char* istr, const char* lstr, int n)
{
	if (NULL == istr || NULL == lstr || n < 1) return NULL;
	return NiceCreateIL(istr, lstr, n - 1);
}


void strPreOrder(struct BtNode* p)
{
	if (NULL != p)
	{
		printf("%c", p->data);
		strPreOrder(p->leftchild);
		strPreOrder(p->rightchild);
	}
	else printf("#");
}

int main()
{
	// {先序，中序，后序}
	const char* str[][20] = {
	{"ABCDEFGH","CBEDFAGH","CEFDBHGA"},			// 普通二叉树
	{"ABCDEFGH","HGFEDCBA","HGFEDCBA"},			// 只有左子树，单链表结构
	{"ABCDEFGH","ABCDEFGH","HGFEDCBA"},			// 只有右子树，单链表结构
	{"ABCDEFGH","DCFEGHBA","DFHGECBA"},			// 根节点没有右子树
	{"ABCDFE","ABFDCE","FDECBA"}				// 根节点没有左子树
	};

	BinaryTree rootPI = NULL;		// 递归先序、中序
	BinaryTree rootIL = NULL;		// 递归中序、后序
	BinaryTree rootPI_r = NULL;		// 非递归先序、中序
	BinaryTree rootIL_r = NULL;		// 非递归中序、后序
	int len = sizeof(str) / sizeof(str[0]);
	while (len--)
	{
		int n = strlen(*str[len]);
		printf("●--第%d组测试用例：\n", len + 1);

		const char* pstr = str[len][0];
		const char* istr = str[len][1];
		const char* lstr = str[len][2];

		printf("使用‘#’表示：\n");
		rootPI = NiceCreateTreePI(pstr, istr, n); // 使用先序和中序创建二叉树 
		strPreOrder(rootPI);  printf("\n");
		rootIL = NiceCreateTreeIL(istr, lstr, n); // 使用中序和后序创建二叉树 
		strPreOrder(rootIL);  printf("\n");
		rootPI_r = NiceCreateTreePI(pstr, istr, n);
		strPreOrder(rootPI_r); printf("\n");
		rootIL_r = NiceCreateTreeIL(istr, lstr, n);
		strPreOrder(rootIL_r); printf("\n\n");

		printf("前序遍历：\t", ""); printf("%*s中序遍历：\t", n, ""); printf("%*s后序遍历：\n", n, "");
		PreOrder(rootPI); printf("\t");		 InOrder(rootPI); printf("\t");		  PastOrder(rootPI); printf("\n");
		PreOrder(rootIL); printf("\t");		 InOrder(rootIL); printf("\t");		  PastOrder(rootIL); printf("\n");
		PreOrder(rootPI_r); printf("\t");	 InOrder(rootPI_r); printf("\t");	  PastOrder(rootPI_r); printf("\n");
		PreOrder(rootIL_r); printf("\t");	 InOrder(rootIL_r); printf("\t");	  PastOrder(rootIL_r); printf("\n");


		puts("");
	}


	return 0;
}

/*		输出：
●--第5组测试用例：
使用‘#’表示：
A#B#CDF###E##
A#B#CDF###E##
A#B#CDF###E##
A#B#CDF###E##

前序遍历：            中序遍历：              后序遍历：
A B C D F E     A B F D C E     F D E C B A
A B C D F E     A B F D C E     F D E C B A
A B C D F E     A B F D C E     F D E C B A
A B C D F E     A B F D C E     F D E C B A

●--第4组测试用例：
使用‘#’表示：
ABCD##EF##G#H####
ABCD##EF##G#H####
ABCD##EF##G#H####
ABCD##EF##G#H####

前序遍历：              中序遍历：              后序遍历：
A B C D E F G H         D C F E G H B A         D F H G E C B A
A B C D E F G H         D C F E G H B A         D F H G E C B A
A B C D E F G H         D C F E G H B A         D F H G E C B A
A B C D E F G H         D C F E G H B A         D F H G E C B A

●--第3组测试用例：
使用‘#’表示：
A#B#C#D#E#F#G#H##
A#B#C#D#E#F#G#H##
A#B#C#D#E#F#G#H##
A#B#C#D#E#F#G#H##

前序遍历：              中序遍历：              后序遍历：
A B C D E F G H         A B C D E F G H         H G F E D C B A
A B C D E F G H         A B C D E F G H         H G F E D C B A
A B C D E F G H         A B C D E F G H         H G F E D C B A
A B C D E F G H         A B C D E F G H         H G F E D C B A

●--第2组测试用例：
使用‘#’表示：
ABCDEFGH#########
ABCDEFGH#########
ABCDEFGH#########
ABCDEFGH#########

前序遍历：              中序遍历：              后序遍历：
A B C D E F G H         H G F E D C B A         H G F E D C B A
A B C D E F G H         H G F E D C B A         H G F E D C B A
A B C D E F G H         H G F E D C B A         H G F E D C B A
A B C D E F G H         H G F E D C B A         H G F E D C B A

●--第1组测试用例：
使用‘#’表示：
ABC##DE##F##G#H##
ABC##DE##F##G#H##
ABC##DE##F##G#H##
ABC##DE##F##G#H##

前序遍历：              中序遍历：              后序遍历：
A B C D E F G H         C B E D F A G H         C E F D B H G A
A B C D E F G H         C B E D F A G H         C E F D B H G A
A B C D E F G H         C B E D F A G H         C E F D B H G A
A B C D E F G H         C B E D F A G H         C E F D B H G A

*/

2022.1.7更新…

四、力扣刷题

106. 从中序与后序遍历序列构造二叉树

[力扣LC]关于中序后序构造二叉树

在这里插入图片描述
思路：通过后缀式的特点，定位每个区间内根节点的位置。例如，通过后序最后一位可以确定树的根节点为3，从而将中序序列分成三部分。

接下来，分别对左区间和有区间做相同的操作即可。唯一的难点在于确定左区间根的位置与确定右区间根的位置。

对于左区间而言：
1. 根据后序特点：[左]-[右]-[根] 。我们通过中缀式计算得到 根右边节点个数。
2. 通过 当前根的位置 - 右节点个数 = 左结点位置
3. 而该左节位置的值即为左区间的根节点值。

在这里插入图片描述
对于右区间而言：

  1. 根据后序特点：[左]-[右]-[根] 。
  2. [左]-[[左]-[右]-[根]]-[根] 。因此，对于右区间而言，只需将 当前根位置减一，即可得到右区间的根位置。
    在这里插入图片描述
    全部代码参考：
class Solution {
    // 在中序遍历中找根位置
    int find_root(vector<int>& inorder, int begin, int end, int r_val)
    {
        int pos = -1;
        for ( ; begin <= end; ++begin)
        {
            if (inorder[begin] == r_val)
            {
                pos = begin;
                break;
            }
        }
        return pos;
    }
    TreeNode* createTree(vector<int>& inorder, int begin, int end, vector<int>& postorder, int n)
    {
        TreeNode* proot = nullptr;
        if (n >= 0 && begin<=end)  
        {
            int r_val = postorder[n]; // 获得根节点元素
            proot = new TreeNode(r_val);
            int pos = find_root(inorder, begin, end, r_val);    // 根节点在中序串的位置
            proot->left = createTree(inorder, begin, pos - 1, postorder, n - (end - pos) - 1); // 左区间 [begin,pos-1]
            proot->right = createTree(inorder, pos + 1, end, postorder, n - 1);	// 右区间 [pos+1,end]
        }
        return proot;
    }
    
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.empty() || postorder.empty() || inorder.size() != postorder.size())
            return nullptr;
        int n = postorder.size();
        return createTree(inorder, 0, n-1, postorder, n-1);
    }
};
[力扣LC]关于先序中序构造二叉树

同理可以参考中序+后序方式。

先序的特点：首位是树的根节点，则可以根据先序首位将中序分成三部分 （左子树，根，右子树）。
然后分别在左子树、右子树中通过上述方式继续相同的步骤，这里可以采用递归的方式进行。

而递归的出口条件是，当我们已经找到先序中的最后一个根，即先序序列的最后一位。（n < preorder.size()）。

全部代码参考：

class Solution {
    // 在中序遍历中找根位置
    int find_root(vector<int>& inorder, int begin, int end, int r_val)
    {
        int pos = -1;
        for ( ; begin <= end; ++begin)
        {
            if (inorder[begin] == r_val)
            {
                pos = begin;
                break;
            }
        }
        return pos;
    }
    TreeNode* createTree(vector<int>& inorder, int begin, int end, vector<int>& preorder, int n)
    {
        TreeNode* proot = nullptr;
        if (n <= preorder.size() && begin <= end) 
        {
            int r_val = preorder[n]; // 获得根节点元素
            proot = new TreeNode(r_val);
            int pos = find_root(inorder, begin, end, r_val);    // 根节点在中序串的位置
            
            proot->left = createTree(inorder, begin, pos - 1, preorder, n + 1);
            proot->right = createTree(inorder, pos + 1, end, preorder,  n + (pos - begin) +1);
        }
        return proot;
    }
    
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.empty() || inorder.empty() || preorder.size() != inorder.size())
            return nullptr;
        int n = preorder.size();
        return createTree(inorder, 0, n-1, preorder, 0);
    }
};
我叫RT
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构：二叉树的构建、前中后序遍历（递归vs非递归）思路及代码
sunny_yeah_的博客
07-03 935
二叉树的基本操作二叉树的创建构建二叉树的类对象先序遍历递归非递归中序遍历递归非递归后序遍历递归非递归层序遍历求解二叉树的高度最大高度最小高度 二叉树的创建 构建二叉树的类对象 在创建一棵二叉树之前，我们先创建一个二叉树的类对象Tree。类中包含的成员变量有：val、left、right，函数接口包括：先序遍历、中序遍历、后序遍历、层序遍历、二叉树高度 typedef int TreeElemt; class Tree{ public: enum Mode{NUM, CHAR}; private:
二叉树创建之先序法（非递归算法）入门详解（C语言版）
sunnyoldboy博客
07-19 8158
二叉树是一种非常重要的非线性数据结构，在信号处理、移动通讯等应用中均有重要的应用。 在二叉树的应用中，首先要建立二叉树。本文针对二叉树的先序建立过程给出了详细的实现过程，包括非递归算法和递归算法两种不同的实现模式。所谓的先序法，就是按照先序遍历二叉树的流程创建二叉树。使用的二叉树数据如下图所示。本文给出了C语言版本的先序创建二叉树的非递归算法。......
递归和非递归方式实现二叉树的先序、中序和后序遍历
明朗晨光的专栏
06-18 1910
二叉树的递归实现和非递归实现、递归序
非递归法创建二叉树
ljk的博客
12-04 3307
非递归法创建二叉树 层次遍历二叉树
C++实现二叉树的创建以及四种遍历方式（递归与非递归）
weixin_42133358的博客
05-23 4723
C++实现二叉树的创建以及四种遍历方式（递归与非递归） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 下图是我们要创建的二叉树，其中的#代表空字符； 为了验证我们程序的正确性，现给出此二叉树的四种遍历结果： 前序遍历（Preorder traversal）： A B C D E F
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
上述代码中的三个函数都是基于栈实现的非递归遍历，它们能够有效地处理任意大小的二叉树，而不会受到递归深度限制的影响。 在实际应用中，二叉树遍历可以用来进行多种操作，如查找、复制、排序等。比如，在编译器中...
链表先序建立二叉树，得到中序后序输出，递归和非递归实现(C++代码加设计报告)
07-15
在本课程设计中，我们将探讨如何使用C++编程语言来构建和操作二叉树，特别是通过先序遍历建立二叉树以及非递归方式实现中序遍历。这一过程涉及到了数据结构中的核心概念——二叉链表，以及递归和非递归算法的应用。 ...
数据结构试验报告用先序中序建立二叉树后序遍历非递归.doc
09-28
数据结构实验报告：创建并遍历二叉树非递归算法 数据结构实验报告的目的是熟悉二叉树存储结构，熟悉二叉树的三种遍历方法，并能用非递归的方法建立并遍历二叉树。本实验报告将详细介绍如何使用先序和中序建立二叉树...
c代码-非递归实现二叉树的先序、中序、后序遍历
07-16
在计算机科学中，二叉树是一种基础的数据结构，它由节点（或称为元素）组成，每个节点最多有两个子节点，通常分别称为左子节点和右子节点。二叉树的遍历是访问树中所有节点的过程，有三种基本的遍历方式：先序遍历、...
C++ 非递归二叉树创建
07-09
非递归实现C++二叉树 Node* creatTree(struct Node *head) void preOrderUnrec(struct Node *head) void inOrderUnrec(struct Node *head) void postOrderUnrec(struct Node *head)
二叉树的创建——递归与非递归
最新发布
ting_happy的博客
11-05 1009
初学者对于二叉树的遍历，这些放在最早学习的内容，应该是非常熟悉的，但是渐渐的就会发现，对于如何创建一颗二叉树，初学者对此过程还不甚清晰。直接一个一个结点插入吗？当树的深度过大时，这显然是一个费时费力的过程。以下我们介绍二叉树的创建的两种方法——递归与非递归。
根据先序序列和中序序列创建二叉树——递归及非递归实现详细讲解
vivi_and_qiao的博客
09-21 9342
二叉树存储结构： typedef struct Tnode { char data; struct Tnode *lnode; struct Tnode *rnode; }Tnode; typedef Tnode* type; 递归创建二叉树： Tnode *createtree6(char a[], int n1,int m1,char b[],int n2,int m2) { //...
非递归创建二叉树
杨龙飞的博客
03-13 2125
虽然我们能用递归创建二叉树，但是我们是否真正的理解真正的递归过程呢,其实，递归函数的内部还是挺复杂的，想真正弄明白递归也是要下一番功夫的，虽然说，递归算法有效的减少了某些问题的编程，但是它只能简化程序编码，却不能降低程序的时间和空间复杂度，相反，由于执行过程依赖函数或过程的重复调用,会增加函数的时间复杂度.而且返回函数的地址保存需要占用系统栈，从而增加的空间的复杂度。下面是我用栈实现了二叉树的非递
二叉树的先序遍历 非递归算法
m0_63168183的博客
04-12 2291
【问题描述】 给出一个按照“扩展遍历序列”的扩展先序遍历序列字符串，'.' 代表空的子节点，大写字母代表节点内容。请通过这个字符串建立二叉树，并参考课件上的算法，对该树利用栈进行非递归算法的遍历。注意，不用栈和非递归算法 不给分！ 【输入形式】 输入只有1行(以回车结束)，包含一个字符串S，用来建立二叉树。保证S为合法的二叉树扩展先序遍历字符串，节点内容只有大写字母，且S的长度不超过80。 【输出形式】 输出对该树先序遍历得出的节点序列。 【样例...
先序中序建立二叉树，先序非递归遍历
qq_58299006的博客
11-14 2896
题目内容 编写程序，实现以下功能： 按中序顺序建立一棵二叉树。 用先序非递归方式遍历二叉树。 算法设计 二叉树的创建可以是先序创建、先序中序创建、中序后序创建。显然不可以只用中序或者后序单独创建一棵二叉树。根据定义，二叉树的先序遍历是先访问根结点，再按照先序遍历方式遍历根结点的左子树，最后按照先序遍历方式遍历根结点的右子树。这就是说，再先序序列中，第一个结点一定是二叉树的根结点，另一方面，中序遍历是先遍历左子树，然后访问根结点，最后再遍历右子树，这样，根结点在中序序列中必然将中序序列分割成两个.
二叉树的先序遍历（非递归）
muyu_muyu的博客
12-13 6981
虽然递归简单理解，但是用递归内存开销大，耗时长，性能往往不如非递归方式 所以这里通过栈，用非递归方法实现二叉树的先序遍历 二叉树的存储结构定义： typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode; 思路：（根 右 左，由于要使用栈，会和原本的不同） 1，定义一个栈，定义初始化。 2.判断二叉树是否为
算法学习13：分别用递归和非递归方式实现二叉树先序、中序和后序遍历
effort_study的博客
03-05 829
数据结构 树结点 class Tree{ public: int data; Tree* left; Tree* right; Tree(int x){this->data=x;left=NULL;right=NULL;} }; 构造一颗二叉树 Tree* head=new Tree(1); head->left=new Tree(2); head->right=new Tree(3); head->left->left=new Tree(4); head-
[二叉树]分别用递归和非递归方式实现二叉树先序、中序和后序遍历
ltcz99的博客
11-13 573
题目：用递归和非递归两种方式，分别按照二叉树先序、中序和后序打印所有的节点。我们约定先遍历顺序为根、左、右；中序遍历顺序为左、根、右；后序遍历为左、右、根。 前提知识： 递归的遍历： 树的遍历与递归 最近做一个统计工作，需要遍历一些文件，一个文件夹下面有很多层的小文件，如何算出这个文件夹下面有多少文件？相信很多人第一时间都能想到递归遍历，这是最直接，最简单的办法。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧...
二叉树遍历详解：先序、中序、后序及宽度遍历
"本资源主要介绍了二叉树的四种遍历方法，包括先序遍历、中序遍历、后序遍历以及宽度优先遍历，并通过流程图详细展示了这些遍历的思想，同时提供了递归和非递归的实现方式。具体的代码实现可以在指定博客中查看。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我叫RT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值