树（一）：二叉树(BiTree) 创建+销毁+前中后层遍历（递归+非递归）C++

树系列文章：
树（一）：二叉树(BiTree) 创建+销毁+前中后层遍历（递归+非递归）C++

树（二）：线索二叉树(ThreadBiTree) 线索化及其非递归遍历C++

树（三）：二叉排序树（BST） C++实现

树（四）：平衡二叉树(AVL) C++实现

树（五）：哈夫曼树(HuffmanTree) C++实现

---

二叉树图示

以此二叉树为例进行创建：

前序法创建节点,输入’#'表示为NULL

用前序创建的话需要输入 ：ABD##E##C#G##
前序遍历：ABD##E##C#G##
中序遍历：#D#B#E#A#C#G#
后序遍历: ##D##EB###GCA
层序遍历: ABCDEG
这里的’#’ 只是用来方便与区分 NULL，也可以控制程序不进行打印

二叉树完整代码

#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <unistd.h>
using namespace std;

/*****************************二叉树**********************************/
/*****************************类申明**********************************/
struct Node
{
    char data;
    struct Node *left;
    struct Node *right;
    Node(int data = 0) : data(data), left(NULL), right(NULL) {}
};

class BiTree
{
    Node *_root;
    int _i;

public:
    BiTree(const char *s); //前序创建
    ~BiTree();             //后序销毁

    void preTraverse(Node *);              //前序遍历
    void inTraverse(Node *);               //中序遍历
    void postTraverse(Node *);             //后序遍历
    void levelTraverse(Node *);            //层序遍历
    void preTraverse_notRecursion(Node *); //前序遍历非递归
    void inTraverse_notRecursion(Node *);  //中序遍历非递归
    void postTraverse_notRecursion(Node *);  //后序遍历非递归

    Node *getRoot() const { return _root; }

private:
    Node *createBiTree(const char *s); //前序创建二叉树
    void destroyBiTree(Node *);        //后序销毁二叉树
};

/*****************************类成员定义**********************************/
BiTree::BiTree(const char *s)
{
    _i = 0;
    _root = createBiTree(s);
    cout << "BiTree()" << endl;
}

BiTree::~BiTree()
{
    if (_root)
    {
        destroyBiTree(_root);
        cout << "~BiTree()" << endl;
    }
}

void BiTree::destroyBiTree(Node *root)
{
    if (!root)
        return;
    else
    {
        destroyBiTree(root->left);
        destroyBiTree(root->right);
        delete root;
        root = NULL;
    }
}

Node *BiTree::createBiTree(const char *s)
{
    if ('\0' == s[_i])
        return NULL;
    else if ('#' == s[_i])
    {
        _i++;
        return NULL;
    }
    else
    {
        Node *node = new Node(s[_i]);
        _i++;
        node->left = createBiTree(s);
        node->right = createBiTree(s);
        return node;
    }
}

void BiTree::preTraverse(Node *node)
{
    if (!node)
        cout << "#";
    else
    {
        cout << node->data;
        preTraverse(node->left);
        preTraverse(node->right);
    }
}

void BiTree::inTraverse(Node *node)
{
    if (!node)
        cout << "#";
    else
    {
        inTraverse(node->left);
        cout << node->data;
        inTraverse(node->right);
    }
}

void BiTree::postTraverse(Node *node)
{
    if (!node)
        cout << "#";
    else
    {
        postTraverse(node->left);
        postTraverse(node->right);
        cout << node->data;
    }
}

void BiTree::levelTraverse(Node *node)
{
    queue<Node *> que;
    que.push(node);
    while (!que.empty())
    {
        Node *temp = que.front();
        cout << temp->data;
        que.pop();
        if (temp->left)
            que.push(temp->left);
        if (temp->right)
            que.push(temp->right);
    }
}

//先不考虑打印，左右遍历完 , 先分别写出向左的，向右的
void BiTree::preTraverse_notRecursion(Node *root)
{
    stack<Node *> mystack;
    Node *p = root;
    while (p || !mystack.empty())
    {
        //向左
        while (p)
        {
            cout << p->data;
            mystack.push(p);
            p = p->left;
        }

        //向右
        if (!mystack.empty())
        {
            p = mystack.top();
            mystack.pop();
            p = p->right;
        }
    }
}

