二叉树遍历递归和非递归实现

最新推荐文章于 2022-12-09 18:31:27 发布

qilimi-1

最新推荐文章于 2022-12-09 18:31:27 发布

阅读量113

点赞数

分类专栏：基础算法 C++ 程序基础文章标签： C++ 二叉树遍历递归非递归

本文链接：https://blog.csdn.net/qilimi1053620912/article/details/103190262

版权

C++ 同时被 3 个专栏收录

20 篇文章 1 订阅

订阅专栏

基础算法

16 篇文章 0 订阅

订阅专栏

程序基础

9 篇文章 0 订阅

订阅专栏

遍历一共有三种，前序中序后序，下面直接上代码吧，外加运行结果：

#include <stdio.h>
#include <stdlib.h>

#include <stack>
#include <queue>
#include <iostream>

using namespace std;


// 定义一个树节点
typedef struct tag_tree_node {
	int data;
	tag_tree_node* left_node;
	tag_tree_node* right_node;
}tree_node, *tree_node_p;


/*
 * 创建一个二叉树节点
*/
tree_node_p create_tree_node(int data = 0) {
	tree_node_p p = (tree_node_p)malloc(sizeof(tree_node));
	p->data = data;
	p->left_node = NULL;
	p->right_node = NULL;
	return p;
}

/*
 * 删除一个二叉树节点
*/
void delete_tree_node(tree_node_p *val) {
	tree_node_p p = *val;
	free(p);
	p = NULL;
}
/*
 * 删除一个二叉树节点
*/
void delete_tree_node_recursion(tree_node_p *val) {
	tree_node_p p = *val;
	if (p != NULL) {
		delete_tree_node_recursion(&p->left_node);
		delete_tree_node_recursion(&p->right_node);
		free(p);
		p = NULL;
	}
}
/*
 * 打印一个二叉树数据
*/
void print_tree_node(tree_node_p val) {
	printf(" %d ", val->data);
}

/*
 * 创建一个用于测试的二叉树
*/
tree_node_p create_test_tree() {
	int index = 1;
	// 首节点
	tree_node_p head = create_tree_node(index++);
	head->left_node = create_tree_node(index++);
	head->right_node = create_tree_node(index++);
	// 首节点的左节点
	tree_node_p tmp = head->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点
	tmp = head->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);

	// 首节点的左节点左节点
	tmp = head->left_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的左节点右节点
	tmp = head->left_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点左节点
	tmp = head->right_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点右节点
	tmp = head->right_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);

	// 首节点的左节点左节点左节点
	tmp = head->left_node->left_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的左节点左节点右节点
	tmp = head->left_node->left_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的左节点右节点左节点
	tmp = head->left_node->right_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的左节点右节点右节点
	tmp = head->left_node->right_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);

	// 首节点的右节点左节点左节点
	tmp = head->right_node->left_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点左节点右节点
	tmp = head->right_node->left_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点右节点左节点
	tmp = head->right_node->right_node->left_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);
	// 首节点的右节点右节点右节点
	tmp = head->right_node->right_node->right_node;
	tmp->left_node = create_tree_node(index++);
	tmp->right_node = create_tree_node(index++);

	tmp = NULL;
	return head;
}

// 前序遍历，递归
void preorder_recursion(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	print_tree_node(val);
	preorder_recursion(val->left_node);
	preorder_recursion(val->right_node);
}
// 中序序遍历，递归
void infixorder_recursion(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	infixorder_recursion(val->left_node);
	print_tree_node(val);
	infixorder_recursion(val->right_node);
}
// 后序遍历，递归
void postorder_recursion(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	postorder_recursion(val->left_node);
	postorder_recursion(val->right_node);
	print_tree_node(val);
}

/// 下面采用非递归算法，这个时候如果要使用非递归的话，我们要需要使用到栈
// 前序遍历
void preorder(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	stack<tree_node_p> storage_stack;
	storage_stack.push(val);

	while (!storage_stack.empty()) {
		tree_node_p p = storage_stack.top();
		storage_stack.pop();
		print_tree_node(p);
		if (p->right_node != NULL) {
			storage_stack.push(p->right_node);
		}
		if (p->left_node != NULL) {
			storage_stack.push(p->left_node);
		}
	}
}
// 中序序遍历
void infixorder(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	stack<tree_node_p> storage_stack;
	tree_node_p tmp = val;

	while (!storage_stack.empty() || tmp != NULL) {
		while (tmp != NULL) {
			storage_stack.push(tmp);
			tmp = tmp->left_node;
		}
		if (!storage_stack.empty()) {
			tree_node_p p = storage_stack.top();
			storage_stack.pop();
			print_tree_node(p);
			tmp = p->right_node;
		}
	}
}
// 后序遍历
void postorder(tree_node_p val) {
	if (val == NULL) {
		return;
	}
	stack<tree_node_p> storage_stack1;
	stack<tree_node_p> storage_stack2;
	storage_stack1.push(val);
	tree_node_p tmp = NULL;

	while (!storage_stack1.empty()) {
		tmp = storage_stack1.top();
		storage_stack1.pop();
		if (tmp->left_node != NULL) {
			storage_stack1.push(tmp->left_node);
		}
		if (tmp->right_node != NULL) {
			storage_stack1.push(tmp->right_node);
		}
		storage_stack2.push(tmp);
	}

	while (!storage_stack2.empty()) {
		print_tree_node(storage_stack2.top());
		storage_stack2.pop();
	}

}

int main() {
	tree_node_p head = create_test_tree();
	printf("---------------------------- \r\n");
	preorder_recursion(head);
	printf("\r\n");
	preorder(head);
	printf("\r\n");
	infixorder_recursion(head);
	printf("\r\n");
	infixorder(head);
	printf("\r\n");
	postorder_recursion(head);
	printf("\r\n");
	postorder(head);

	delete_tree_node_recursion(&head);

	getchar();
	return 0;
}

结果:

----------------------------
 1  2  4  8  16  17  9  18  19  5  10  20  21  11  22  23  3  6  12  24  25  13  26  27  7  14  28  29  15  30  31
 1  2  4  8  16  17  9  18  19  5  10  20  21  11  22  23  3  6  12  24  25  13  26  27  7  14  28  29  15  30  31
 16  8  17  4  18  9  19  2  20  10  21  5  22  11  23  1  24  12  25  6  26  13  27  3  28  14  29  7  30  15  31
 16  8  17  4  18  9  19  2  20  10  21  5  22  11  23  1  24  12  25  6  26  13  27  3  28  14  29  7  30  15  31
 16  17  8  18  19  9  4  20  21  10  22  23  11  5  2  24  25  12  26  27  13  6  28  29  14  30  31  15  7  3  1
 16  17  8  18  19  9  4  20  21  10  22  23  11  5  2  24  25  12  26  27  13  6  28  29  14  30  31  15  7  3  1