tree

Author: vegetabledogg

106-Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal.c

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize) {
+    if (inorderSize <= 0)
+    {
+        return NULL;
+    }
+    struct TreeNode *newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
+    newNode->val = postorder[postorderSize - 1];
+    int i;
+    for (i = 0; i < inorderSize; i++)
+    {
+        if (inorder[i] == postorder[postorderSize - 1])
+        {
+            break;
+        }
+    }
+    newNode->left = buildTree(inorder, i, postorder, i);
+    newNode->right = buildTree(inorder + i + 1, inorderSize - i - 1, postorder + i, inorderSize - i - 1);
+    return newNode;
+}

144-Binary-Tree-Preorder-Traversal.c

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+/**
+ * Return an array of size *returnSize.
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* preorderTraversal(struct TreeNode* root, int* returnSize) {
+    int *result = (int*)malloc(100000 * sizeof(int));
+    struct TreeNode* stack[100000];
+    int top = -1;
+    *returnSize = 0;
+    while (NULL != root || -1 != top)
+    {
+        while (NULL != root)
+        {
+            stack[++top] = root;
+            result[(*returnSize)++] = root->val;
+            root = root->left;
+        }
+        root = stack[top--]->right;
+    }
+    return result;
+}

226-Invert-Binary-Tree.c

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+struct TreeNode* invertTree(struct TreeNode* root) {
+    if (NULL == root)
+    {
+        return NULL;
+    }
+    struct TreeNode *temp = invertTree(root->left);
+    root->left = invertTree(root->right);
+    root->right = temp;
+    return root;
+}

235-Lowest-Common-Ancestor-of-a-Binary-Search-Tree.c

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
+    struct TreeNode *tempNode;
+    while (NULL != root)
+    {
+        if (p->val < root->val && q->val < root->val)
+        {
+            root = root->left;
+        }
+        else if (p->val > root->val && q->val > root->val)
+        {
+            root = root->right;
+        }
+        else
+        {
+            return root;
+        }
+    }
+    return root;
+}