中序遍历——非递归算法

已于 2022-05-25 15:27:06 修改
阅读量3.5k 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： c语言 c++ 经历 文章标签： 链表 c++ 数据结构 算法
于 2021-03-16 21:34:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51543618/article/details/114870530

中序遍历

  • 先走到的后访问，后走到的先访问，采用栈结构。

步骤：

  • 1.如果节点有左子树，该节点入栈，否则访问该节点。
  • 2.如果节点有右子树，重复步骤1。
  • 3.如果节点没有右子树，访问完毕，根据栈顶指示退回，访问栈顶元素，并访问右子树，重复步骤1。
  • 4.如果栈为空，遍历结束。

例子（c++版）：

#include<iostream>
#include<stack>

using namespace std;

typedef struct Binary_tree
{
	int user_data;
	Binary_tree* left;
	Binary_tree* right;
}binary_tree;

binary_tree*left_push_cpp(binary_tree*b1, stack<binary_tree*> &s)
{
	binary_tree*temp_push = b1;
	if (temp_push == nullptr)
	{
		printf("树为空！！！\n\n");
		return nullptr;
	}
	s.push(temp_push);
	while (temp_push->left != nullptr)
	{
		s.push(temp_push->left);
		temp_push = temp_push->left;
	}
	return temp_push;
}

void show_stack(binary_tree*b1)
{
	stack<binary_tree*>s;
	binary_tree*temp_show = left_push_cpp(b1,s);
	s.pop();
	while (temp_show)
	{
		printf("%d\n\n",temp_show->user_data);
		if (temp_show->right)
		{
			printf("左子树有值！！！\n\n");
			temp_show = left_push_cpp(temp_show->right,s);
			s.pop();
		}
		else if(s.size()>0)
		{
			temp_show = s.top();
			s.pop();
		}
		else
		{
			break;
		}
	}
}
int main()
{
	binary_tree* b1 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b2 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b3 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b4 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b5 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b6 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b7 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b8 = (binary_tree*)malloc(sizeof(binary_tree));

	int u1 = 1111;
	b1->user_data = u1;
	int u2 = 2222;
	b2->user_data = u2;
	int u3 = 3333;
	b3->user_data = u3;
	int u4 = 4444;
	b4->user_data = u4;
	int u5 = 5555;
	b5->user_data = u5;
	int u6 = 6666;
	b6->user_data = u6;
	int u7 = 7777;
	b7->user_data = u7;
	int u8 = 8888;
	b8->user_data = u8;

	b1->left = b2;
	b1->right = b3;
	b2->left = b4;
	b2->right = b5;
	b3->left = b6;
	b3->right = b7;
	b4->left = b8;
	b4->right = nullptr;
	b5->left = nullptr;
	b5->right = nullptr;
	b6->left = nullptr;
	b6->right = nullptr;
	b7->left = nullptr;
	b7->right = nullptr;
	b8->left = nullptr;
	b8->right = nullptr;

	show_stack(b1);
	return 0;
}

例子（c语言版）：

  • 先利用c语言建立栈空间
  • 再创建中序遍历的函数：
#include<stdio.h>
#include<algorithm>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<windows.h>

typedef struct Binary_tree
{
	int user_data;
	Binary_tree* left;
	Binary_tree* right;
}binary_tree;

void show_tree_recursion(binary_tree*b1)
{
	if (b1 == nullptr)
	{
		printf("本分支结束！！！\n\n");
		return;
	}
	printf("root_data = %d\n\n",b1->user_data);
	show_tree_recursion(b1->left);
	show_tree_recursion(b1->right);
}

int deep(binary_tree*b1)
{
	int left = 0;
	int right = 0;
	int root = 0;

	if (b1 == nullptr)
	{
		return 0;
	}
	left = deep(b1->left);
	right = deep(b1->right);

	root = 1 + (left > right ? left : right);
	return root;
}

void count_leaf(binary_tree*b1, int*sum)
{
	if (b1->left == nullptr && b1->right == nullptr)
	{
		(*sum)++;
		printf("找到叶子节点啦！！！sum = %d\n\n",*sum);
	}

	if (b1->left)
	{
		printf("这不是叶子节点，继续寻找！！！\n\n");
		count_leaf(b1->left,sum);
	}
	if (b1->right)
	{
		printf("这不是叶子节点，继续寻找！！！\n\n");
		count_leaf(b1->right, sum);
	}
}

typedef struct Node
{
	//定义连接链表的节点：
	Node* next;
}node;

typedef struct Common_list
{
	//定义一个空间域
	node head;
	int length;
}common_list;


