Question

我要做的是，使用提供的二叉树，计算每个节点密钥的最低可能值，同时保持树结构完整。因此，根据我的理解，密钥应转换为0,1,2,3,4等。

示例：

原始树连接

7 -- 5
7 -- 15
5 -- 2
15 -- 10
15 -- 21
10 -- 9
10 -- 13

预期连接：

2 -- 1
2 -- 6
1 -- 0
6 -- 4
6 -- 7
4 -- 3
4 -- 5

代码的目的是将每个键的最小值与键一起打印。树不需要自己更改。

完整的代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int key;
    struct TreeNode* lChild;
    struct TreeNode* rChild;
} node;

// the following is test code
node *createTree(int key) {

    node *root = malloc(sizeof(node));

    root->key = key;
    root->lChild = NULL;
    root->rChild = NULL;

    return(root);

}

void insert(node *root, int key) {

    if (root->key == -1)
        root->key = key;

    else if (key < root->key) {

        if (root->lChild != NULL)
            insert(root->lChild, key);

        else {
            root->lChild = malloc(sizeof(node));
            root->lChild->key = key;
            root->lChild->lChild = NULL;
            root->lChild->rChild = NULL;
        }
    }

    else if (key > root->key) {

        if (root->rChild != NULL)
            insert(root->rChild, key);

        else {
            root->rChild = malloc(sizeof(node));
            root->rChild->key = key;
            root->rChild->lChild = NULL;
            root->rChild->rChild = NULL;
        }
    }

}

void printNode(node *root) {

    if (root->lChild != NULL) {

        printf("%d -- %d\n", root->key, root->lChild->key);

        if (root->rChild != NULL)
            printf("%d -- %d\n", root->key, root->rChild->key);

        printNode(root->lChild);
    }

    if (root->rChild != NULL) {

        if (root->lChild == NULL)
            printf("%d -- %d\n", root->key, root->rChild->key);

        printNode(root->rChild);
    }
}

void printTree(node *root) {

    printf("graph g {\n");

    printNode(root);

    printf("}\n");

}
//test code ends here

node *treeMin(node *root) {

    if (root->lChild != NULL)
        root = treeMin(root->lChild);

    return root;
}

node *treeSearch(node *root, int key) {

    if (root == NULL && root->key != key) {

        if (key < root->key)
            return treeSearch(root->lChild, key);

        else
            return treeSearch(root->rChild, key);
    }
}

node* succAbove(node* root, node* x) {

    node* succ;
    succ = NULL;

    while (root != x) {

        if (x->key < root->key) {
            succ = root;
            root = root->lChild;
        }


        else if (x->key > root->key)
            root = root->rChild;
    }

    return succ;
}

node *treeSucc(node *root) {

    if (root->rChild != NULL)
        return treeMin(root->rChild);

    node *parent = succAbove(root, treeMin(root));

    while (parent != NULL && root == parent->rChild) {

        root = parent;
        parent = succAbove(root, parent);
    }

    return parent;
}

void printMinKey(int key, int minPosKey) {
    printf("%d - %d\n", key, minPosKey);
}

int minKey(node *root, int count) {

    // as long as the parent node exists
    if (treeSucc(root) != NULL) {
        printMinKey(treeSucc(root)->key, ++count);
        minKey(treeSucc(root), count);
    }

}

void test() {

    node *root1 = createTree(-1);

    insert(root1, 7);
    insert(root1, 5);
    insert(root1, 15);
    insert(root1, 2);
    insert(root1, 10);
    insert(root1, 21);
    insert(root1, 9);
    insert(root1, 13);
    printTree(root1);

    printMinKey(treeMin(root1)->key, 0);

    minKey(root1, 0);

}

int main() {
    test();
}

输出结果为：

graph g {
7 -- 5
7 -- 15
5 -- 2
15 -- 10
15 -- 21
10 -- 9
10 -- 13
}
2 - 0
9 - 1

Process returned 0 (0x0)   execution time : 0.260 s
Press any key to continue.

我构建此代码的方式来自我从课堂上获得的各种摘录和材料。我不确定我是否正确连接它们。特别是succAbove() treeSucc()中的treeSearch()来电，我确信这是错误的，但我不确定要使用什么。

succAbove()，count等的想法。据我所知，它不需要将父指针添加到原始结构中。

minKey()中minKey()的想法是，它允许我轻松获取minPossibleKey，因为它在treeSucc()和2 - 0 5 - 1 7 - 2 9 - 3 10 - 4 13 - 5 15 - 6 21 - 7点的每次递归中都会增加继承人是下一个最低价值。我完全不确定我的思维过程是否正确。

练习中不需要标记为测试代码的部分，但旨在帮助我了解其他代码是否有效。

预期输出为：

{{1}}

为每个二叉树节点搜索minPossibleKey的问题

0 个答案: