Функция двоичных деревьев

Question

Может кто-нибудь объяснить результат вызова mystery(root) в двоичном дереве ниже?

struct treenode {
  int data;
  struct treenode* left;
  struct treenode* right;
}

void mystery(struct treenode* root) {
  if (root == NULL) return;
  mystery(root->right);
  printf("%d ", root->data%25);
  mystery(root->left);
}

Дерево:

       35
    /      \
  23       17
 /  \     /
89  135  56
        /   \
       44    89
              \
              74
             /
            287     

Answer 1

Я думаю, что это будет 17 24 12 14 6 19 10 10 23 14

Редактировать: фиксированный интервал.

Answer 2

См. Ниже след:

You call mystery(35)
the root is not null which calls mystery(17)
    mystery(17) is not null and calls mystery(17-Right)
        This is null so it Returns
    printf(17%25 == 17)
    call mystery(56)
        mystery(56) is not null and calls mystery(89)
            mystery(89) is not null and calls mystery(74)
                    mystery(74) is not null and calls mystery(74-Right)
                    mystery(74-Right) is null; return;
                printf(74%25 == 24)
                mystery(74) calls mystery(287)
                    printf(287%25 == 12)
                printf(89%25 == 14)
        printf(56%25 == 6)
        mystery(56) calls mystery(44)
                mystery(44) has no right or left child
                printf(44%25 == 19)
printf(35%25 == 10)
root calls mystery(23)
    mystery(23) calls mystery(135)
        printf(135%25 == 10)
    printf(23%25 == 23)
    mystery(23) calls mystery(89)
        printf(89%25 == 14)

Answer 3

Используя следующий код, я получаю:

17 24 12 14 6 19 10 10 23 14

void makenode(struct treenode **n, int val) {
    *n = malloc(sizeof(struct treenode));
    (*n)->left = (*n)->right = 0;
    (*n)->data = val;
}

int main() {
    struct treenode *root;
    makenode(&root, 35);
    makenode(&root->left, 23);
    makenode(&root->right, 17);
    makenode(&root->left->left, 89);
    makenode(&root->left->right, 135);

    makenode(&root->right->left, 56);
    makenode(&root->right->left->left, 44);
    makenode(&root->right->left->right, 89);

    makenode(&root->right->left->right->right, 74);
    makenode(&root->right->left->right->right->left, 287);

    mystery(root);
    return 0;
}

Answer 4

Нет, эта функция не может обеспечить такой результат для этого дерева. 17 24 12 14 6 19 10 10 23 14

Answer 5

17,24,12,14,6,19,10,10,23,14 - правильный вывод

Answer 6

Это не правильно.Этот обход называется inorder Первые 17 верны, так как 17% 25 = 17, следующие должны быть 24, поскольку 74% 25 = 24

Кажется, что функция в порядке, возможно, изображенное деревоне верно.