Given a binary tree, return the inorder traversal of its nodes‘ values.
For example:
Given binary tree [1,null,2,3],
1
2
/
3
return [1,3,2].
Note: Recursive solution is trivial, could you do it iteratively?
我的AC代码，递归写法比较简单，所以试试迭代：
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> nums;
stack<TreeNode *> stackNode;
while(root)
{
stackNode.push(root);
if (root->left != NULL)
{
root = root->left;
continue;
}
nums.push_back(root->val);
stackNode.pop();
if (root->right != NULL)
{
root = root->right;
continue;
}
TreeNode * node = root;
if (!stackNode.empty())
{
root = stackNode.top();
root->left = NULL;
stackNode.pop();
}
if (node == root)
break;
}
return nums;
}
};
利用递归栈的思路，自己维护一个栈，时间复杂度应该是O(n)，空间复杂度O(n)。
看看AC后的详细细节：
运行时间是3ms。
不过我也写了一个递归版的：
class Solution {
public:
void helper(TreeNode* root, vector<int> & nums) {
if (root) {
helper(root->left, nums);
nums.push_back(root->val);
helper(root->right, nums);
}
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> nums;
helper(root, nums);
return nums;
}
};
这个运行结果感觉差不多：
完整的迭代算法：
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class Tree {
public:
int val;
Tree * left;
Tree * right;
Tree() : val(), left(NULL), right(NULL) {}
void CreateTree(Tree * &root);
Tree* insert(Tree * root, int x);
void buildTree(Tree* root, vector<int> nums);
void inorderTraversal(Tree * root);
void iterative_inorderTraversal(Tree * root);
};
void Tree::CreateTree(Tree * &root)
{
int val;
cin >> val;
if (val == -1)
root = NULL;
else
{
root = new Tree;
root->val = val;
CreateTree(root->left);
CreateTree(root->right);
}
}
Tree* Tree::insert(Tree * root, int x)
{
Tree * node = new Tree;
node->val = x;
if (root == NULL)
{
root = node;
return root;
}
else if (root->left == NULL)
{
root->left = node;
return root;
}
else if (root->right == NULL)
{
root->right = node;
return root;
}
else
node->left = root;
return node;
}
void Tree::buildTree(Tree* root, vector<int> nums)
{
for (auto n : nums)
root = insert(root, n);
}
void Tree::inorderTraversal(Tree * root)
{
if (root != NULL)
{
inorderTraversal(root->left);
cout << root->val << ‘ ‘;
inorderTraversal(root->right);
}
}
void Tree::iterative_inorderTraversal(Tree * root)
{
stack<Tree *> stackNode;
while(root)
{
stackNode.push(root);
if (root->left != NULL)
{
root = root->left;
continue;
}
cout << root->val << ‘ ‘;
stackNode.pop();
if (root->right != NULL)
{
root = root->right;
continue;
}
Tree * node = root;
if (!stackNode.empty())
{
root = stackNode.top();
root->left = NULL;
stackNode.pop();
}
if (node == root)
break;
}
}
int main()
{
//vector<int> nums{ 1,2,3 };
Tree * root = NULL;
root->CreateTree(root);
//root->buildTree(root, nums);
root->inorderTraversal(root);
cout << endl;
root->iterative_inorderTraversal(root);
return 0;
}
