二叉树先序、中序、后序遍历（递归、非递归）及层次遍历以及二叉树线索化以及线索化二叉树六种遍历、并查集（代码演示+注释解析）以及一些真题介绍

置顶 已于 2024-08-05 16:00:56 修改
阅读量2.1k 收藏 39
点赞数 8
分类专栏： 数据结构与算法 真题 文章标签： c语言 算法 c++ leetcode
于 2023-01-15 22:29:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigbbug/article/details/128698686
版权
文章详细介绍了二叉树的四种遍历方法（先序、中序、后序、层序）的递归和非递归实现，并提供了相应的C++代码示例。此外，还讲解了线索二叉树的概念，如何进行二叉树的线索化以及如何通过线索进行中序、先序和后序的非递归遍历。
摘要由CSDN通过智能技术生成

1.四种遍历

先序遍历 依次遍历：根结点，左子树，右子树
中序遍历 依次遍历：左子树，根结点，右子树
后序遍历 依次遍历：左子树，右子树，根结点
层序遍历：深度优先遍历

这里给出一棵树，进行四种遍历：
在这里插入图片描述
递归：

#include<iostream>
#include<queue>
using namespace std;

typedef char DataType;

//二叉树
typedef struct TreeNode {
	DataType val;
	struct TreeNode* left;
	struct TreeNode* right;
	TreeNode(DataType data) :val(data), left(NULL), right(NULL) {};
}TNode;


//先序遍历：根左右
void PreOrder(TNode* root) {
	if (root == NULL) return;//如果节点为空 则返回上一级

	printf("%c ", root->val);//打印根节点
	PreOrder(root->left);//先遍历左子树
	PreOrder(root->right);//再遍历右子树
}

//中序遍历：左根右
void InOrder(TNode* root) {
	if (root == NULL) return;//如果节点为空 则返回上一级

	InOrder(root->left);//先遍历左子树
	printf("%c ", root->val);//左子树遍历完 打印当前节点
	InOrder(root->right);//再遍历右子树
}

//后序遍历：左右根
void PostOrder(TNode* root) {
	if (root == NULL) return;//如果节点为空 则返回上一级

	PostOrder(root->left);//先遍历左子树
	PostOrder(root->right);//再遍历右子树
	printf("%c ", root->val);//左右子树遍历完 打印当前节点
}

//层序遍历  广度优先遍历
//核心思路: 上一层出的时候带下一层节点进
//这里可以考虑用到数据结构中的队列存储节点
void LevelOrder(TNode* root) {
	queue<TNode*> q;
	if(root) q.push(root);
	while (!q.empty()) {
		TNode* t = q.front();//取出来队列前面的节点
		printf("%c ", t->val);
		q.pop();//删掉
		//上一层出 下一层进
		if (t->left) q.push(t->left);
		if (t->right) q.push(t->right);
	}
}


int main() {
	//节点初始化
	TNode* root = new TNode('A');
	TNode* B = new TNode('B');
	TNode* C = new TNode('C');
	TNode* D = new TNode('D');
	TNode* E = new TNode('E');
	TNode* F = new TNode('F');
	TNode* G = new TNode('G');
	TNode* H = new TNode('H');
	TNode* I = new TNode('I');

	//构建二叉树
	root->left = B;
	root->right = C;
	B->left = D;
	B->right = E;
	D->left = H;
	C->left = F;
	C->right = G;
	F->left = I;

	//先序遍历
	cout << "先序遍历：";
	PreOrder(root);
	puts("");

	//中序遍历
	cout << "中序遍历：";
	InOrder(root);
	puts("");

	//后序遍历
	cout << "后序遍历：";
	PostOrder(root);
	puts("");

	//层序遍历
	cout << "层序遍历：";
	LevelOrder(root);
	puts("");
	
	return 0;
}

先序遍历：A B D H E C F I G
中序遍历：H D B E A I F C G
后序遍历：H D E B I F G C A
层序遍历：A B C D E F G H I

三种遍历非递归：

 //节点总数
int TreeSize(struct TreeNode* root){
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
}
 
