Перевод программы с языка C++ на язык C - C (СИ)

Узнай цену своей работы

Формулировка задачи: 

#include <iostream>
#include <set>
#include <cmath>
 
struct BNode
{
    int key;
    BNode* left;
    BNode* right;
    BNode* parent;
};
 
BNode* global_root = 0;
bool state = false;
std::set<int> table;
 
static double curr_node = 0;
static double curr_line = 1;
 
unsigned get_line()
{
    ++curr_node;
    if ((pow(curr_node, 1/(curr_line))) == 2.0)
    {
        ++curr_line;
    }
    return curr_line;
}
 
void put_node(BNode* root, int key, int depth)
{
 
    if (!state)
    {
        state = true;
        get_line();
    }
 
    if (curr_line == 1)
    {
        global_root = new BNode;
        global_root->left = global_root->right = 0;
        global_root->parent = global_root;
        global_root->key = key;
        return;
    }
 
    if (depth >= curr_line)
    {
        return;
    }
 
    if (!root->left)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end())
        {
            root->left = new BNode;
            root->left->left = root->left->right = 0;
            root->left->parent = root;
            root->left->key = key;
            table.insert(key);
            return;
        }
    }
 
    if (!root->right)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end() && depth < curr_line)
        {
            root->right = new BNode;
            root->right->left = root->right->right = 0;
            root->right->parent = root;
            root->right->key = key;
            table.insert(key);
            return;
        }
    }
 
    if (root->left)
    {
        put_node(root->left, key, depth+1);
    }
 
    if (root->right)
    {
        put_node(root->right, key, depth+1);
    }
}
 
void show_tree(BNode* root, int lvl)
{
    if (!root)
    {
        return;
    }
    std::cout << "lvl: " << lvl << "; key: " << root->key << std::endl;
    show_tree(root->left, lvl + 1);
    show_tree(root->right, lvl + 1);
}
 
int main()
{
    put_node(global_root, 4, 1); state = false;
    put_node(global_root, 2, 1); state = false;
    put_node(global_root, 6, 1); state = false;
    put_node(global_root, 1, 1); state = false;
    put_node(global_root, 3, 1); state = false;
    put_node(global_root, 5, 1); state = false;
    put_node(global_root, 7, 1); state = false;
    show_tree(global_root, 1);
}
Что смог я уже перевел, осталось совсем чуть-чуть. 
#include <stdio.h>
#include<malloc.h>
 
typedef enum{false,true}bool;
 
typedef struct BNode
{
    int key;
    struct BNode* left;
    struct BNode* right;
    struct BNode* parent;
}BNode;
 
BNode* global_root = 0;
bool state = false;
set <int> table;
 
static double curr_node = 0;
static double curr_line = 1;
 
unsigned get_line()
{
    ++curr_node;
    if ((pow(curr_node, 1/(curr_line))) == 2.0)
    {
        ++curr_line;
    }
    return curr_line;
}
 
void put_node(BNode* root, int key, int depth)
{
    int i;
    if (!state)
    {
        state = true;
        get_line();
    }
 
    if (curr_line == 1)
    {
        global_root = (BNode*)malloc(sizeof(BNode));
        global_root->left = global_root->right = 0;
        global_root->parent = global_root;
        global_root->key = key;
        return;
    }
 
    if (depth >= curr_line)
    {
        return;
    }
 
    if (!root->left)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end())
        {
            root->left=(BNode*)malloc(sizeof(BNode));
            root->left->left = root->left->right = 0;
            root->left->parent=root;
            root->left->key=key;
            table.insert(key);
            return;
        }
    }
 
    if (!root->right)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end() && depth < curr_line)
        {
            root->right = (BNode*)malloc(sizeof(BNode));
            root->right->left = root->right->right = 0;
            root->right->parent = root;
            root->right->key = key;
            table.insert(key);
            return;
        }
    }
 
    if (root->left)
    {
        put_node(root->left, key, depth+1);
    }
 
    if (root->right)
    {
        put_node(root->right, key, depth+1);
    }
}
 
