Create integer.cpp

C++_DSA/BinaryTreeInorderTraversal.cpp

@@ -0,0 +1,68 @@
+/*
+
+Binary Tree Inorder Traversal
+
+Given the root of a binary tree, return the inorder traversal of its nodes' values.
+
+
+
+Input: root = [1,null,2,3]
+Output: [1,3,2]
+Example 2:
+
+Input: root = []
+Output: []
+Example 3:
+
+Input: root = [1]
+Output: [1]
+
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 100].
+-100 <= Node.val <= 100
+
+
+*/
+
+
+/**
+ * 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:
+
+
+
+
+ vector<int> inorderTraversal(TreeNode* root) {
+ vector<int> v;
+
+ stack<TreeNode*> s;
+
+
+ while(root || !s.empty()){
+
+ while(root){
+ s.push(root);
+ root=root->left;
+ }
+ root=s.top();
+ s.pop();
+ v.push_back(root->val);
+ root=root->right;
+ }
+
+
+ return v;
+ }
+};

C++_DSA/BinaryTreeMinimumDepth.cpp

@@ -0,0 +1,69 @@
+/*
+
+Minimum Depth of Binary Tree
+
+Given a binary tree, find its minimum depth.
+
+The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
+
+Note: A leaf is a node with no children.
+
+
+Input: root = [3,9,20,null,null,15,7]
+Output: 2
+Example 2:
+
+Input: root = [2,null,3,null,4,null,5,null,6]
+Output: 5
+
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 105].
+-1000 <= Node.val <= 1000
+
+*/
+
+
+/**
+ * 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:
+ int minDepth(TreeNode* root) {
+ int c=0;
+ if(!root) return c;
+
+ queue<TreeNode*> q;
+
+ q.push(root);
+
+ while(!q.empty()){
+
+ int x=q.size();
+ c++;
+ while(x){
+ TreeNode *t=q.front();
+ q.pop();
+ if(t->left ==nullptr && t->right ==nullptr){
+ return c;
+ }
+ if(t->left) q.push(t->left);
+ if(t->right) q.push(t->right);
+ x--;
+ }
+
+
+ }
+
+ return c;
+ }
+};

FibonacciNumberFunction.java

@@ -0,0 +1,16 @@
+ //Using Dynamic Programming
+ static int fib(int n)
+ {
+ int f[] = new int[n+2]; // 1 extra to handle case, n = 0
+ int i;
+
+ f[0] = 0;
+ f[1] = 1;
+
+ for (i = 2; i <= n; i++)
+ {
+ f[i] = f[i-1] + f[i-2];
+ }
+
+ return f[n];
+ }

Java_DSA/DSA-Recursion.java

@@ -0,0 +1,33 @@
+public class RecursionDemo {
+ public static void main(String[] args){
+ RecursionDemo recursionDemo = new RecursionDemo();
+ int n = 5;
+ System.out.println(Factorial of + n + 
+ + recursionDemo.factorial(n));
+ System.out.print(Fibbonacci of + n + );
+ for(int i=0;in;i++){
+ System.out.print(recursionDemo.fibbonacci(i) + ); 
+ }
+ }
+
+ private int factorial(int n){
+ base case
+ if(n == 0){
+ return 1;
+ }else{
+ return n factorial(n-1);
+ }
+ }
+
+ private int fibbonacci(int n){
+ if(n ==0){
+ return 0;
+ }
+ else if(n==1){
+ return 1;
+ }
+ else {
+ return (fibbonacci(n-1) + fibbonacci(n-2));
+ }
+ }
+}

Java_DSA/HouseRobber.java

@@ -0,0 +1,30 @@
+/* You are a professional robber planning to rob houses along a street. 
+ Each house has acertain amount of monet stashed.
+ The onlt constraint stopping you for robbing each of them is that each house have security systems connected and it will automatically contact the police
+ if two ajacent houses were broken into on the same night.
+ Considering the constarints determine the maximum amount of money you can rob tonight without alerting the police. 
+*/
+
+public class HouseRobber{
+ public static void main(String[] args) {
+ int[] arr = {2,45,8,7,98,24};
+ int maxAmount = robHouse(arr);
+ System.out.println("Maximum amount that can be robbed : "+ maxAmount);
+ }
+
+ static int robHouse(int[] arr){
+ int prev = arr[0], curr = Math.max(arr[0], arr[1]);
+
+ for(int i =2; i< arr.length; i++){
+ int temp = curr;
+ curr = Math.max(prev + arr[i], curr);
+ prev = temp;
+ }
+ return curr;
+ }
+}
+
+
+
+
+//prints:- Maximum amount that can be robbed : 143