//先序
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    if(root==NULL){
        *returnSize = 0;
        return (int*)malloc(sizeof(int)*0);
    }
    int size = TreeSize(root);//获得树的节点数
    int* ans = (int*)malloc(sizeof(int)*size);//开辟数组
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int top = 0;
    int i = 0;
    s[top++] = root;
    while(i<size){
        struct TreeNode* node = s[--top];//出栈
        if(node){
            if(node->right) s[top++] = node->right;
            if(node->left) s[top++] = node->left;
            s[top++] = node;
            s[top++] = NULL;//表明前一个根节点已经访问过子树
        }else{
            ans[i++] = s[--top]->val;
        }
 
    }
    free(s);//释放内存
    *returnSize = size;
    return ans;
}
 
 //中序
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    if(root==NULL){
        *returnSize=0;
        return (int*)malloc(sizeof(int)*0);
    }
    int size = TreeSize(root);
    *returnSize = size;
    int* ans = (int*)malloc(sizeof(int)*size);
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int i = 0;
    int top = 0;//栈顶
    s[top++] = root;
    while(i<size){
        struct TreeNode* node = s[--top];
        if(node){
            if(node->right) s[top++] = node->right;
            s[top++] = node;
            s[top++] = NULL;
            if(node->left) s[top++] = node->left;
        }else{
            ans[i++] = s[--top]->val;
        }
    }
    free(s);
    return ans;
}

//后序
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    if(root==NULL) {
        *returnSize = 0;
        return (int*)malloc(sizeof(int)*0);  
    }
    int size = TreeSize(root);//获得树的节点数
    int* ans = (int*)malloc(sizeof(int)*size);//开辟数组
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int top = 0;
    int i = 0;
    s[top++] = root;
    //先根右左进栈，之后左右根出栈
    //这里注意如果root本来就为空，下面则会发生越界 所以不建议while(top>0) 或者开头便判断是否为空
    while(i<size){
        struct TreeNode* node = s[--top];//弹出栈顶元素 并且pop掉
        if(node){//元素不为NULL
            s[top++] = node;
            s[top++] = NULL;//NULL标记前面根节点已经被访问
            if(node->right) s[top++] = node->right;
            if(node->left) s[top++] = node->left;
        }else{
            ans[i++] = s[--top]->val;
        }
        
    }
    free(s);//释放内存
    *returnSize = size;
    return ans;
}

王道版本非递归：

//节点总数
int TreeSize(struct TreeNode* root){
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
}

//先序
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    if(root==NULL){
        *returnSize = 0;
        return (int*)malloc(sizeof(int)*0);
    }
    int size = TreeSize(root);//获得树的节点数
    int* ans = (int*)malloc(sizeof(int)*size);//开辟数组
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int top = 0;
    int i = 0;
    struct TreeNode* node = root;
    while(i<size){
        if(node){
            ans[i++] = node->val;
            s[top++] = node;
            node = node->left;
        }else{
           node = s[--top];
           node = node->right; 
        }
    }
    free(s);//释放内存
    *returnSize = size;
    return ans;
}

//中序
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    if(!root){//空树
        *returnSize = 0;
        return (int*)malloc(sizeof(int*)*0);
    }
    int size = TreeSize(root);
    *returnSize = size;
    int* ans = (int*) malloc(sizeof(int)*size);
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int i = 0;
    int top = 0;//栈顶
    struct TreeNode* node = root;
    while(i<size){
        if(node){//一直检索左孩子
            s[top++] = node;//入栈
            node = node->left;//一路向左
        }else{//出栈
            node = s[--top];//栈顶元素出栈
            ans[i++] = node->val;
            node = node->right;//右子树
        }
    }
    free(s);
    return ans;
}

//后序
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    if(root==NULL) {
        *returnSize = 0;
        return (int*)malloc(sizeof(int)*0);  
    }
    int size = TreeSize(root);//获得树的节点数
    int* ans = (int*)malloc(sizeof(int)*size);//开辟数组
    struct TreeNode** s = (struct TreeNode*)malloc(sizeof(struct TreeNode*)*size*2);//模拟栈
    int top = 0;
    int i = 0;
    struct TreeNode* node = root;
    struct TreeNode* r = NULL;
    while(i<size){
        if(node){
            s[top++] = node;
            node = node->left;
        }
        else{
            node = s[top-1];
            if(node->right&&r!=node->right){//防止重复遍历右子树
                node = node->right;
            }
            else{
                r = s[--top];
                ans[i++] = r->val;
                node = NULL;
            }
        }
    }
    free(s);//释放内存
    *returnSize = size;
    return ans;
}

