988.从叶结点开始的最小字符串

力扣 988.从叶结点开始的最小字符串

 

1、利用二叉树先序遍历，记录经过的所有节点的值
2、新增停止条件，当左右孩子都为null时，即可认为找到了一条从根到叶子的一条路径，
3、将该路径上的字符串翻转，并与历史值进行比较，得出最小值
4、注意点window下可以按照最长的字符串进行比较大小，linux下只能按照最短字符串进行比较

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
#define MAX_QUEUE_SIZE 8502

typedef struct TreeNode TreeNode;

char g_result[MAX_QUEUE_SIZE];

void ReverseAndCopmare(char *tempResult)
{
    int i;
    int tempLength = strlen(tempResult);
    int resultLength = strlen(g_result);
    char *temp = (char *)malloc((tempLength + 1) * sizeof(char));
    for (i = 0; i < tempLength; i++) {
        temp[tempLength - i - 1] = tempResult[i];
    }
    temp[i] = '\0';

    if (resultLength == 0) {
        memcpy(g_result, temp, (tempLength + 1));
        free(temp);
        temp = NULL;
        return;
    }
    if (tempLength <= resultLength) {
        if (memcmp(temp, g_result, tempLength) <= 0) {
            memcpy(g_result, temp, (tempLength + 1));
        }
    } else {
        if (memcmp(g_result, temp, resultLength) > 0) {
            memcpy(g_result, temp, (tempLength + 1));
        }
    }
    free(temp);
    temp = NULL;
    return;
}

void DfsTraverse(int step, TreeNode *root, char *result)
{
    if (root == NULL) {
        return;
    }

    if ((root->left == NULL) && (root->right == NULL)) {
        result[step] = root->val + 'a';
        result[step + 1] = '\0';
        ReverseAndCopmare(result);
        return;
    }

    result[step] = root->val + 'a';

    DfsTraverse(step + 1, root->left, result);
    DfsTraverse(step + 1, root->right, result);

    return;
}

char *smallestFromLeaf(struct TreeNode *root)
{
    int step = 0;
    char *tempChar = (char *)calloc(MAX_QUEUE_SIZE, sizeof(char));
    memset(g_result, 0, sizeof(g_result));

    DfsTraverse(step, root, &tempChar[0]);
    return g_result;
}

力扣的用力代码如下：

TreeNode *treeQueue[MAX_QUEUE_SIZE];

TreeNode *CreatTree()
{
    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
    root->left = NULL;
    root->right = NULL;
    return root;
}

void InsertTree(TreeNode *root)
{
    int queueFont = 0;
    int queueRear = 0;
    int inputValue;
    TreeNode *tempTree;
    TreeNode *fatherTree;
    treeQueue[queueRear++] = root;
    while (scanf("%d", &inputValue) != EOF) {
        fatherTree = treeQueue[queueFont++];
        if (inputValue >= 0) {
            tempTree = (TreeNode *)malloc(sizeof(TreeNode));
            tempTree->left = NULL;
            tempTree->right = NULL;
            tempTree->val = inputValue;
            fatherTree->left = tempTree;
            treeQueue[queueRear++] = tempTree;
        }

        if (scanf("%d", &inputValue) == EOF) {
            return;
        }
        if (inputValue >= 0) {
            tempTree = (TreeNode *)malloc(sizeof(TreeNode));
            tempTree->left = NULL;
            tempTree->right = NULL;
            tempTree->val = inputValue;
            fatherTree->right = tempTree;
            treeQueue[queueRear++] = tempTree;
        }
    }
}

void DestroyTree(TreeNode *root)
{
    if (root == NULL) {
        return;
    }

    DestroyTree(root->left);
    DestroyTree(root->right);
    free(root);
    root = NULL;
    return;
}

int main()
{
    freopen("test/1.txt", "r", stdin);
    TreeNode *root = CreatTree();
    scanf("%d", &(root->val));
    InsertTree(root);
    printf("%s\n", smallestFromLeaf(root));
    DestroyTree(root);

    freopen("test/2.txt", "r", stdin);
    root = CreatTree();
    scanf("%d", &(root->val));
    InsertTree(root);
    printf("%s\n", smallestFromLeaf(root));
    DestroyTree(root);

    freopen("test/3.txt", "r", stdin);
    root = CreatTree();
    scanf("%d", &(root->val));
    InsertTree(root);
    printf("%s\n", smallestFromLeaf(root));
    DestroyTree(root);

    freopen("test/4.txt", "r", stdin);
    root = CreatTree();
    scanf("%d", &(root->val));
    InsertTree(root);
    printf("%s\n", smallestFromLeaf(root));
    DestroyTree(root);

    system("pause");
    return 0;
}