Add binary tree preorder + reorder list.

Author: AnnieKim

BinaryTreePreorderTraversal.h

@@ -0,0 +1,103 @@
+/*
+ Author:     Annie Kim, [email protected]
+ Date:       Nov 11, 2013
+ Problem:    Binary Tree Preorder Traversal
+ Difficulty: Easy
+ Source:     http://oj.leetcode.com/problems/binary-tree-preorder-traversal/
+ Notes:
+ Given a binary tree, return the preorder traversal of its nodes' values.
+ For example:
+ Given binary tree {1,#,2,3},
+    1
+     \
+      2
+     /
+    3
+ return [1,2,3].
+ Note: Recursive solution is trivial, could you do it iteratively?
+
+ Solution: 1. Iterative way (stack).   Time: O(n), Space: O(n).
+           2. Recursive solution.      Time: O(n), Space: O(n).
+           3. Threaded tree (Morris).  Time: O(n), Space: O(1).
+ */
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> preorderTraversal(TreeNode *root) {
+        return preorderTraversal_3(root);
+    }
+    
+    vector<int> preorderTraversal_1(TreeNode *root) {
+        vector<int> res;
+        stack<TreeNode *> stk;
+        TreeNode *cur = root;
+        while (cur || !stk.empty())
+        {
+            if (cur)
+            {
+                res.push_back(cur->val);
+                stk.push(cur);
+                cur = cur->left;
+            }
+            else if (!stk.empty())
+            {
+                cur = stk.top()->right;
+                stk.pop();
+            }
+        }
+        return res;
+    }
+    
+    vector<int> preorderTraversal_2(TreeNode *root) {
+        vector<int> res;
+        preorderTraversalRe(root, res);
+        return res;
+    }
+
+    void preorderTraversalRe(TreeNode *node, vector<int> &res) {
+        if (!node) return;
+        res.push_back(node->val);
+        preorderTraversalRe(node->left, res);
+        preorderTraversalRe(node->right, res);
+    }
+    
+    vector<int> preorderTraversal_3(TreeNode *root) {
+        vector<int> res;
+        TreeNode *cur = root;
+        while (cur)
+        {
+            if (cur->left)
+            {
+                TreeNode *prev = cur->left;
+                while (prev->right && prev->right != cur)
+                    prev = prev->right;
+                    
+                if (prev->right == cur)
+                {
+                    cur = cur->right;
+                    prev->right = NULL;
+                }
+                else
+                {
+                    res.push_back(cur->val);
+                    prev->right = cur;
+                    cur = cur->left;
+                }
+            }
+            else
+            {
+                res.push_back(cur->val);
+                cur = cur->right;
+            }
+        }
+        return res;
+    }
+};

ReorderList.h

@@ -0,0 +1,51 @@
+/*
+ Author:     Annie Kim, [email protected]
+ Date:       Nov 11, 2013
+ Problem:    Reorder List
+ Difficulty: Easy
+ Source:     http://oj.leetcode.com/problems/reorder-list/
+ Notes:
+ Given a singly linked list L: L0->L1->...->Ln-1->Ln,
+ reorder it to: L0->Ln->L1->Ln-1->L2->Ln-2->...
+ You must do this in-place without altering the nodes' values.
+ For example,
+ Given {1,2,3,4}, reorder it to {1,4,2,3}.
+
+ Solution: Reverse the back half first, then reorder.
+*/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void reorderList(ListNode *head) {
+        if (!head || !head->next) return;
+        ListNode *slow = head, *fast = head->next->next;
+        while (fast && fast->next) {
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        if (fast) slow = slow->next;
+        ListNode *mid = slow, *cur = slow->next;
+        while (cur->next) {
+            ListNode *mov = cur->next;
+            cur->next = mov->next;
+            mov->next = mid->next;
+            mid->next = mov;
+        }
+        cur = head;
+        while (cur != mid && mid->next) {
+            ListNode *mov = mid->next;
+            mid->next = mov->next;
+            mov->next = cur->next;
+            cur->next = mov;
+            cur = cur->next->next;
+        }
+    }
+};