//1. 建立空链表：
common_list* creat_list()
{
	common_list*temp_creat;
	temp_creat = (common_list*)malloc(sizeof(common_list));
	if (temp_creat == nullptr)
	{
		printf("空间开辟错误！！！\n");
		return nullptr;
	}
	printf("已成功创建空列表！！1\n");
	temp_creat->head.next = nullptr;
	temp_creat->length = 0;
	printf("空列表初始化成功！！1\n");
	return temp_creat;
}

//2. 开始在old中的pos位置处插入元素input：
void insert_list(common_list**old, node*input, int pos)
{
	common_list*temp_insert = *old;
	if (temp_insert == nullptr)
	{
		printf("传入空间错误！！！\n\n");
		return;
	}
	else if (pos < 0)
	{
		printf("位置号不能小于0");
		return;
	}

	else if (pos > temp_insert->length)
	{
		pos = temp_insert->length;
	}
	//定义一个辅助指针：
	node*current = &temp_insert->head;
	for (int i = 0; i < pos; i++)
	{
		//开始移动到插入的位置：
		current = current->next;
	}
	//进行插入操作：
	input->next = current->next;
	current->next = input;
	temp_insert->length++;
	printf("号码插入成功！！！\n\n");
}

//查找pos处的元素：
node* find_list(common_list*old, int pos)
{
	common_list*temp_find = old;
	if (temp_find == nullptr)
	{
		printf("传入空间错误！！！\n\n");
		return nullptr;
	}
	else if (pos < 0 || pos >= temp_find->length)
	{
		printf("该位置处无号码！！！\n\n");
		return nullptr;
	}

	//定义一个辅助指针便于寻找：
	node* current = temp_find->head.next;
	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}
	printf("找到号码啦！！！\n\n");
	return current;
}

//定义删除函数：
node* delete_list(common_list**old, int pos)
{
	common_list*temp_del = *old;
	if (temp_del == nullptr)
	{
		printf("传入空间错误！！！\n\n");
		return NULL;
	}
	else if (pos < 0 || pos >= temp_del->length)
	{
		printf("该位置处无号码！！！\n\n");
		return NULL;
	}

	//定义一个辅助指针定位当前位置：
	node* current = &temp_del->head;
	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}
	//定义一个辅助指针用于缓存要删除的节点：
	node*del = current->next;
	current->next = del->next;
	temp_del->length--;
	printf("数据删除成功！！！\n\n");
	return del;
}

void clear_list(common_list**old)
{
	common_list* temp_cls = *old;
	if (temp_cls == nullptr)
	{
		printf("传入空间错误！！！\n\n");
		return;
	}
	free(temp_cls);
	temp_cls = nullptr;
	printf("数据已经清空！！！\n\n");
}

int length_list(common_list*old)
{
	return old->length;
}

typedef struct Node_stack
{
	node head;
	void* user_data;
}node_stack;

common_list* creat_stack()
{
	common_list*old_stack = creat_list();
	if (old_stack == nullptr)
	{
		printf("栈为空！！！已退出！！！\n\n");
		return nullptr;
	}
	return old_stack;
}

void push_stack(common_list** old_stack, void* user_data)
{
	if (old_stack == nullptr || user_data == nullptr)
	{
		printf("栈为空！！！或用户数据为空！！！已退出！！！\n\n");
		return;
	}
	common_list*temp_old = *old_stack;
	node_stack* user_temp = (node_stack*)malloc(sizeof(node_stack));
	user_temp->user_data = user_data;

	insert_list(&temp_old, (node*)user_temp, 0);

	printf("用户数据插入成功！！！\n\n");
}

void* get_top(common_list*old_stack)
{
	if (old_stack == nullptr)
	{
		printf("栈为空！！！已退出！！！\n\n");
		return nullptr;
	}
	node_stack*temp_get = (node_stack*)find_list(old_stack, 0);
	if (temp_get == nullptr)
	{
		printf("用户数据已删除完成！！！\n\n");
		return nullptr;
	}
	return temp_get->user_data;
}

void pop_stack(common_list**old_stack)
{
	if (old_stack == nullptr)
	{
		printf("栈为空！！！已退出！！！\n\n");
		return;
	}
	common_list*temp_del = *old_stack;
	node_stack*buf_del = (node_stack*)delete_list(&temp_del, 0);
	free(buf_del);
	buf_del = nullptr;
	printf("用户数据删除成功！！！\n\n");
}

int length_stack(common_list*old_stack)
{
	if (old_stack == nullptr)
	{
		printf("栈为空！！！已退出！！！\n\n");
		return -1;
	}
	int temp_len_stack = length_list(old_stack);
	return temp_len_stack;
}

