OZ

1.PreOrder - Using Stack.txt

@@ -0,0 +1,69 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    void preorder(TreeNode* root,vector<int> &ans)
+    {
+        if(root==NULL)
+        {
+            return;
+        }
+        else
+        {
+             ans.push_back(root->val);
+            preorder(root->left,ans);
+            preorder(root->right,ans);
+        }
+    }
+public:
+    vector<int> preorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        preorder(root,ans);
+        return ans;
+    }
+};
+
+
+
+
+Using stack
+
+class Solution {
+public:
+    vector<int> preorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        if(root==NULL)
+        {
+            return ans;
+        }
+        else
+        {
+            stack<TreeNode*> st;
+            st.push(root);
+            while(!st.empty())
+            {
+                TreeNode* node = st.top();
+                st.pop();
+                 if(node->right!=NULL)
+                {
+                    st.push(node->right);
+                }
+                if(node->left!=NULL)
+                {
+                    st.push(node->left);
+                }
+               ans.push_back(node->val);
+            }
+            return ans;
+        }
+    }
+};

2.PostOrder - Using Stack.txt

@@ -0,0 +1,87 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+    public:
+    void postorder(TreeNode* root,vector<int> &ans)
+    {
+        if(root==NULL)
+        {
+            return;
+        }
+        else
+        {
+            postorder(root->left,ans);
+            postorder(root->right,ans);
+            ans.push_back(root->val);
+        }
+    }
+public:
+    vector<int> postorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        postorder(root,ans);
+        return ans;
+    }
+};
+
+
+
+
+class Solution {
+public:
+    vector<int> postorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        if(root==NULL)
+        {
+            return ans;
+        }
+        else if(root->left==NULL&root->right==NULL)
+        {
+            ans.push_back(root->val);
+            return ans;
+        }
+        else
+        {
+            stack<TreeNode*> st;
+            TreeNode* curr = root;
+            TreeNode* temp;
+            while(curr!=NULL||!st.empty())
+            {
+                if(curr!=NULL)
+                {
+                    st.push(curr);
+                    curr=curr->left;
+                }
+                else
+                {
+                    temp = st.top()->right;
+                    if(temp==NULL)
+                    {
+                        temp = st.top();
+                        st.pop();
+                        ans.push_back(temp->val);
+                        while(!st.empty()&&temp==st.top()->right)
+                        {
+                            temp = st.top();
+                            st.pop();
+                            ans.push_back(temp->val);
+                        }
+                    }
+                    else
+                    {
+                        curr = temp;
+                    }
+                }
+            }
+            return ans;
+        }
+    }
+};

3.InOrder Using Stack.txt

@@ -0,0 +1,82 @@
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+    public:
+    void inorder(TreeNode* root,vector<int> &ans)
+    {
+        if(root==NULL)
+        {
+            return;
+        }
+        else
+        {
+            inorder(root->left,ans);
+            ans.push_back(root->val);
+            inorder(root->right,ans);
+        }
+    }
+public:
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        inorder(root,ans);
+        return ans;
+    }
+};
+
+
+
+
+
+class Solution {
+public:
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> ans;
+        if(!root)
+        {
+            return ans;
+        }
+        else if(root->left==NULL&&root->right==NULL)
+        {
+            ans.push_back(root->val);
+            return ans;
+        }
+        else
+        {
+            stack<TreeNode*> st;
+            TreeNode* node = root;
+             while(true)
+              {
+                 if(node!=NULL)
+                  {
+                    st.push(node);
+                    node=node->left;
+                  }
+                 else
+                  {
+                    if(st.empty())
+                    {
+                       break;
+                    }
+                    else
+                    {
+                       node=st.top();
+                       ans.push_back(node->val);
+                       st.pop();
+                       node = node->right;
+                    }
+                 }
+              }
+        return ans;
+        }
+    }
+};

31aug6.cpp

@@ -0,0 +1,36 @@
+// Code to understand the working of the copy constructor.
+#include <iostream>
+using namespace std;
+class person
+{
+private:
+    string name;
+    int age;
+
+public:
+    person(string person_name, int person_age)
+    {
+        cout << "Constructor for both name and age is called" << endl;
+        name = person_name;
+        age = person_age;
+    }
+    person(const person &obj)
+    {
+        cout << "Copy constructor is called" << endl;
+        name = obj.name;
+        age = obj.age;
+    }
+    void display()
+    {
+        cout << "Name of current object : " << name << endl;
+        cout << "Age of current object : " << age << endl;
+        cout << endl;
+    }
+};
+int main()
+{
+    person obj1("First person", 25);
+    obj1.display();
+    person obj2(obj1);
+    obj2.display();
+};