二叉树的一些操作

二叉树的一些操作

/*
 * https://blog.csdn.net/alxe_made/article/details/94721195
 */

#include <iostream>
#include <array>
#include <vector>
#include <stack>

using namespace std;

class Node
{
public:
    int value;
    Node* left;
    Node* right;
};

Node* newNode(int value)
{
    Node* node = new Node;
    node->value = value;
    node->left = nullptr;
    node->right = nullptr;
    return node;
}

Node* createTree(Node* tree, int value)
{
    if (tree == nullptr)
        tree = newNode(value);
    else
    {
        if (value > tree->value)
            tree->right = createTree(tree->right, value);
        if (value < tree->value)
            tree->left = createTree(tree->left, value);
    }

    return tree;
}

// root -> left ->right
void preorder(Node* tree)
{
    if (tree != nullptr)
    {
        cout << tree->value << " ";
        preorder(tree->left);
        preorder(tree->right);
    }
}

void inorder(Node* tree)
{
    if (tree != nullptr)
    {
        inorder(tree->left);
        cout << tree->value << " ";
        inorder(tree->right);
    }
}

void postorder(Node* tree)
{
    if (tree != nullptr)
    {
        inorder(tree->left);
        inorder(tree->right);
        cout << tree->value << " ";
    }
}

void inorderUnrecur(Node* tree)
{
    stack<Node*> s;
    Node* t = tree;
    while(!s.empty() || t != nullptr)
    {
        if (t != nullptr)
        {
            s.push(t);
            t = t->left;
        }
        else
        {
            t = s.top();
            cout << t->value << " ";
            s.pop();
            t = t->right;
        }
    }
}

void preorderUnrecur(Node* tree)
{
    stack<Node*> s;
    Node* t = tree;
    s.push(t);
    while(!s.empty())
    {
        t = s.top();
        cout << t->value << " ";
        s.pop();
        if (t->right)
            s.push(t->right);
        if (t->left)
            s.push(t->left);
    }
}

void postorderUnrecur(Node* tree)
{
    stack<Node*> s1, s2;
    Node* t = tree;
    s1.push(t);
    while (!s1.empty())
    {
        t = s1.top();
        s2.push(t);
        s1.pop();
        if (t->left)
            s1.push(t->left);
        if (t->right)
            s1.push(t->right);
    }
    while(!s2.empty())
    {
        cout << s2.top()->value << " ";
        s2.pop();
    }
}

void printLeaves(Node* tree)
{
    Node* t = tree;
    if (tree)
    {
        if (tree->left == nullptr && tree->right == nullptr)
            cout << tree->value << " ";
        printLeaves(tree->left);
        printLeaves(tree->right);
    }
}

int getTreeHeight(Node* tree)
{
    int HL, HR, MAXH;
    if (tree)
    {
        HL = getTreeHeight(tree->left);
        HR = getTreeHeight(tree->right);
        MAXH = HL > HR ? HL : HR;
        return MAXH + 1;
    }
    return 0;
}

Node* buildTreeWithPreInOrder(int* pre, int* in, int num)
{
    if (num == 0)
        return nullptr;
    int root = pre[0];
    int i = 0;
    while (in[i] != root)
        i++;
    int leftLength = i;
    int rightLength = num - 1 - i;
    Node* node = newNode(root);
    node->left = buildTreeWithPreInOrder(&pre[1], &in[0], leftLength);
    node->right = buildTreeWithPreInOrder(&pre[1 + leftLength], &in[leftLength + 1], rightLength);
    return node;
}

int main_()
{
    int N;
    cin >> N;
    int value;
    cin >> value;
    Node* tree = newNode(value);
    for (int i = 0; i < N - 1; i++)
    {
        cin >> value;
        tree = createTree(tree, value);
    }

    // preorder
    preorder(tree);
    cout << endl;
    inorder(tree);
    cout << endl;
    postorder(tree);
    cout << endl;

    // non-recursive: inorder
    preorderUnrecur(tree);
    cout << endl;
    inorderUnrecur(tree);
    cout << endl;
    postorderUnrecur(tree);
    cout << endl;

    printLeaves(tree);
    cout << endl;
    int height = getTreeHeight(tree);
    cout << height << endl;

    // build a tree with preorder and in order
    int a1[4]{3, 2, 1, 4};
    int a2[4]{1, 2, 3, 4};
    Node* tree1 = buildTreeWithPreInOrder(a1, a2, 4);
    cout << endl;
    preorder(tree1);
    cout << endl;
    inorder(tree1);
    cout << endl;
    postorder(tree1);

}