LeetCode OJ——Binary Tree Inorder Traversal

http://oj.leetcode.com/problems/binary-tree-inorder-traversal/

树的中序遍历，递归方法，和非递归方法。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    void subfunction(TreeNode *root,vector<int> &result)
    {
        if(root == NULL)
            return;
        subfunction(root->left,result);
        result.push_back(root->val);
        subfunction(root->right,result);
    }
public:
    vector<int> inorderTraversal(TreeNode *root) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
     vector<int> result;
     result.clear();
     subfunction(root,result);
     return result;

    }
};

 #include <iostream>;
 #include<stack>
 #include<vector>
 using namespace std;

  //Definition for binary tree
   struct TreeNode {
       int val;
       TreeNode *left;
       TreeNode *right;
       TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };
   class Solution {

   private:
       void instack(TreeNode * root,stack< TreeNode*> &datastack )
       {
           if(root ==NULL)
               return;
           while(root ->left!=NULL)
           {
               datastack.push(root ->left);
               root = root ->left;
           }
       }
   public:
       vector< int> inorderTraversal(TreeNode *root) {
           // Note: The Solution object is instantiated only once and is reused by each test case.
           stack<TreeNode *> datastack;

           vector<int> result;
           result.clear();
           if(root==NULL)
               return result;
           datastack.push(root);
           instack( root,datastack);

           TreeNode* tempNode = (TreeNode*)malloc(sizeof(TreeNode));
           while(datastack.empty()==false)
           {
               tempNode = datastack.top();
               result.push_back(tempNode->val);
               datastack.pop();
               if(tempNode->right==NULL )
                   continue;
               else
               {
                   datastack.push(tempNode->right);
                   instack(tempNode->right,datastack);
               }
           }
           return result;
       }
   };

#include<iostream>
#include"cla.h"
using namespace std;

int main()
{
    TreeNode *myroot = (TreeNode*)malloc(sizeof(TreeNode));
    myroot->val = ;

    TreeNode *myroot2 = (TreeNode*)malloc(sizeof(TreeNode));
    myroot2->val = -;
    myroot2->left = NULL;
    myroot2->right = NULL;

    TreeNode *myroot3 = (TreeNode*)malloc(sizeof(TreeNode));
    myroot3->val = ;
    myroot3->left = NULL;
    myroot3->right = NULL;

    myroot->left = myroot2;
    myroot->right = myroot3;

    TreeNode *myroot4 = (TreeNode*)malloc(sizeof(TreeNode));
    /*myroot4->val = 9;*/
    /*myroot3->right =myroot4;*/
    myroot4->left = NULL;
    myroot4->right = NULL;

    Solution *pSolution = new Solution;

    vector<int> result;
    result = pSolution->inorderTraversal(NULL);
    for(int i = ;i<result.size();i++)
        cout<<result[i]<<"   ";

    if(pSolution!=NULL)
        delete pSolution;
    pSolution = NULL;

    return ;
}