void cls_stack(common_list**old_stack)
{
	if (old_stack == nullptr)
	{
		printf("栈为空！！！已退出！！！\n\n");
		return;
	}
	common_list*temp_cls = *old_stack;

	while (length_stack(temp_cls) > 0)
	{
		pop_stack(&temp_cls);
		printf("栈中有元素，开始删除！！！\n\n剩余栈的长度是：【%d】\n\n", length_stack(temp_cls));
		Sleep(800);
	}
	printf("元素删除完成，栈为空！！！\n\n");
}

//返回开始遍历的元素：
binary_tree* left_push(binary_tree*b1, common_list**stack)
{
	binary_tree*temp_node = b1;
	common_list*temp_stack = *stack;
	push_stack(&temp_stack, temp_node);
	if (temp_node == nullptr)
	{
		printf("树为空！！！\n\n");
		return nullptr;
	}
	while (temp_node->left !=nullptr)
	{
		push_stack(&temp_stack, temp_node->left);
		temp_node = temp_node->left;
	}
	return temp_node;
}

//遍历树的函数：
void show_tree_user(binary_tree*b1)
{
	if (b1 == nullptr)
	{
		printf("树为空！！！\n\n");
		return;
	}
	common_list*stack = creat_stack();
	binary_tree*temp_show = left_push(b1, &stack);
	pop_stack(&stack);
	while (temp_show)
	{
		printf("%d\n\n", temp_show->user_data);
		if (temp_show->right)
		{
			printf("此节点还有右子树！！！\n\n");
			temp_show = left_push(temp_show->right,&stack);
			pop_stack(&stack);
		}
		else if (length_stack(stack)>0)
		{
			temp_show = (binary_tree*)get_top(stack);
			pop_stack(&stack);
		}
		else
		{
			temp_show = nullptr;
		}
	}
}