2.线索二叉树

（1）二叉树线索化

//线索二叉树
typedef struct ThreadTree{
	DataType val;
	struct ThreadTree* left;
	struct ThreadTree* right;
	int ltag,rtag;
}ThreadTree;

//全局变量，指向当前访问节点前驱
ThreadTree* pre = NULL;

void visit(ThreadTree* p){
	//空链线索化
	//当前左前驱
	if(p->left==NULL){
		p->ltag = 1;
		p->left = pre;
	}
	//pre右后续
	if(pre!=NULL&&pre->right==NULL){
		pre->rtag = 1;
		pre->right = p;
	}
	pre = p;
	//开始访问下一节点
}

//先序遍历二叉树，同时进行线索化
//这里跟先序遍历没有太大区别，只是在访问的过程中对节点线索化
void PreThreadTree(ThreadTree* p){
	if(!p) return ;
	visit(p);
	//易错点
	//注意前面visit可能已经修改了节点左孩子指向前驱，避免循环在这里需要判断
	if(p->ltag==0) PreThreadTree(p->left);
	PreThreadTree(p->left);
	PreThreadTree(p->right);
}

//中序遍历二叉树，同时进行线索化
//这里跟中序遍历没有太大区别，只是在访问的过程中对节点线索化
void InThreadTree(ThreadTree* p){
	if(!p) return ;
	InThreadTree(p->left);
	visit(p);
	InThreadTree(p->right);
}

//后序遍历二叉树，同时进行线索化
//这里跟后序遍历没有太大区别，只是在访问的过程中对节点线索化
void PostThreadTree(ThreadTree* p){
	if(!p) return ;
	InThreadTree(p->left);
	InThreadTree(p->right);
	visit(p);
}

int main(){
	TreadTree* root;
	init(root);//初始化树
	//先遍历线索化
	if(root){
		PreThreadTree(root);
		//注意处理先序遍历的最后一个节点，后续为空
		pre->rtag = 1;
		pre->right = NULL;
	}
	//中序遍历线索化
	if(root){
		InThreadTree(root);
		//注意处理中序遍历的最后一个节点，后续为空
		pre->rtag = 1;
		pre->right = NULL;
	}
	//后序遍历线索化
	if(root){
		PostThreadTree(root);
		//注意处理后序遍历的最后一个节点，后续为空
		if(!pre){
			pre->rtag = 1;
			pre->right = NULL;
		}
	}
}

（2）线索二叉树遍历

①中序线索二叉树遍历

图解：
在这里插入图片描述在这里插入图片描述
代码：

typedef struct ThreadTree{
	DataType val;
	struct ThreadTree* left;
	struct ThreadTree* right;
	int ltag,rtag;
}ThreadTree;

//中序线索二叉树找中序后续
//相当于非递归实现中序遍历
//首先找到以p为根的子树中第一个被中序遍历的节点
ThreadTree* FirstNode(ThreadTree* p){
	//循环找到最左下节点，即中序遍历的首节点
	while(p->ltag==0) p = p->left;
	return p;
}
//寻找节点p的后续节点
ThreadNode* NextNode(ThreadTree* p){
	//若节点p的右子树有孩子，则无法找到直接后续，需要中序遍历右子树，寻找右子树最左下节点（即后续）
	if(p->rtag==0) return FirstNode(p->right);
	//rtag==1直接得到后续
	return p->right;
}
//通过找中序后续实现中序遍历（利用线索实现非递归中序遍历）
void InOrder(ThreadTree* root){
	for(Thread* p = FirstNode(root);p!=NULL;p = NextNode(p)){
		visit(p);
	}
}


