Move rob from ArrayList to LeetCode

Author: lewis617

ArrayList/ArrayList.js

@@ -130,29 +130,6 @@ function ArrayList() {
     return -1;
   };
 
-  var rob = function (array) {
-    var last = 0,
-      now = 0;
-    for (var i = 0; i < array.length; i++) {
-      var temp = last;
-      last = now;
-      now = Math.max(temp + array[i], now);
-    }
-
-    return now;
-  };
-
-  this.simpleRob = function () {
-    return rob(array);
-  };
-
-  this.circleRob = function () {
-    if (array.length === 1) {
-      return array[0];
-    }
-    return Math.max(rob(array.slice(1)), rob(array.slice(0, array.length - 1)));
-  };
-
   this.findContentChildren = function (cookies) {
     this.quickSort();
     cookies.sort(function (a, b) {

ArrayList/ArrayList.test.js

@@ -42,30 +42,6 @@ test('ArrayList', function () {
   expect(array.binarySearch(6)).toBe(-1);
   expect(array.binarySearch(2)).toBe(1);
 
-  function createRobArray() {
-    var array = new ArrayList();
-    array.insert(2);
-    array.insert(0);
-    array.insert(0);
-    array.insert(4);
-    array.insert(5);
-    return array;
-  }
-
-  array = createRobArray();
-  expect(array.simpleRob()).toBe(7);
-  expect(array.circleRob()).toBe(6);
-
-  function createOneLengthRobArray() {
-    var array = new ArrayList();
-    array.insert(2);
-    return array;
-  }
-
-  array = createOneLengthRobArray();
-  expect(array.simpleRob()).toBe(2);
-  expect(array.circleRob()).toBe(2);
-
   array = createNonSortedArray();
   expect(array.findContentChildren([1, 1])).toBe(1);
   expect(array.findContentChildren([1, 2, 3])).toBe(3);

LeetCode/__tests__/rob1.test.js

@@ -0,0 +1,5 @@
+var rob1 = require('../rob1');
+
+test('rob1', function () {
+  expect(rob1([2, 0, 0, 4, 5])).toBe(7);
+});

LeetCode/__tests__/rob2.test.js

@@ -0,0 +1,6 @@
+var rob2 = require('../rob2');
+
+test('rob2', function () {
+  expect(rob2([2])).toBe(2);
+  expect(rob2([2, 0, 0, 4, 5])).toBe(6);
+});

LeetCode/__tests__/rob3.test.js

@@ -0,0 +1,15 @@
+var rob3 = require('../rob3');
+var BinarySearchTree = require('../../Tree/BinarySearchTree');
+
+test('rob3', function () {
+  var binarySearchTree = new BinarySearchTree();
+
+  binarySearchTree.insert(11);
+  binarySearchTree.insert(7);
+  binarySearchTree.insert(13);
+  binarySearchTree.insert(5);
+  binarySearchTree.insert(3);
+  binarySearchTree.insert(9);
+
+  expect(rob3(binarySearchTree.getRoot())).toBe(27);
+});

LeetCode/rob1.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  var last = 0,
+    now = 0;
+  for (var i = 0; i < nums.length; i++) {
+    var temp = last;
+    last = now;
+    now = Math.max(temp + nums[i], now);
+  }
+
+  return now;
+};
+
+module.exports = rob;

LeetCode/rob2.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+  var rob1 = require('./rob1');
+
+  if (nums.length === 1) {
+    return nums[0];
+  }
+  return Math.max(rob1(nums.slice(1)), rob1(nums.slice(0, nums.length - 1)));
+};
+
+module.exports = rob;

LeetCode/rob3.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(key) {
+ *     this.val = key;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var rob = function(root) {
+  var dfs = function (node) {
+    if (node === null) {
+      return [null, null];
+    }
+    var left = dfs(node.left);
+    var right = dfs(node.right);
+    var res = [];
+    res[0] = left[1] + right[1] + node.key;
+    res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
+    return res;
+  };
+
+  var num = dfs(root);
+  return Math.max(num[0], num[1]);
+};
+
+module.exports = rob;

Tree/BinarySearchTree.js

@@ -133,27 +133,6 @@ function BinarySearchTree() {
       }
     }
   };
-  /**
-   * 打家劫舍问题：房屋按二叉树来排列，
-   * 不允许在同一晚打劫相邻的两家，
-   * 求能打劫到的最大钱财数量。
-   */
-  this.rob = function () {
-    var dfs = function(node){
-      if(node === null){
-        return [null, null];
-      }
-      var left = dfs(node.left);
-      var right = dfs(node.right);
-      var res = [];
-      res[0] = left[1] + right[1] + node.key;
-      res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
-      return res;
-    };
-
-    var num = dfs(root);
-    return Math.max(num[0], num[1]);
-  };
 
   var minNode = function (node) {
     if (node) {
@@ -219,7 +198,7 @@ function BinarySearchTree() {
       return node;
     } else {
       if (node.left === null && node.right === null) {
-        if(node ===root){
+        if (node === root) {
           root = null;
         }
         node = null;
@@ -250,6 +229,10 @@ function BinarySearchTree() {
     });
     return keyList;
   };
+
+  this.getRoot = function () {
+    return root;
+  }
 }
 
 module.exports = BinarySearchTree;

Tree/BinarySearchTree.test.js

@@ -17,8 +17,6 @@ test('BinarySearchTree', function () {
   expect(binarySearchTree.values('postOrderTraverse')).toEqual([3, 5, 9, 7, 13, 11]);
   expect(binarySearchTree.values('postOrderTraverseUnRec')).toEqual([3, 5, 9, 7, 13, 11]);
 
-  expect(binarySearchTree.rob()).toBe(27);
-
   expect(binarySearchTree.min()).toBe(3);
   expect(binarySearchTree.max()).toBe(13);
   expect(binarySearchTree.search(3)).toBeTruthy();
@@ -50,4 +48,5 @@ test('BinarySearchTree', function () {
   expect(binarySearchTree.min()).toBe(null);
   expect(binarySearchTree.max()).toBe(null);
   expect(binarySearchTree.remove(11)).toBe(null);
+  expect(binarySearchTree.getRoot()).toBe(null)
 });