树的遍历等操作

#include<iostream>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :data(x), left(NULL), right(NULL) {}
};
class Btree
{
    static int n;
    static int m;
public:
    TreeNode *root;
    Btree()
    {
        root = NULL;
    }
    void create_Btree(int);                     //二叉排序树的方式建树
    //void create_Btree1(int);                    //先序遍历的方式建树
    void BreadthFirstSearch(TreeNode *);              //层次遍历（广度优先遍历）
    void DepthFirstSearch(TreeNode *);              //深度遍历（深度优先遍历）
    void Preorder(TreeNode *);                  //先序遍历
    void inorder(TreeNode *);                   //中序遍历
    void Postorder(TreeNode *);                 //后序遍历
    void preOrderTravel(TreeNode* root);  //非递归先序遍历
    void inorderTravel(TreeNode* root);   //非递归中序遍历
    void postOrderTravel(TreeNode* root); //非递归后序遍历
    void display1() { Preorder(root); cout << endl; }
    void display2() { inorder(root); cout << endl; }
    void display3() { Postorder(root); cout << endl; }
    void display4() { BreadthFirstSearch(root); cout << endl; }
    void display5() { DepthFirstSearch(root); cout << endl; }
    void display6() { preOrderTravel(root); cout << endl; }
    void display7() { inorderTravel(root); cout << endl; }
    void display8() { postOrderTravel(root); cout << endl; }
    int count(TreeNode *);                      //计算二叉树的个数
    int findleaf(TreeNode *);                   //求二叉树叶子的个数
    int findnode(TreeNode *);                   //求二叉树中度数为1的结点数量,这是当初考数据结构时候的最后一道题目
};
int Btree::n = 0;
int Btree::m = 0;
void Btree::create_Btree(int x)              //二叉排序树的方式建树
{
    TreeNode *newnode = new TreeNode(x);
    if (root == NULL)
        root = newnode;
    else
    {
        TreeNode *back = NULL;
        TreeNode *current = root;
        while (current != NULL)
        {
            back = current;
            if (current->data>x)
                current = current->left;
            else
                current = current->right;
        }
        if (back->data>x)
            back->left = newnode;
        else
            back->right = newnode;
    }
}
//void Btree::create_Btree1(int x)              //先序遍历的方式建树
//{
//    TreeNode *newnode = new TreeNode(x);
//    if (root == NULL)
//        root = newnode;
//}
void Btree::BreadthFirstSearch(TreeNode *temp)              //层次遍历
{
    if (temp == NULL)
        return;
    queue<TreeNode*> treenode;
    treenode.push(temp);
    while (treenode.size())
    {
        TreeNode *pNode = treenode.front();
        treenode.pop();
        cout << pNode->data << " ";
        if (pNode->left) treenode.push(pNode->left);
        if (pNode->right) treenode.push(pNode->right);
    }
}
void Btree::DepthFirstSearch(TreeNode * temp)          // 深度优先遍历
{
    if (temp == NULL)
        return;
    stack<TreeNode*> nodeStack;
    nodeStack.push(root);
    while (nodeStack.size())
    {
        TreeNode *pNode = nodeStack.top();
        cout << pNode->data << " ";
        nodeStack.pop();
        if (pNode->right)
        {
            nodeStack.push(pNode->right);
        }
        if (pNode->left)
        {
            nodeStack.push(pNode->left);
        }
    }
}
int Btree::count(TreeNode *p)
{
    if (p == NULL)
        return 0;
    else
        return count(p->left) + count(p->right) + 1;      //这是运用了函数嵌套即递归的方法。
}
void Btree::Preorder(TreeNode *temp)    //这是先序遍历二叉树，采用了递归的方法。
{
    if (temp != NULL)
    {
        cout << temp->data << " ";
        Preorder(temp->left);
        Preorder(temp->right);
    }
}
void Btree::preOrderTravel(TreeNode* root){       //这是先序遍历二叉树，采用了非递归的方法。

    vector<int> res;
    if (root == NULL)
        cout << 0 << endl;  //return res;
    stack<TreeNode*> s;
    while (root || !s.empty()){

        while (root){
            res.push_back(root->data);
            s.push(root);
            root = root->left;
        }
        root = s.top();
        s.pop();
        root = root->right;

    }
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
}
void Btree::inorder(TreeNode *temp)      //这是中序遍历二叉树，采用了递归的方法。
{
    if (temp != NULL)
    {
        inorder(temp->left);
        cout << temp->data << " ";
        inorder(temp->right);
    }
}
void Btree::inorderTravel(TreeNode* root){     //这是中序遍历二叉树，采用了非递归的方法。

    vector<int> res;
    if (root == NULL)
        cout << 0 << endl;//return res;
    stack<TreeNode*>s;
    while (root || !s.empty()){

        while (root){
            s.push(root);
            root = root->left;
        }
        root = s.top();
        s.pop();
        res.push_back(root->data);
        root = root->right;
    }
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
}
void Btree::Postorder(TreeNode *temp)     //这是后序遍历二叉树，采用了递归的方法。
{
    if (temp != NULL)
    {
        Postorder(temp->left);
        Postorder(temp->right);
        cout << temp->data << " ";
    }
}
void Btree::postOrderTravel(TreeNode* root)    //这是后序遍历二叉树，采用了非递归的方法。
{     
        vector<int> res;
        if (root == NULL)
            cout << 0 << endl;//return res;
        stack<TreeNode*> s;
        s.push(root);
        TreeNode* head = root;
        while (!s.empty()){
            TreeNode* t = s.top();
            if (!t->left&&!t->right || t->left == head || t->right == head){
                res.push_back(t->data);
                s.pop();
                head = t;
            }
            else{
                if (t->right)s.push(t->right);
                if (t->left)s.push(t->left);
            }
        }
        for (int i = 0; i < res.size(); i++)
        {
            cout << res[i] << " ";
        }
}

