把经典问题:二叉树的非递归遍历理了理,顺便做个笔记。
核心思路就是节点的压栈和出栈。
#include <iostream>
#include<stack>
#include<vector>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x) { left = right = nullptr; }
TreeNode(int x, TreeNode* theLeft, TreeNode* theRight)
: val(x), left(theLeft), right(theRight) { }
};
class Solution {
TreeNode* root;
void print(vector<int> &result, const char* str) {
vector<int>::iterator it = result.begin();
cout << str;
for (; it != result.end(); ++it)
cout << *it << " ";
cout << endl;
}
public:
Solution(TreeNode* theRoot) : root(theRoot) { }
TreeNode* getRoot() { return root; }
//递归遍历
void prePrint_D(TreeNode* root) {
if (root) {
cout << root->val << " ";
prePrint_D(root->left);
prePrint_D(root->right);
}
}
void midPrint_D(TreeNode* root) {
if (root) {
midPrint_D(root->left);
cout << root->val << " ";
midPrint_D(root->right);
}
}
void postPrint_D(TreeNode* root) {
if (root) {
postPrint_D(root->left);
postPrint_D(root->right);
cout << root->val << " ";
}
}
//非递归遍历
void prePrint() {
if (!root) return;
stack<TreeNode*> nodeStack;
vector<int> result;
TreeNode* cNode = root;
nodeStack.push(cNode)
while (!nodeStack.empty()) {
cNode = nodeStack.top();
result.push_back(cNode->val);
nodeStack.pop();
if (cNode->right) nodeStack.push(cNode->right);
if (cNode->left) nodeStack.push(cNode->left);
}
print(result, "preOrder: ");
}
void midPrint() {
stack<TreeNode*> nodeStack;
vector<int> result;
TreeNode* cNode = root;
while (cNode || !nodeStack.empty()) {
if (cNode) {
nodeStack.push(cNode);
cNode = cNode->left;
}
else {
cNode = nodeStack.top();
result.push_back(cNode->val);
nodeStack.pop();
cNode = cNode->right;
}
}
print(result, "midOrder: ");
}
void postPrint() {
stack<TreeNode*> nodeStack;
vector<int> result;
TreeNode* cNode = root, *lastNode = nullptr;
while (cNode || !nodeStack.empty()) {
if (cNode) {
nodeStack.push(cNode);
cNode = cNode->left;
}
else {
TreeNode* topNode = nodeStack.top();
if (topNode->right && topNode->right != lastNode)
cNode = topNode->right;
else {
result.push_back(topNode->val);
lastNode = topNode;
nodeStack.pop();
}
}
}
print(result, "postOrder: ");
}
};
int main()
{
TreeNode* p1 = new TreeNode(1),
*p2 = p1->left = new TreeNode(2),
*p3 = p1->right = new TreeNode(3),
*p4 = p2->left = new TreeNode(4),
*p5 = p2->right = new TreeNode(5),
*p6 = p3->left = new TreeNode(6),
*p7 = p3->right = new TreeNode(7),
*p8 = p4->left = new TreeNode(8),
*p9 = p4->right = new TreeNode(9),
*p10 = p5->left = new TreeNode(10),
*p11 = p5->right = new TreeNode(11),
*root = p1;
Solution S(root);
cout << "递归:" << endl;
S.prePrint();
S.midPrint();
S.postPrint();
cout << "递归:" << endl;
cout << "preOrder: ";
S.prePrint_D(S.getRoot());
cout << endl;
cout << "midOrder: ";
S.midPrint_D(S.getRoot());
cout << endl;
cout << "postOrder: ";
S.postPrint_D(S.getRoot());
cout << endl;
//...释放二叉树内存代码段...
return 0;
}
输出:
递归:
preOrder: 1 2 4 8 9 5 10 11 3 6 7
midOrder: 8 4 9 2 10 5 11 1 6 3 7
postOrder: 8 9 4 10 11 5 2 6 7 3 1
递归:
preOrder: 1 2 4 8 9 5 10 11 3 6 7
midOrder: 8 4 9 2 10 5 11 1 6 3 7
postOrder: 8 9 4 10 11 5 2 6 7 3 1