//中序线索二叉树找中序前驱
//相当于非递归实现逆中序遍历
//首先找到以p为根的子树中最后一个被中序遍历的节点
ThreadTree* LastNode(ThreadTree* p){
	//循环找到最右下节点（不一定是叶子结点）左根右（左根）
	while(p->rtag==0) p = p->right;
	return p;
/*这段代码我最开始理解错了，想着应该是叶子结点，但是是左根右，只要是最右下就行了，现在找到了最右下，即使有左孩子，此时根据中序特征，也可知左子树优先于根。这里是对应先序遍历的最后一个叶子结点。
	//此时已经是最后一个叶子节点，即先序遍历的最后一个节点
	if(p->ltag&&p->rtag)  return p;
	//此节点还有右子树
	if(p->rtag==0) return LastNode(p->right);
	//此根节点还有左子树
	if(p->ltag==0) return LastNode(p->left); 
*/
}

//寻找节点p的前驱节点
ThreadNode* PreNode(ThreadTree* p){
	//若节点p的左子树有孩子，则无法找到直接前驱，需要中序遍历左子树，寻找右子树最右下节点（即前驱）
	if(p->ltag==0) return LastNode(p->left);
	//ltag==1直接得到前驱
	return p->left;
}
//通过找中序前驱实现逆中序遍历
void RevInOrder(ThreadTree* root){
	for(Thread* p = LastNode(root);p!=NULL;p = PreNode(p)){
		visit(p);
	}
}

②先序线索二叉树遍历

图解：
在这里插入图片描述

在这里插入图片描述
代码：

typedef struct ThreadTree{
	DataType val;
	struct ThreadTree* left;
	struct ThreadTree* right;
	struct ThreadTree* parent;
	int ltag,rtag;
}ThreadTree;

//先序线索二叉树找先序后续
//相当于非递归实现先序遍历
//首先找到以p为根的子树中第一个被先序遍历的节点，即根节点
//寻找节点p的后续节点
ThreadNode* NextNode(ThreadTree* p){
	//若节点p的右子树有孩子，则无法找到直接后续
	if(p->rtag==0){
		//若有左孩子，则后续为左孩子
		if(!p->ltag) retuen p-left;
		//若无则后续为右孩子
		return p->right;//这步可省略
	}
	//rtag==1直接得到后续
	return p->right;
}
//通过找先序后续实现先序遍历（利用线索实现非递归先序遍历）
void PreOrder(ThreadTree* root){
	for(ThreadTree* p = root;p!=NULL;p = NextNode(p)){
		visit(p);
	}
}


//先序线索二叉树找先序前驱
//相当于非递归实现逆先序遍历
//首先找到以p为根的子树中最后一个被先序遍历的节点（这里注意与上面中序遍历找最后一个节点的区别）
ThreadTree* LastNode(ThreadTree* p){
	//循环找到最右下节点（一定要是叶子结点），因为根左右，此时只是最右下但是有左孩子则并不满足条件（根左），需要找到左子树的最后一个右叶子结点。
	//此时已经是最后一个叶子节点，即先序遍历的最后一个节点
	if(p->ltag&&p->rtag)  return p;
	//此节点还有右子树
	if(p->rtag==0) return LastNode(p->right);
	//此根节点（即最右的非叶子节点）还有左子树
	if(p->ltag==0) return LastNode(p->left); 
}
//寻找节点p的前驱节点
ThreadNode* PreNode(ThreadTree* p){
	//若节点p的左子树有孩子，则无法找到直接后续
	if(p->ltag==0){//满足右左根
		ThreadTree* par = p->parent;//父节点
		if(par){//能找到父节点
			//若p是左孩子或者p是右孩子且父节点左孩子为空，则父节点为其前驱
			if(par->left==p||par->ltag) rerurn par;
			//p不为左孩子且左孩子非空
			return par->left;
		}
		//找不到父节点，说明已遍历到根节点，p没有前驱
		return NULL;
	}
	//ltag==1直接得到前驱
	return p->left;
}
//通过找先序前驱实现逆先序遍历
void RevPreOrder(ThreadTree* root){
	for(ThreadTree* p = LastNode(root);p!=NULL;p = PreNode(p)){
		visit(p);
	}
}

③后序线索二叉树遍历

图解：
在这里插入图片描述
在这里插入图片描述
代码：

typedef struct ThreadTree{
	DataType val;
	struct ThreadTree* left;
	struct ThreadTree* right;
	struct ThreadTree* parent;
	int ltag,rtag;
}ThreadTree;

