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 = 0;
    
    TreeNode *myroot2 = (TreeNode*)malloc(sizeof(TreeNode));
    myroot2->val = -3;
    myroot2->left = NULL;
    myroot2->right = NULL;

    TreeNode *myroot3 = (TreeNode*)malloc(sizeof(TreeNode));
    myroot3->val = 5;
    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 = 0;i<result.size();i++)
        cout<<result[i]<<"   ";

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

    return 0;
}