二叉樹遍歷遞歸和非遞歸實現

遍歷一共有三種，前序中序後序，下面直接上代碼吧，外加運行結果：

#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