Урок 2-2 умный указатель

#include <cassert>
#include <iostream>
#include <memory>

template <typename T>
struct TreeNode;

template <typename T>
using TreeNodePtr = std::unique_ptr<TreeNode<T>>;

template <typename T>
struct TreeNode {
    TreeNode(T val, TreeNodePtr<T>&& left, TreeNodePtr<T>&& right)
        : value(std::move(val))
        , left(std::move(left))
        , right(std::move(right)) {
    }

    T value;
    TreeNodePtr<T> left;
    TreeNodePtr<T> right;
    TreeNode* parent = nullptr;
};

template <typename T>
bool CheckTreeProperty(const TreeNode<T>* node) noexcept {
     int leftznac = 0;
    int rightznac = 0;

    // return if the tree is empty
       if (node == nullptr) {
           return true;
       }

    auto left  = node->left.get();
    if (left) {
        leftznac = left->value;
    if (leftznac > node->value || !CheckTreeProperty(left)) {
        return false;
    }
    }
    auto right = node->right.get();

    if (right) {
        rightznac = right->value;
        if (rightznac < node->value || !CheckTreeProperty(right)) {
            return false;
    }
     }
    return true;

  }



template <typename T>
TreeNode<T>* begin(TreeNode<T>* node) noexcept {
    if (node != nullptr){

    while (node->left.get()){
        node =node->left.get();
    }
    return node;
  }
  return nullptr;


//    while(node->left) {
//          node = node->left;
//      }
//      return node;

}

template <typename T>
TreeNode<T>* next(TreeNode<T>* node) noexcept {
    if (node->right != nullptr) {
        node = node->right.get();
        while (node->left != nullptr) {
            node = node->left.get();
        }
    }
    else {
        if(node->parent == nullptr) return nullptr;
        while (node->parent != nullptr) {

            if (node->parent->right.get() == node) {
                node = node->parent;
                if (node->parent == nullptr) {
                    return nullptr;
                }
            }
            else {
                return node->parent;
            }
        }
    }
    return node;
}


// функция создаёт новый узел с заданным значением и потомками
TreeNodePtr<int> N(int val, TreeNodePtr<int>&& left = {}, TreeNodePtr<int>&& right = {}) {


    auto new_node =  TreeNode<int>({std::move(val), std::move(left), std::move(right)});


    auto result = std::make_unique<TreeNode<int>>(std::move(new_node));

    auto z = result.get();


    if (z->left.get()) {
        auto l = z->left.get();
       l->parent = z;
    }
    if (z->right.get()) {
        auto r = z->right.get();
       r->parent = z;
     }


    return result;





}

int main() {
    using namespace std;
    using T = TreeNode<int>;
    auto root1 = N(6, N(4, N(3), N(5)), N(7));

    assert(CheckTreeProperty(root1.get()));

    T* iter = begin(root1.get());
    while (iter) {
        cout << iter->value << " "s;
        iter = next(iter);
        cout << endl;
    }
    cout << endl;

    auto root2 = N(6, N(4, N(3), N(5)), N(7, N(8)));
    assert(!CheckTreeProperty(root2.get()));

    // Функция DeleteTree не нужна. Узлы дерева будут рекурсивно удалены
    // благодаря деструкторам unique_ptr
}