08.16

https://leetcode.com/problems/minimum-depth-of-binary-tree/description/

111. Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

DFS (Depth First Search)

 1 int
 
 minDepth(struct TreeNode* root) {
 2     int leftMin, rightMin, min;
 3 
 4     if (root == NULL) {
 5         return 0;
 6     }
 7     leftMin = minDepth(root->left);
 8     rightMin = minDepth(root->right);
 9     if (leftMin == 0) {
10         min = rightMin;
11     }
12     else if (rightMin == 0
 
) {
13         min = leftMin;
14     }
15     else {
16         min = leftMin < rightMin ? leftMin : rightMin;
17     }
18     return (min + 1);
19 }

耗時9ms。

看到這個解法https://discuss.leetcode.com/topic/8723/my-4-line-java-solution後，修改如下，耗時6ms。耗時節省33%的關鍵在於將兩個if合並為一個if，可能這樣生成的指令較少。

int minDepth(struct
 
 TreeNode* root) {
    int leftMin, rightMin;

    if (root == NULL) {
        return 0;
    }
    leftMin = minDepth(root->left);
    rightMin = minDepth(root->right);
    if (leftMin == 0 || rightMin == 0) {
        return leftMin + rightMin + 1;
    }
    else {
        return (leftMin < rightMin ? leftMin : rightMin) + 1;
    }
}

BFS(Breadth First Search)

同樣耗時9ms，采用類似如上修改後，耗時為6ms。我采用的不是典型的隊列。

int minDepth(struct TreeNode* root) {
    struct TreeNode** nodeRow;
    int depth, len, size, i, j;
    if (root == NULL) {
        return 0;
    }
    size = 1024;
    nodeRow = malloc(sizeof(struct TreeNode*) * size);
    nodeRow[0] = root;
    len = 1;
    for (depth = 1; ; depth++){
        for (i = 0, j = len; i < len; i++) {
            if (nodeRow[i]->left == NULL) {
                if (nodeRow[i]->right == NULL) {
                    goto done;
                }
                nodeRow[i] = nodeRow[i]->right;
            }
            else {
                if (nodeRow[i]->right != NULL) {
                    if (j >= size) {
                        size *= 2;
                        nodeRow = realloc(nodeRow, sizeof(struct TreeNode*) * size);
                        /* error checking */
                    }
                    nodeRow[j++] = nodeRow[i]->right;
                }
                nodeRow[i] = nodeRow[i]->left;
            }
        }
        len = j;
    }
done:
    free(nodeRow);
    return depth;
}

int minDepth(struct TreeNode* root) {
    struct TreeNode** nodeRow;
    struct TreeNode* lChild, * rChild;
    int depth, len, size, i, j, flag;
    if (root == NULL) {
        return 0;
    }
    size = 1024;
    nodeRow = malloc(sizeof(struct TreeNode*) * size);
    nodeRow[0] = root;
    len = 1;
    j = len;
    for (depth = 1; ; depth++){
        for (i = 0; i < len; i++) {
            flag = (nodeRow[i]->left == NULL ? 0 : 2) |
                    (nodeRow[i]->right == NULL ? 0 : 1);
            switch(flag) {
            case 3:
                if (j >= size) {
                    size *= 2;
                    nodeRow = realloc(nodeRow, sizeof(struct TreeNode*) * size);
                    /* error checking */
                }
                nodeRow[j++] = nodeRow[i]->right;
                nodeRow[i] = nodeRow[i]->left;
                break;
            case 2:
                nodeRow[i] = nodeRow[i]->left;
                break;
            case 1:
                nodeRow[i] = nodeRow[i]->right;
                break;
            default: /* least probability */
                goto done;
            }
        }
        len = j;
    }
done:
    free(nodeRow);
    return depth;
}

6ms的排名是33.11% （Your time beats 33.11% of c submissions），不知道進一步怎麽優化。

leetcode小結（龜速刷新）