int Btree::findleaf(TreeNode *temp)
{
    if (temp == NULL)return 0;
    else
    {
        if (temp->left == NULL&&temp->right == NULL)return n += 1;
        else
        {
            findleaf(temp->left);
            findleaf(temp->right);
        }
        return n;
    }
}
int Btree::findnode(TreeNode *temp)
{
    if (temp == NULL)return 0;
    else
    {
        if (temp->left != NULL&&temp->right != NULL)
        {
            findnode(temp->left);
            findnode(temp->right);
        }
        if (temp->left != NULL&&temp->right == NULL)
        {
            m += 1;
            findnode(temp->left);
        }
        if (temp->left == NULL&&temp->right != NULL)
        {
            m += 1;
            findnode(temp->right);
        }
    }
    return m;
}


int main()
{
    Btree A;
    int array[] = { 7, 4, 2, 3, 15, 35, 6, 45, 55, 20, 1, 14, 56, 57, 58 };
    int k;
    k = sizeof(array) / sizeof(array[0]);
    cout << "建立排序二叉树顺序: " << endl;
    for (int i = 0; i<k; i++)
    {
        cout << array[i] << " ";
        A.create_Btree(array[i]);
    }
    cout << endl;
    cout << "二叉树节点个数： " << A.count(A.root) << endl;
    cout << "二叉树叶子个数：" << A.findleaf(A.root) << endl;
    cout << "二叉树中度数为1的结点的数量为：" << A.findnode(A.root) << endl;
    cout << endl << "深度遍历序列: " << endl;
    A.display5();
    cout << endl << "层次遍历序列: " << endl;
    A.display4();
    cout << endl << "先序遍历序列: " << endl;
    A.display1();
    cout << endl << "中序遍历序列: " << endl;
    A.display2();
    cout << endl << "后序遍历序列: " << endl;
    A.display3();
    cout << endl << "先序非递归遍历：" << endl;
    A.display6();
    cout << endl << "中序非递归遍历：" << endl;
    A.display7();
    cout << endl << "后序非递归遍历：" << endl;
    A.display8();
    system("pause");
    return 0;
}

参考：http://www.cnblogs.com/zhangbaochong/p/5492877.html

https ://zhidao.baidu.com/question/1176347680995216059.html

http ://blog.csdn.net/langmanqishizaijia/article/details/51106870