add 114,118,155,160,171,189 modified 110

Author: leopsidom

110.balanced-binary-tree.rs

@@ -25,9 +25,28 @@
 // }
 use std::rc::Rc;
 use std::cell::RefCell;
+use std::cmp;
+
 impl Solution {
     pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
-        
+        fn helper(root: Option<Rc<RefCell<TreeNode>>>) -> (bool, i32) {
+            if let Some(rc_node) = root {
+                let tree_node = rc_node.borrow();
+                let (is_left_balanced, left_height) = helper(tree_node.left.clone());
+                let (is_right_balanced, right_height) = helper(tree_node.right.clone());
+
+                if is_left_balanced && is_right_balanced && (left_height - right_height).abs() <= 1 {
+                    (true, cmp::max(left_height, right_height) + 1)
+                } else {
+                    (false, 0)
+                }
+            } else {
+                (true, 0)
+            }
+        }
+
+        let (ans, _) = helper(root);
+        ans
     }
 }
 // @lc code=end

114.flatten-binary-tree-to-linked-list.rs

@@ -0,0 +1,55 @@
+/*
+ * @lc app=leetcode id=114 lang=rust
+ *
+ * [114] Flatten Binary Tree to Linked List
+ */
+
+// @lc code=start
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn flatten(root: &mut Option<Rc<RefCell<TreeNode>>>) {
+
+        if let Some(rc_node) = root {
+            Self::flatten(&mut rc_node.borrow_mut().left);
+            Self::flatten(&mut rc_node.borrow_mut().right);
+
+            let mut left = rc_node.borrow_mut().left.take();
+            if left.is_some() {
+                let right = rc_node.borrow().right.clone();
+                rc_node.borrow_mut().right = left.clone();
+
+                let mut left_ref = left.clone();
+                while let Some(next) = left_ref.take() {
+                    if next.borrow().right.is_some() {
+                        left_ref = next.borrow_mut().right.clone();
+                    } else {
+                        next.borrow_mut().right = right;
+                        break;
+                    }
+                }
+            }
+        }
+
+    }
+}
+// @lc code=end
+

118.pascals-triangle.rs

@@ -0,0 +1,27 @@
+/*
+ * @lc app=leetcode id=118 lang=rust
+ *
+ * [118] Pascal's Triangle
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn generate(num_rows: i32) -> Vec<Vec<i32>> {
+        let mut ans = vec![];
+        let mut curr = vec![1];
+
+        for i in 0..num_rows {
+            let mut next = vec![1];
+            for i in 0..curr.len()-1 {
+                next.push(curr[i] + curr[i+1]);
+            }
+            next.push(1);
+            ans.push(curr);
+            curr = next;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

155.min-stack.rs

@@ -0,0 +1,69 @@
+/*
+ * @lc app=leetcode id=155 lang=rust
+ *
+ * [155] Min Stack
+ */
+
+// @lc code=start
+// use std::i32;
+
+struct MinStack {
+    pub stack: Vec<i32>,
+    pub min: i32
+}
+
+
+/** 
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MinStack {
+
+    /** initialize your data structure here. */
+    fn new() -> Self {
+        MinStack { stack: vec![], min: std::i32::MAX }
+    }
+    
+    fn push(&mut self, x: i32) {
+        if x <= self.min {
+            self.stack.push(self.min);
+            self.min = x;
+        }
+        self.stack.push(x);
+
+    }
+    
+    fn pop(&mut self) {
+        match self.stack.pop() {
+            None => None,
+            Some(val) => {
+                if val == self.min {
+                    match self.stack.pop() {
+                        None => { self.min = std::i32::MAX; },
+                        Some(val1) => { self.min = val1; }
+                    };
+                }
+                Some(val)
+            }
+        };
+    }
+    
+    fn top(&self) -> i32 {
+        self.stack[self.stack.len()-1]
+    }
+    
+    fn get_min(&self) -> i32 {
+        self.min
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * let obj = MinStack::new();
+ * obj.push(x);
+ * obj.pop();
+ * let ret_3: i32 = obj.top();
+ * let ret_4: i32 = obj.get_min();
+ */
+// @lc code=end
+

160.intersection-of-two-linked-lists.rs

@@ -0,0 +1,21 @@
+/*
+ * @lc app=leetcode id=171 lang=rust
+ *
+ * [171] Excel Sheet Column Number
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn title_to_number(s: String) -> i32 {
+        let mut ans = 0;
+
+        for c in s.chars() {
+            ans *= 26;
+            ans += c as i32 - 'A' as i32 + 1;
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

171.excel-sheet-column-number.rs

@@ -0,0 +1,20 @@
+/*
+ * @lc app=leetcode id=189 lang=rust
+ *
+ * [189] Rotate Array
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let mut ans = vec![0; nums.len()];
+
+        for i in 0..nums.len() {
+            ans[(i+k as usize)%nums.len()] = nums[i];
+        }
+
+        ans
+    }
+}
+// @lc code=end
+