void show_tree(BNode* root, int lvl)
{
    if (!root)
    {
        return;
    }
    printf("lvl: %d; lvl: %d\n", lvl, root->key);
    show_tree(root->left, lvl + 1);
    show_tree(root->right, lvl + 1);
}
 
int main()
{
    put_node(global_root, 4, 1); state = false;
    put_node(global_root, 2, 1); state = false;
    put_node(global_root, 6, 1); state = false;
    put_node(global_root, 1, 1); state = false;
    put_node(global_root, 3, 1); state = false;
    put_node(global_root, 5, 1); state = false;
    put_node(global_root, 7, 1); state = false;
    show_tree(global_root, 1);
    return 0;
}
Посмотрите я перевел все без ошибок, но ответ выводит не правильно 
#include <stdio.h>
#include<malloc.h>
 
typedef enum{false,true}bool;
 
typedef struct BNode
{
    int key;
    struct BNode* left;
    struct BNode* right;
    struct BNode* parent;
}BNode;
 
BNode* global_root = 0;
bool state = false;
int mas[1000];
 
static double curr_node = 0.0;
static double curr_line = 1.0;
static double c = 0.0;
static double b = 0.0;
double pow(double curr_node,double b);
 
unsigned get_line()
{
    ++curr_node;
    b=1.0/(curr_line);
    c=pow(curr_node, b);
    if(c==2.0)
    {
        ++curr_line;
    }
    return curr_line;
}
 
void put_node(BNode* root, int key, int depth)
{
    static int i;
    if (!state)
    {
        state = true;
        get_line();
    }
 
    if (curr_line == 1)
    {
        global_root = (BNode*)malloc(sizeof(BNode));
        global_root->left = global_root->right = 0;
        global_root->parent = global_root;
        global_root->key = key;
        return;
    }
 
    if (depth >= curr_line)
    {
        return;
    }
 
    if (!root->left)
    {
        if (mas[i]==key)
        {
            root->left=(BNode*)malloc(sizeof(BNode));
            root->left->left = root->left->right = 0;
            root->left->parent=root;
            root->left->key=key;
            ++i;
            mas[i]=key;
            return;
        }
    }
 
    if (!root->right)
    {
        if (mas[i]==key && depth < curr_line)
        {
            root->right = (BNode*)malloc(sizeof(BNode));
            root->right->left = root->right->right = 0;
            root->right->parent = root;
            root->right->key = key;
            ++i;
            mas[i]=key;
            return;
        }
    }
 
    if (root->left)
    {
        put_node(root->left, key, depth+1);
    }
 
    if (root->right)
    {
        put_node(root->right, key, depth+1);
    }
}
 
void show_tree(BNode* root, int lvl)
{
    if (!root)
    {
        return;
    }
    printf("lvl: %d; lvl: %d\n", lvl, root->key);
    show_tree(root->left, lvl + 1);
    show_tree(root->right, lvl + 1);
}
 
int main()
{
    put_node(global_root, 4, 1); state = false;
    put_node(global_root, 2, 1); state = false;
    put_node(global_root, 6, 1); state = false;
    put_node(global_root, 1, 1); state = false;
    put_node(global_root, 3, 1); state = false;
    put_node(global_root, 5, 1); state = false;
    put_node(global_root, 7, 1); state = false;
    show_tree(global_root, 1);
    return 0;
}

Решение задачи: «Перевод программы с языка C++ на язык C»

textual
Листинг программы 
#include <stdio.h>
#include <set>
#include <math.h>
#include<malloc.h>
 
typedef enum{f,t}d;
 
typedef struct BNode
{
    int key;
    struct BNode* left;
    struct BNode* right;
    struct BNode* parent;
}BNode;
 
