280/281: edge crawling Serialize and Deserialize Binary Tree

Author: MaskRay

README.md

@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 279/279 problems.
+Solved 280/281 problems.
 
 ## Database
 
@@ -12,6 +12,7 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|297|[Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)|[serialize-and-deserialize-binary-tree.cc](serialize-and-deserialize-binary-tree.cc)|
 |296|[Best Meeting Point](https://leetcode.com/problems/best-meeting-point/)|[best-meeting-point.cc](best-meeting-point.cc)|
 |295|[Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/)|[find-median-from-data-stream.cc](find-median-from-data-stream.cc)|
 |294|[Flip Game II](https://leetcode.com/problems/flip-game-ii/)|[flip-game-ii.cc](flip-game-ii.cc)|

best-meeting-point.cc

@@ -12,7 +12,6 @@ class Solution {
         xs.push_back(i);
         ys.push_back(j);
       }
-    nth_element(xs.begin(), xs.begin()+xs.size()/2, xs.end());
     nth_element(ys.begin(), ys.begin()+ys.size()/2, ys.end());
     int d = 0, rx = xs[xs.size()/2], ry = ys[ys.size()/2];
     for (auto x: xs)

count-complete-tree-nodes.cc

@@ -10,3 +10,29 @@ class Solution {
     return dl == dr ? (1 << dl) - 1 : countNodes(root->left) + countNodes(root->right) + 1;
   }
 };
+
+///
+
+class Solution {
+  int f(TreeNode *x) {
+    int h = 0;
+    for (; x; x = x->left)
+      h++;
+    return h;
+  }
+public:
+  int countNodes(TreeNode *root) {
+    int h = f(root), s = 0;
+    while (root) {
+      h--;
+      if (f(root->right) == h) {
+        s += 1 << h;
+        root = root->right;
+      } else {
+        s += 1 << h-1;
+        root = root->left;
+      }
+    }
+    return s;
+  }
+};

find-peak-element.cc

@@ -12,3 +12,18 @@ class Solution {
     return l;
   }
 };
+
+///
+
+class Solution {
+public:
+  int findPeakElement(vector<int> &a) {
+    int l = 0, h = a.size();
+    while (l < h-1) {
+      int m = l+h >> 1;
+      if (a[m-1] > a[m]) h = m;
+      else l = m;
+    }
+    return l;
+  }
+};

first-missing-positive.cc

@@ -1,15 +1,32 @@
 // First Missing Positive
 #define REP(i, n) for (int i = 0; i < (n); i++)
-
 class Solution {
 public:
-  int firstMissingPositive(int A[], int n) {
+  int firstMissingPositive(vector<int> &a) {
+    int n = a.size();
     REP(i, n)
-      while (0 < A[i] && A[i] <= n && A[A[i]-1] != A[i])
-        swap(A[A[i]-1], A[i]);
+      while (0 < a[i] && a[i] <= n && a[a[i]-1] != a[i])
+        swap(a[a[i]-1], a[i]);
     REP(i, n)
-      if (A[i] != i+1)
+      if (a[i] != i+1)
         return i+1;
     return n+1;
   }
 };
+
+///
+
+class Solution {
+public:
+  int firstMissingPositive(vector<int> &a) {
+    int l = 0, h = a.size();
+    while (l < h)
+      if (a[l]-1 == l)
+        l++;
+      else if (l <= a[l]-1 && a[l]-1 < h && a[a[l]-1] != a[l])
+        swap(a[l], a[a[l]-1]);
+      else
+        a[l] = a[--h];
+    return l+1;
+  }
+};

serialize-and-deserialize-binary-tree.cc

@@ -0,0 +1,101 @@
+// Serialize and Deserialize Binary Tree
+class Codec {
+  void encode(TreeNode *x, string &s) {
+    if (! x)
+      s += ".,";
+    else {
+      s += to_string(x->val)+",";
+      encode(x->left, s);
+      encode(x->right, s);
+    }
+  }
+  TreeNode *decode(istringstream &ss) {
+    string t;
+    getline(ss, t, ',');
+    if (t == ".")
+      return NULL;
+    auto r = new TreeNode(stoi(t));
+    r->left = decode(ss);
+    r->right = decode(ss);
+    return r;
+  }
+public:
+  string serialize(TreeNode* root) {
+    string s;
+    encode(root, s);
+    return s;
+  }
+  TreeNode* deserialize(string data) {
+    istringstream ss(data);
+    return decode(ss);
+  }
+};
+
+/// O(1) extra space, Morris pre-order traversal + edge crawling (resembling Schorr-Waite graph marking algorithm)
+
+class Codec {
+  int tag(TreeNode *x) {
+    return ptrdiff_t(x) & 3;
+  }
+  TreeNode *pointer(TreeNode *x) {
+    return (TreeNode *)(ptrdiff_t(x) & -4);
+  }
+public:
+  string serialize(TreeNode* x) {
+    string s;
+    while (x) {
+      auto y = x->left;
+      if (y) {
+        while (y->right && y->right != x)
+          y = y->right;
+        if (y->right == x) {
+          y->right = NULL;
+          s += ".,";
+        } else {
+          s += to_string(x->val)+",";
+          y->right = x;
+          x = x->left;
+          continue;
+        }
+      } else
+        s += to_string(x->val)+",.,";
+      x = x->right;
+    }
+    s += ".,";
+    return s;
+  }
+  TreeNode* deserialize(string data) {
+    istringstream ss(data);
+    string t;
+    getline(ss, t, ',');
+    if (t == ".")
+      return NULL;
+    TreeNode *x = new TreeNode(stoi(t)), *y, *p = NULL;
+    for(;;) {
+      int xt = tag(x);
+      auto xp = pointer(x);
+      if (xt < 2) {
+        x = (TreeNode *)(ptrdiff_t(xp) | xt+1);
+        getline(ss, t, ',');
+        y = t == "." ? NULL : new TreeNode(stoi(t));
+        if (y) {
+          (xt ? xp->right : xp->left) = p;
+          p = x;
+          x = y;
+        } else
+          (xt ? xp->right : xp->left) = NULL;
+      } else {
+        x = pointer(x);
+        if (! p) break;
+        y = x;
+        x = p;
+        xp = pointer(x);
+        if (tag(x) == 1)
+          p = xp->left, xp->left = y;
+        else
+          p = xp->right, xp->right = y;
+      }
+    }
+    return x;
+  }
+};