leetcode

简单来说，就是二叉树的前序、中序、后序遍历，包括了递归和非递归的方法

前序遍历（注释中的为递归版本）：

#include <vector>
#include <stack>
#include <stddef.h>
#include <iostream>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    vector<int> preorderTraversal(TreeNode *root)
    {
        /*
        vector<int> rootVector;
        vector<int> leftVector;
        vector<int> rightVector;

        if (root == NULL)
        {
            return rootVector;
        }

        rootVector.push_back(root->val);
        leftVector = preorderTraversal(root->left);
        rightVector = preorderTraversal(root->right);
        rootVector.insert(rootVector.end(), leftVector.begin(), leftVector.end());
        rootVector.insert(rootVector.end(), rightVector.begin(), rightVector.end());

        return rootVector;
        */
        
        vector<int> preorder;
        stack<TreeNode *> treeNodeStack;

        while (root || !treeNodeStack.empty())
        {
            while (root)
            {
                preorder.push_back(root->val);
                treeNodeStack.push(root);
                root = root->left;
            }
            root = treeNodeStack.top();
            treeNodeStack.pop();
            root = root->right;
        }

        return preorder;
    }
};

int main()
{
    Solution s;
    TreeNode *root = new TreeNode(1);
    root->right = new TreeNode(2);
    root->right->left = new TreeNode(3);

    vector<int> v = s.preorderTraversal(root);

    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
    {
        cout << *it << endl;
    }

    system("pause");

    return 0;
}

中序遍历（注释中的为递归版本）：

#include <vector>
#include <stack>
#include <stddef.h>
#include <iostream>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    vector<int> inorderTraversal(TreeNode *root)
    {
        /*
        vector<int> rootVector;
        vector<int> leftVector;
        vector<int> rightVector;

        if (root == NULL)
        {
            return rootVector;
        }

        leftVector = inorderTraversal(root->left);
        rightVector = inorderTraversal(root->right);
        rootVector.insert(rootVector.end(), leftVector.begin(), leftVector.end());
        rootVector.push_back(root->val);
        rootVector.insert(rootVector.end(), rightVector.begin(), rightVector.end());

        return rootVector;
        */

        vector<int> inorder;
        stack<TreeNode *> treeNodeStack;

        while (root || !treeNodeStack.empty())
        {
            while (root)
            {
                treeNodeStack.push(root);
                root = root->left;
            }

            root = treeNodeStack.top();
            treeNodeStack.pop();
            inorder.push_back(root->val);
            root = root->right;
        }

        return inorder;
    }
};

int main()
{
    Solution s;
    TreeNode *root = new TreeNode(1);
    root->right = new TreeNode(2);
    root->right->left = new TreeNode(3);

    vector<int> v = s.inorderTraversal(root);

    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
    {
        cout << *it << endl;
    }

    system("pause");

    return 0;
}

后序遍历（注释中的为递归版本）：

#include <vector>
#include <stack>
#include <stddef.h>
#include <iostream>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    vector<int> postorderTraversal(TreeNode *root)
    {
        /*
        vector<int> rootVector;
        vector<int> leftVector;
        vector<int> rightVector;

        if (root == NULL)
        {
            return rootVector;
        }

        leftVector = postorderTraversal(root->left);
        rightVector = postorderTraversal(root->right);
        rootVector.insert(rootVector.end(), leftVector.begin(), leftVector.end());
        rootVector.insert(rootVector.end(), rightVector.begin(), rightVector.end());
        rootVector.push_back(root->val);

        return rootVector;
        */

        vector<int> postorder;
        stack<TreeNode *> s;
        TreeNode *pre = NULL;

        while (root || !s.empty())
        {
            while (root)
            {
                s.push(root);
                root = root->left;
            }

            root = s.top();
            if (root->right == NULL || pre == root->right)
            {
                postorder.push_back(root->val);
                s.pop();
                pre = root;
                root = NULL;
            }
            else
            {
                root = root->right;                
            }
        }

        return postorder;
    }
};

int main()
{
    Solution s;
    TreeNode *root = new TreeNode(1);
    root->right = new TreeNode(2);
    root->right->left = new TreeNode(3);

    vector<int> v = s.postorderTraversal(root);

    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
    {
        cout << *it << endl;
    }

    system("pause");

    return 0;
}

递归的算法非常简单，就不说了

非递归的算法，前序和中序相对简单，主要就是利用栈来模拟递归，后序的思路是这样的，当前节点的右子树为空或者右子树已访问过，则访问该节点，否则访问该节点的右子树，这里需要有一个pre指针来标识前一个访问的节点是否为右子节点，链接：http://blog.csdn.net/chenqiumiao/article/details/6901309