BNode* global_root = 0;
d state = f;
std::set<int> table;
 
double curr_node = 0;
double curr_line = 1;
 
int get_line()
{
    ++curr_node;
    if ((pow(curr_node, 1/(curr_line))) == 2.0)
    {
        ++curr_line;
    }
    return curr_line;
}
 
BNode *put_node(BNode* root, int key, int depth)
{
 
    if (!state)
    {
        state = t;
        get_line();
    }
 
    if (curr_line == 1)
    {
        global_root = (BNode*)malloc(sizeof(BNode));
        global_root->left = global_root->right = 0;
        global_root->parent = global_root;
        global_root->key = key;
        return global_root;
    }
 
    if (depth >= curr_line)
    {
        return global_root;
    }
 
    if (!root->left)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end())
        {
            root->left = (BNode*)malloc(sizeof(BNode));
            root->left->left = root->left->right = 0;
            root->left->parent = root;
            root->left->key = key;
            table.insert(key);
            return global_root;
        }
    }
 
    if (!root->right)
    {
        std::set<int>::iterator i = table.find(key);
        if (i == table.end() && depth < curr_line)
        {
            root->right = (BNode*)malloc(sizeof(BNode));
            root->right->left = root->right->right = 0;
            root->right->parent = root;
            root->right->key = key;
            table.insert(key);
            return global_root;
        }
    }
 
    if (root->left)
    {
        put_node(root->left, key, depth+1);
    }
 
    if (root->right)
    {
        put_node(root->right, key, depth+1);
    }
    return global_root;
}
 
BNode *show_tree(BNode* root, int lvl)
{
    if (!root)
    {
        return global_root;
    }
    printf("lvl: %d; key: %d\n", lvl, root->key);
    show_tree(root->left, lvl + 1);
    show_tree(root->right, lvl + 1);
    return global_root;
}
 
int main()
{
    global_root=put_node(global_root, 1, 1); state = f;
    global_root=put_node(global_root, 2, 1); state = f;
    global_root=put_node(global_root, 3, 1); state = f;
    global_root=put_node(global_root, 4, 1); state = f;
    global_root=put_node(global_root, 5, 1); state = f;
    global_root=put_node(global_root, 6, 1); state = f;
    global_root=put_node(global_root, 7, 1); state = f;
    global_root=show_tree(global_root, 1);
    return 0;
}

Объяснение кода листинга программы

  1. Объявлены переменные:
    • global_root (указатель на узел)
    • state (флаг типа enum)
    • table (множество для хранения ключей)
    • curr_node (текущий номер узла)
    • curr_line (текущая линия для построения дерева)
    • get_line (функция для получения следующего номера узла)
    • put_node (функция для добавления узла в дерево)
    • show_tree (функция для вывода дерева на экран)
    • main (основная функция программы)
  2. В функции main создаются первые узлы и вызывается функция show_tree для вывода дерева на экран.
  3. В функции get_line вычисляется следующий номер узла, используя формулу pow(curr_node, 1/(curr_line)). Если результат равен 2.0, то увеличивается curr_line.
  4. В функции put_node выполняется следующие действия:
    • Если state равно f, то устанавливается значение state равным t.
    • Если curr_line равно 1, то создается новый узел и добавляется в дерево.
    • Если depth больше или равно curr_line, то выполняется рекурсивный вызов функции put_node для правого поддерева.
    • Если узел с ключом key уже есть в дереве, то выполняется рекурсивный вызов функции put_node для левого поддерева.
    • Если узел с ключом key не найден в дереве и depth меньше curr_line, то создается новый узел и добавляется в дерево.
    • Если узел с ключом key не найден в дереве и depth равно curr_line, то выполняется рекурсивный вызов функции put_node для правого поддерева.
  5. В функции show_tree выводится информация о каждом узле дерева.
  6. В основной функции программы вызывается функция main.

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

9   голосов , оценка 4 из 5
Похожие ответы