//后序线索二叉树找后序后续
//相当于非递归实现后序遍历
//首先找到以p为根的子树中第一个被后序遍历的节点
ThreadTree* FirstNode(ThreadTree* p){
	//循环找到最左下节点，即后序遍历的首节点
	while(p->ltag==0) p = p->left;
	return p;
}
//寻找节点p的后续节点
ThreadNode* NextNode(ThreadTree* p){//左右根
	//若节点p的右子树有孩子，则无法找到直接后续
	if(p->rtag==0){
		//后序遍历中左右子树节点只可能是根的前驱，不可能是后续
		ThreadTree par = p->parent;//找p的父节点
		if(par){//p的父节点不为空
			//如果p是左孩子且右兄弟为空||p是右孩子，则父节点即为后续
			if((par->left==p&&par->rtag)||par->right==p) return par;
			//如果p是左孩子且右兄弟非空，则后续为右兄弟子树后序遍历的第一个节点
			return FirstNode(par->right);
		}
		//par为空说明p为根节点，p无后续
		return NULL;
	}
	//rtag==1直接得到后续
	return p->right;
}
//通过找先序后续实现先序遍历（利用线索实现非递归先序遍历）
void PostOrder(ThreadTree* root){
	for(ThreadTree* p = FirstNode(p);p!=NULL;p = NextNode(p)){
		visit(p);
	}
}


//后序线索二叉树找后序前驱
//相当于非递归实现逆后序遍历
//首先找到以p为根的子树中最后一个被后序遍历的节点，即根节点
//寻找节点p的前驱节点
ThreadNode* PreNode(ThreadTree* p){
	//若节点p的左子树有孩子，则无法找到直接前驱
	if(p->ltag==0){
		//如果p有右孩子，则前驱为p->right
		if(!p->rtag) return p->right;
		//若p无右孩子则前驱为其左孩子
		rerturn p-left;//此步可省略
	}
	//ltag==1直接得到前驱
	return p->left;
}
//通过找后序前驱实现逆后序遍历
void RevPostOrder(ThreadTree* root){
	for(ThreadTree* p = root;p!=NULL;p = PreNode(p)){
		visit(p);
	}
}

下面这些题值得一看，测试自己，知识点可融会贯通

3.关于二叉树的遍历的练习题

  1. 清华大学上机复试二叉树遍历
  2. 根据先序和中序遍历输出后序遍历
  3. 根据后序和中序遍历输出先序遍历
  4. 根据后序和中序遍历输出层序遍历
  5. 二叉树的三种遍历（递归、非递归）

4.二叉树的一些拓展练习题

  1. 二叉树的最大深度
  2. 二叉树的叶子结点个数
  3. 列出叶节点
  4. 二叉树中和为目标值的路径
  5. 翻转二叉树

5.并查集

在这里插入图片描述在这里插入图片描述

const int  N=1005					//指定并查集所能包含元素的个数
int pre[N];     					//存储每个结点的前驱结点，即父节点 
int rank[N];    					//树的高度 

//双亲表示法
//初始化函数，对n个结点进行初始化 
void init(int n)     				
{
    for(int i = 0; i < n; i++){
        pre[i] = i;     			//每个结点的父节点都是自己 
        rank[i] = 1;    			//每个结点构成的树的高度为 1 
    } 
}

 //查找结点x的根结点，即代表元
int find(int x)     	 		   
{
    if(pre[x] == x) return x;  		//递归出口：x的父节点为 x本身，则x为根结点 
    return find(pre[x]); 			//递归查找 
} 
 //改进查找算法：完成路径压缩，将x的前驱直接变为根结点
 //先找到根节点，再将此路径上所有节点前驱都改为根节点
int find(int x)     				
{
    if(pre[x] == x) return x;		//递归出口：x的父节点为 x本身，即x为根结点 
    return pre[x] = find(pre[x]);   //此代码相当于先找到根结点 rootx，然后 pre[x]=rootx 
} 

//判断两个结点是否连通 
bool isSame(int x, int y)      		
{
	//判断两个结点的根结点（即代表元）是否相同 
    return find(x) == find(y);  	
}

