8 二叉树的下一个节点

·理解关键：先序遍历的意思是先遍历左子树，等到左子树全部遍历完之后才遍历自己，然后是右子树。

#include <iostream>
using namespace std;

struct BinaryTreeNode {
	int m_nValue;
	BinaryTreeNode* m_pLeft;
	BinaryTreeNode* m_pRight;
	BinaryTreeNode* m_pParent;
};



/*********************************
*	可视化树结构
**********************************/
void padding(char ch, int n)
{
	int i;

	for (i = 0; i < n; i++)
		putchar(ch);
}

void print_node(struct BinaryTreeNode *root, int level)
{

	if (root == NULL)
	{
		padding('\t', level);
		puts("NIL");

	}
	else
	{
		print_node(root->m_pRight, level + 1);
		padding('\t', level);
		printf("%d\n", root->m_nValue);
		print_node(root->m_pLeft, level + 1);
	}
}

void print_tree(struct BinaryTreeNode* root)
{
	print_node(root, 0);
	printf("-------------------------------------------\n");
}

/*********************************
*	随机生成一棵树
**********************************/
BinaryTreeNode* creatNode(int deep, int range, BinaryTreeNode* parent) {

	BinaryTreeNode* node = new BinaryTreeNode();
	node->m_pParent = parent;
	node->m_nValue = rand() % range;
	node->m_pLeft = node->m_pRight = NULL;
	if (deep - 1 > 0) {
		if (rand() % 2)
			node->m_pLeft = creatNode(deep - 1, range, node);
		else
			node->m_pLeft = NULL;

		if (rand() % 2)
			node->m_pRight = creatNode(deep - 1, range, node);
		else
			node->m_pRight = NULL;
	}

	return node;
}

BinaryTreeNode* creatRandTree(int deep, int range) {
	if (deep <= 0) {
		return NULL;
	}
	BinaryTreeNode* root = new BinaryTreeNode();
	root->m_pParent = NULL;
	root->m_nValue = rand() % range;
	if (deep == 1) {
		root->m_pLeft = NULL;
		root->m_pRight = NULL;
	}
	else {
		if (rand() % 2)
			root->m_pLeft = creatNode(deep - 1, range, root);
		else
			root->m_pLeft = NULL;

		if (rand() % 2)
			root->m_pRight = creatNode(deep - 1, range, root);
		else
			root->m_pRight = NULL;
	}

	return root;
}
/*********************************
*	算法
**********************************/

BinaryTreeNode* GetNext(BinaryTreeNode* pNode) {
	if (pNode == NULL) {
		return NULL;
	}

	BinaryTreeNode* pNext = NULL;

	if (pNode->m_pRight != NULL) {
		BinaryTreeNode* pRight = pNode->m_pRight;
		while (pRight->m_pLeft != NULL) {
			pRight = pRight->m_pLeft;
		}

		pNext = pRight;
	}
	else if (pNode->m_pParent != NULL) {
		BinaryTreeNode* pCurrent = pNode;
		BinaryTreeNode* pParent = pNode->m_pParent;

		while (pParent != NULL && pCurrent == pParent->m_pRight) {
			pCurrent = pParent;
			pParent = pParent->m_pParent;
		}
		
		pNext = pParent; // 要么是目标节点，要么是NULL
	}

	return pNext;
}

int main() {

	srand(10);
	BinaryTreeNode* root = creatRandTree(4, 100);
	print_tree(root);

	BinaryTreeNode* pNode = root;

	while (pNode->m_pLeft) {
		pNode = pNode->m_pLeft;
	}
	
	cout << "Inorder: ";
	cout << pNode->m_nValue << " ";
	while (pNode=GetNext(pNode)) {
		cout << pNode->m_nValue << " ";
	}

	system("pause");
	return 0;
}

·应用场景：非递归方法中序遍历树。