int main()
{
	//建立二叉树：
	binary_tree* b1 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b2 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b3 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b4 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b5 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b6 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b7 = (binary_tree*)malloc(sizeof(binary_tree));
	binary_tree* b8 = (binary_tree*)malloc(sizeof(binary_tree));

	int u1 = 1111;
	b1->user_data = u1;
	int u2 = 2222;
	b2->user_data =u2;
	int u3 = 3333;
	b3->user_data = u3;
	int u4 = 4444;
	b4->user_data = u4;
	int u5 = 5555;
	b5->user_data =u5;
	int u6 = 6666;
	b6->user_data =u6;
	int u7 = 7777;
	b7->user_data =u7;
	int u8 = 8888;
	b8->user_data = u8;

	b1->left = b2;
	b1->right = b3;
	b2->left = b4;
	b2->right = b5;
	b3->left = b6;
	b3->right = b7;
	b4->left = b8;
	b4->right = nullptr;
	b5->left = nullptr;
	b5->right = nullptr;
	b6->left = nullptr;
	b6->right = nullptr;
	b7->left = nullptr;
	b7->right = nullptr;
	b8->left = nullptr;
	b8->right = nullptr;

	show_tree_user(b1);

	return 0;
}
C语言经典算法之二叉树的中序遍历（非递归实现）
weixin_56154577的博客
02-01 2690
在C语言中，二叉树的中序遍历（Inorder Traversal）非递归实现通常使用栈（stack）来辅助遍历过程。
二叉树中序遍历（递归法和迭代法(非递归法)）——C++
净无邪博客
12-04 2040
1.2迭代法 迭代法是采用非递归方法实现二叉树的中序遍历，主要利用数据结构std::stack来实现，利用栈std::stack的先进后出特性依次压入待访问的节点，然后依次按照中序遍历顺序弹出和访问节点，确保每个节点有且仅有一次访问。 具体步骤如下： a1 先将所有父节点和左子节点依次压入栈； 这样做的目的是为了先弹出左子节点，再弹出父节点，可以在弹出左子节点的时候进行遍历，同时处理右节点，比如将右节点压入栈，这样就实现了先访问左节点，然后父节点，最后右子节点。a2 然后弹出一个节点，进行遍历； 此时弹出a
【数据结构】中序遍历非递归算法
jianbiao1483的博客
08-13 8468
3）根结点出栈，输出根结点，遍历右子树。（2）根结点进栈，遍历左子树。
二叉树的非递归遍历
最新发布
2501_91490760的博客
05-21 363
递归就是不断的调用方法，方法参数在改变，我们当然也可以让循环调用方法，并且在循环中改变方法的参数，下面的算法里这个参数就是curr或node。非递归遍历使用显式栈模拟递归过程，栈的调用是通过代码直接调用，不仅更安全，还能让我们更深入理解遍历的本质。需要注意的是，null节点有两种，一类是在程序运行时添加的，还有就是叶子节点的左右节点，它们都是符合条件的。三种遍历方式有个共同点，那就是记录过的数据要从栈中弹出，这样就保证了弹出的数据有且仅有一次记录，从而当迭代结束，即栈为空时所有元素都被记录了一次。
中序遍历非递归算法
行走巨人国
05-15 1万+
中序遍历： 方法一： //中序遍历 void InOrderWithoutRecursion1(BTNode* root) { //空树 if (root == NULL) return; //树非空 BTNode* p = root; stack<btnode*> s; while (!s.empty() || p...
中序遍历的非递归算法
热门推荐
lyy的博客
10-08 2万+
话不多说直接上代码: Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)){ InitStack(S);Push(S,T);//根指针进栈 while(!StackEmpty(S)){ while(GetTop(S,p)&amp;&amp;p) Push(S,p-&gt;lchild);//...
非递归中序遍历
tannanxi的博客
04-21 4760
非递归中序遍历 中序遍历的顺序为：左-中-右，通过栈这个数据结构来记录遍历的历史，每个节点按照右-中-左的顺序压栈，整棵树按照右子树-根-左子树的顺序压栈。最后全部pop出来。代码如下： 递归实现： void middleOrder(Node* node) { if (node == nullptr) { return; } middleOrder(nod...
二叉树的三种遍历（先序中序后序）——递归非递归算法
筱羊冰冰
08-02 1185
回忆 在上一个关于树的博客提到了二叉树的三种遍历方式，还有一个单独的层次遍历。 先序、中序、后序本质山就是根、左、右的顺序问题 先序：根左右 中序：左根右 后序：左右根 递归算法 因为二叉树的定义（其实应该说树的定义）里面有递归的影子：每一个子树也要符合上述条件 （具体参见上一篇博客） 所以递归算法应该是最先想到的，而且因为递归的性质，函数形式也是最简单的。 先序： 在这里插入代码片 中序： ...
实用《数据结构》编程——二叉树的建立、中序遍历非递归C程序.pdf
08-07
- **中序非递归遍历算法**: 中序遍历的非递归算法通常使用栈来实现。算法的基本思想是从根节点开始，沿着最左侧的路径一直走到最左侧的节点，并将途中经过的节点入栈；当到达最左节点后，依次出栈并访问节点，然后...
二叉树遍历——递归与非递归实现
jjy223404的博客
04-27 965
二叉树遍历——递归与非递归实现描述分析递归版本的二叉树遍历设计代码非递归版本的二叉树遍历非递归先序遍历设计步骤代码非递归后序遍历设计步骤代码非递归中序遍历设计步骤代码非递归遍历二叉树完整代码及测试 描述 实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式。 分析 使用递归实现二叉树遍历十分容易。在递归过程中，系统自动帮你压栈从而回溯时，关键信息不会被丢失。而非递归实现二叉树遍历时，无法再依...
二叉树遍历的非递归算法（过程分析+算法设计思路）
weixin_44788162的博客
02-11 1089
二叉树 1.树概念及结构 2.二叉树概念及结构 3.二叉树顺序结构及实现 4.二叉树链式结构及实现
二叉树的中序遍历非递归算法
03-04
利用栈的基本操作实现二叉树的中序遍历非递归算法。
C语言实现二叉树的中序遍历（非递归）
12-13
C语言实现二叉树的中序遍历（非递归），本人亲自写的！
非递归中序遍历二叉树
10-22
非递归中序遍历二叉树
二叉树
ouyang______的专栏
03-20 585
                                              二叉树的遍历 1、递归实现二叉树的建立和递归实现遍历 //算法5.1 中序遍历的递归算法 #include&lt;iostream&gt; using namespace std; typedef struct BiNode{ //二叉链表定义 char data; struct...
中序遍历（非递归）
北街lhy的博客
03-25 3064
试写出中序遍历的非递归算法 分析： 如果采用非递归，我们就需要用到栈这个数据结构了，具体流程为：从根节点一路往下找左孩子并将其入栈直至左孩子为空 然后依次出栈，并判断是否存在右孩子，如果有，右孩子入栈，继续往下找左孩子，如此重复直至栈空。 本题代码如下： struct biTree {//树的结构体 char data; struct biTree *lchild; struct biTree *rchild; }; struct Stack {...
二叉树的中序遍历(非递归实现)
dai_wen的博客
01-04 2万+
一、递归实现前序，序，后序遍历；对于二叉树，前面已经采用递归的方式实现的其前序，中序，后序遍历，具体请参见：http://blog.csdn.net/dai_wen/article/details/78955411那么，如何采用非递归的方式遍历树呢？下面，以实现中序遍历二叉树为主题展开：二、非递归实现 中序遍历：1，结构： 首先，对于中序遍历，我们知道，原则是先走到的结点后访问，后走到的结点
非递归实现中序遍历
linminx的博客
04-03 3411
非递归实现中序遍历
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值