//合并算法
void join(){
	x = find(x);						//寻找 x的代表元
    y = find(y);						//寻找 y的代表元
    if(x == y) return ;			//如果 x和 y的代表元一致，说明他们共属同一集合，则不需要合并，返回，表示合并失败；否则，执行下面的逻辑
    pre[x] = y;							//让x的根为y
}


/*
改进合并算法(加权标记法)
rank记录树高，小树合并到大树
加权标记法的核心在于对rank数组的逻辑控制，其主要的情况有：
	1、如果rank[x] < rank[y]，则令pre[x] = y；
	2、如果rank[x] == rank[y]，则可任意指定上级；
	3、如果rank[x] > rank[y]，则令pre[y] = x；
*/
void join(int x,int y)
{
    x = find(x);						//寻找 x的代表元
    y = find(y);						//寻找 y的代表元
    if(x == y) return ;			//如果 x和 y的代表元一致，说明他们共属同一集合，则不需要合并，返回，表示合并失败；否则，执行下面的逻辑
    if(rank[x] > rank[y]) pre[y]=x;		//如果 x的高度大于 y，则令 y的根为 x
    else								//否则
    {
        if(rank[x]==rank[y]) rank[y]++;	//如果 x的高度和 y的高度相同，则令 y的高度加1
        pre[x]=y;						//让x的根为y
	}
}
天皓Oo
关注
  • 8
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的线索化以及遍历（前序、中序、后序）
scmuzi18的博客
02-20 394
#define _CRT_SECURE_NO_WARNINGS #include using namespace std; #include #include enum ThdInfo { LINK, THREAD }; template struct BinaryTreeThdNode { BinaryTreeThdNode(const T& data) : pl
二叉树线索化以及线索化前序、中序、后序遍历
honeyJ
12-05 1556
二叉树线索化以及线索化前序、中序、后序遍历 前面已经对二叉树的创建与建立有了一定了解，那二叉树的线索化又是什么呢？ 二叉树虽然是非线性结构，但二叉树的遍历却为二叉树的节点导出了一个线性序列。 用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。 为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节
二叉树的前序中序后序遍历代码
01-03
用C语言实现数据结构中二叉树的前序中序后序遍历 int main()//主函数部分 { BiTree T=NULL; int Layer=0; int LayerT=0; printf("请输入二叉树：\n"); CreatBiTree(&T);printf("你输入的二叉树为：(竖型树状表示)\n"); PrintBinary(T,Layer); printf("\n"); printf("先序遍历二叉树为：\n"); PreOrderTraverse(T); printf("\n"); printf("中序遍历二叉树为：\n"); InOrderTraverse(T); printf("\n"); printf("后序遍历二叉树为：\n"); PostOrderTraverse(T); printf("\n"); printf("二叉树转换为树显示出来为：(竖型树状表示)\n"); PrintTree(T,LayerT); system("pause"); return 0; }
二叉树的前序遍历，中序遍历，后序遍历代码
cfylove的专栏
05-30 825
前序遍历/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class Solution
C++ 二叉树前序、中序、后序遍历代码模板（迭代实现）
qq_24447809的博客
11-26 539
前序遍历 利用栈的后进先出性质 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { stack<TreeNode*> st; vector<int> result; if (root == NULL) return result; st.push(root); while (!st.empty
C++ 二叉树的先序，中序，后序遍历
diyang6487的专栏
03-21 1143
三种遍历方式都分为递归与非递归的方式。三种遍历方式的递归思想相同。后序遍历非递归方法分为两种，具体见代码。 构造方式： 1 #include<iostream> 2 #include<stack> 3 using namespace std; 4 5 typedef struct BiTNode{ 6 char...
二叉树2_先序线索化及遍历
心若有所栖，何似风飘缈。
08-02 260
流程图+代码:代码来源于网络. version_190804
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
二叉树的遍历有三种基本方式：先序遍历（根-左-右）、中序遍历（左-根-右）和后序遍历（左-右-根）。在这里，我们关注的是后序遍历。后序遍历非递归算法的实现相对复杂，需要利用栈的操作来实现。 4. 结构体的定义...
先序中序后序遍历二叉树的递归算法C语言,编写一个程序，实现二叉树的先序遍历，中序遍历，后序遍历的各种递归和非递归算法，以及层次遍历的算法...
weixin_39792803的博客
05-24 3172
满意答案文件 main.cpp 代码如下：#include // malloc()等#include // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等#include // atoi()，exit()#include // 数学函数头文件，包括floor()，ceil()，abs()等#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的...
二叉树先序中序后序三种遍历的非递归算法.doc
05-06
二叉树先序、中序、后序三种遍历的非递归算法 二叉树遍历是数据结构中的一种基础算法，以树状结构为基础，通过对树的遍历来实现数据的访问和处理。常见的二叉树遍历算法有三种：先序遍历、中序遍历和后序遍历。这些...
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
上述代码中的三个函数都是基于栈实现的非递归遍历，它们能够有效地处理任意大小的二叉树，而不会受到递归深度限制的影响。 在实际应用中，二叉树遍历可以用来进行多种操作，如查找、复制、排序等。比如，在编译器中...
二叉树的遍历——前序、中序，后序，层次遍历以及相关题解
Concise200的博客
11-28 2744
二叉树的遍历结点类型1. 前序遍历（preorder traversal）2. 中序遍历（inorder traversal）3. 后序遍历（postorder traversal）4. 三者区别5. 根据前序遍历中序遍历重构二叉树4.1 解法一算法思想代码时间复杂度分析4.2 解法二代码 结点类型 struct TreeNode { int val; TreeNode *left; //左子 TreeNode *right; //右孩子 TreeNode(int x) : val(x), le
二叉树的遍历（前序，中序，后序，层序）--递归和非递归算法实现
wei.zhou的专栏
05-05 1322
二叉树的每个结点最多有两个子树（即不存在度大于2的结点），二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。 二叉树的链式存储结构是一类重要的数据结构，其形式定义
Java：树的前序、中序、后序遍历代码实现--二叉树递归法
qq_46119575的博客
04-14 380
树的前序、中序、后序遍历是常见的树检索方式，本文分享了Java实现树的前序、中序、后序遍历的代码，希望对大家有用！ 先序（深度搜索遍历DFS）：先顶点，再左边节点，接着右边节点。中序：先左边节点，再顶点，最后右边节点。后序：先左边节点，然后右边节点，最后为顶点。
线索化二叉树（先序，中序，后序）+线索化二叉树的遍历【java详解】
2302_79862386的博客
02-17 2029
n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种一个结点的前一个结点，称为前驱结点一个结点的后一个结点，称为后继结点//线索化时记录前一个节点//节点存储结构。
[算法] 二叉树的 先序遍历、中序遍历、后序遍历
scxyz的博客
02-27 3万+
本文根据清华大学邓俊辉老师课程《数据结构》总结，课程地址 。 遍历介绍 按照事先约定的某种规则或次序，对节点各访问一次而且仅一次。与向量和列表等线性结构一样，二叉树的这类访问也统称为遍历（traversal）。 二叉树本身并不具有天然的全局次序， 故为实现遍历，需通过在各节点与其孩子之间约定某种局部次序， 间接地定义某种全局次序。 按惯例左兄弟优先于右兄弟， 若记做节点 V ，...
【代码随想录】——“二叉树的递归遍历”
m0_51660741的博客
06-07 150
每次写递归，都按照这三要素来写确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。 144. 二叉树
G722.1.C简单介绍
最新发布
lijian2017的博客
08-29 831
这些编码参数决定了编码后的数据量和音质水平，低码率适用于带宽有限的环境，而高码率则能提供更高的音质。：G722.1.C采用变换域编码方法（如MLT，即Modulated Lapped Transform），这种方法通过将音频信号从时域转换到变换域（如频域），利用音频信号在变换域中的稀疏性进行压缩，从而实现高效的编码。（注意，通常不直接提及G722.1.C，因为G722.1本身就是一个标准的音频编码算法，G722.1.C并不是一个广泛认知的标准名称，可能是对G722.1的某种变体的特定引用）
二叉树的递归先序中序后序遍历以及非递归层次遍历
04-04
4. 二叉树的非递归层次遍历： 使用一个队列来存储每一层的节点，先将根节点入队，然后遍历队列中的元素，将每个元素的左右子节点入队，直到队列为空。 代码实现： ``` void levelOrder(TreeNode* root) { if ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值