//先不考虑打印，左右遍历完 , 先分别写出向左的，向右的
void BiTree::inTraverse_notRecursion(Node *root)
{
    stack<Node *> mystack;
    Node *p = root;
    while (p || !mystack.empty())
    {
        //向左
        while (p)
        {
            mystack.push(p);
            p = p->left;
        }

        //向右
        if (!mystack.empty())
        {
            p = mystack.top();
            mystack.pop();
            cout << p->data;
            p = p->right;
        }
    }
}


//后序遍历非递归采用双栈法，依次弹栈
void BiTree::postTraverse_notRecursion(Node* root)
{
    stack<Node*> stack1;
    stack<Node*> stack2;
    stack1.push(root);
    while (!stack1.empty())
    {
        Node* temp = stack1.top();
        stack1.pop();
        if (temp->left)
            stack1.push(temp->left);
        if (temp->right)
            stack1.push(temp->right);
        
        stack2.push(temp);
    }
    
    //打印
    while (!stack2.empty())
    {
        Node* temp = stack2.top();
        stack2.pop();
        cout << temp->data;
    }
}


/*********************************测试程序******************************/

//四种遍历方法 前中后层
void test1()
{
    BiTree tree("ABD##E##C#G##");

    cout << "PreOrder:" << endl;
    tree.preTraverse(tree.getRoot());
    cout << endl;
    tree.preTraverse_notRecursion(tree.getRoot());
    cout << endl;

    cout << "InOrder:" << endl;
    tree.inTraverse(tree.getRoot());
    cout << endl;
    tree.inTraverse_notRecursion(tree.getRoot());
    cout << endl;

    cout << "PostOrder:" << endl;
    tree.postTraverse(tree.getRoot());
    cout << endl;
    tree.postTraverse_notRecursion(tree.getRoot());
    cout << endl;

    cout << "levelOrder:" << endl;
    tree.levelTraverse(tree.getRoot());
    cout << endl;
}

int main()
{
    test1();
    return 0;
}

leetcode二叉树练习

1.leetcode105 前序+中序 序列创建二叉树

#include <iostream>
#include <vector>
using namespace std;
/**
 * Definition for a binary tree node.
 */
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    int findIndex(vector<int>& inorder, int val)
    {
        for (int i = 0; i < inorder.size(); i++)
            if (val == inorder[i])
                return i;
        return -1;
    }

    TreeNode *Build(vector<int> &preorder, vector<int> &inorder, int &i, int l, int r)
    {
        if (l <= r)
        {
            TreeNode *newNode = new TreeNode(preorder[i]);
            int mid = findIndex(inorder, preorder[i]);
            i++;
            newNode->left = Build(preorder, inorder, i, l, mid-1);
            newNode->right = Build(preorder, inorder, i, mid+1, r);
            return newNode;
        }
        else
        {
            return NULL;
        }
    }

    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
    {
        int l = 0, r = preorder.size() - 1;
        int i = 0;
        return Build(preorder, inorder, i, l, r);
    }
};


int main()
{
    vector<int> preorder{3,9,20,15,7};
    vector<int> inorder{9,3,15,20,7};
    Solution s;
    s.buildTree(preorder, inorder);
    return 0;
}

2.leetcode106 后序+中序 序列创建二叉树

#include <iostream>
#include <vector>
using namespace std;
/**
 * Definition for a binary tree node.
 */
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    int findIndex(vector<int> &inorder, int val)
    {
        for (int i = 0; i < inorder.size(); i++)
            if (val == inorder[i])
                return i;
        return -1;
    }

    TreeNode *Build(vector<int> &preorder, vector<int> &inorder, int &i, int l, int r)
    {
        if (l <= r && i>=0)
        {
            TreeNode *newNode = new TreeNode(preorder[i]);
            int mid = findIndex(inorder, preorder[i]);
            i--;
            newNode->right = Build(preorder, inorder, i, mid + 1, r);
            newNode->left = Build(preorder, inorder, i, l, mid - 1);
            return newNode;
        }
        else
        {
            return NULL;
        }
    }

    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder)
    {
        int l = 0, r = postorder.size() - 1;
        int i = r;
        return Build(postorder, inorder, i, l, r);
    }
};

int main()
{
    vector<int> preorder{3, 9, 20, 15, 7};
    vector<int> inorder{9, 3, 15, 20, 7};
    Solution s;
    s.buildTree(preorder, inorder);
    return 0;
}