二叉树操作（插入、删除、遍历（递归与非递归））

最新推荐文章于 2020-08-10 14:08:28 发布
最新推荐文章于 2020-08-10 14:08:28 发布
阅读量494 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013994536/article/details/50674202
版权

//genBST.h

#ifndef GENBST_H_INCLUDED
#define GENBST_H_INCLUDED


#include <queue>
#include <stack>


using namespace std;


template <class T>
class Stack:public stack<T>{};


template <class T>
class Queue:public queue<T>{
public:
    T dequeue(){
        T tmp = this->front();
        queue<T>::pop();
        return tmp;
    }


    void enqueue(const T& el){
        this->push(el);
    }
};


template <class T>
class BSTNode{
public:
    BSTNode(){
        left = right = 0;
    }


    BSTNode(const T&e,BSTNode<T> * l=0,BSTNode<T>*r=0){
        el = e;left =l;right =r;
    }
    T el;
    BSTNode<T> *left,*right;
};




template <class T>
class BST{
public:
    BST(){
        root = 0;
    }
    ~BST(){
        clear();
    }


    void clear(){
        clear(root);root = 0;
    }


    bool isEmpty()const{
        return root==0;
    }


    bool isBalance(){
        return isBalance(root);
    }
    bool isComplate(){
        return isComplate(root);
    }
    bool isBinarySort(){
        return isBST(root);
    }


    void preorder(){
        preorder(root);
    }


    void inorder(){
        inorder(root);
    }


    void postorder(){
        postorder(root);
    }


    T *search(const T& el)const{
        return search(root,el);
    }


    int pointNum(){
        return pointNum(root);
    }
    int leafNum(){
        return leafNum(root);
    }
    int rightNum(){
        return rightNum(root);
    }
    int deep(){
        return deep(root);
    }
    void makefree(){
        makefree(root);
    }
    void breadthFirst();
    void iterativePreorder();
    void iterativeInorder();
    void iterativePostorder();
    void iterInorder();
    void MorrisInorder();
    void insert(const T&);
    void deleteByMerging(BSTNode<T>*&);
    void findAndDeleteByMerging(const T&);
    void deleteByCopying(BSTNode<T>*&);
    void findAndDeleteByCopying(const T&);
    void balance(T*,int,int);




protected:
    BSTNode<T> * root;
    void clear(BSTNode<T>*);
    T*search(BSTNode<T>*,const T&)const;
    void preorder(BSTNode<T>*);
    void inorder(BSTNode<T>*);
    void postorder(BSTNode<T>*);
    void makefree(BSTNode<T>*);
    int pointNum(BSTNode<T>*);
    int leafNum(BSTNode<T>*);
    int rightNum(BSTNode<T>*);
    int deep(BSTNode<T>*);
    virtual void visit(BSTNode<T>*p){
        cout<<p->el<<" ";
    }
    bool isBalance(BSTNode<T>*);//递归判断是否是平衡二叉树,多次遍历
    bool isComplate(BSTNode<T>*);//用队列是否是完全二叉树,如果tag=0,说明出现叶子节点，那么它后面的节点就都是叶子节点了。
    bool isBinarySort(BSTNode<T>*);//用队列判断是否是二叉排序树
    bool isBST(BSTNode<T>*);//中序遍历判断是否是二叉排序树
};


template<class T>
bool BST<T>::isBST(BSTNode<T>*p){
    stack<BSTNode<T>*> s;
    BSTNode<T>* pre =0;
    while(p||!s.empty()){
        if(p){
            s.push(p);
            p=p->left;
        }
        else{
            p = s.top();
            s.pop();
            if(pre&&(pre->el >= p->el))
                return false;
            pre = p;
            p=p->right;
        }
    }
    return true;
}


template<class T>
bool BST<T>::isBinarySort(BSTNode<T>*p){
    if(p==0)
        return true;
    queue <BSTNode<T>*> q;
    q.push(p);
    while(!q.empty()){
        p=q.front();
        q.pop();
        if(p->left)
            if(p->left->el < p->el)
                q.push(p->left);
            else
                return false;
        if(p->right)
            if(p->right->el>p->el)
                q.push(p->right);
            else
                return false;
    }
    return true;
}


template<class T>
bool BST<T>::isComplate(BSTNode<T>*p){
    queue<BSTNode<T>*> q;
    if(p==0)
        return true;
    int tag =0;
    q.push(p);
    while(!q.empty()){
        p=q.front();
        q.pop();
        if(p->left&&!tag)
            q.push(p->left);
        else if(p->left)
            return false;
        else
            tag =1;
        if(p->right&&!tag)
            q.push(p->right);
        else if(p->right)
            return false;
        else
            tag =1;


    }
    return true;
}
template<class T>
bool BST<T>::isBalance(BSTNode<T>*p){
    if(p==0)
        return true;
    int left = deep(p->left);
    int right = deep(p->right);
    int diff = right - left;
    if(diff>1 || diff <-1)
        return false;
    return (isBalance(p->right)&&isBalance(p->left));
}


template<class T>
void BST<T>::makefree(BSTNode<T>*p){
    if(p!=NULL){
        makefree(p->left);
        makefree(p->right);
        deleteByCopying(p);
    }
}
template<class T>
int BST<T>::pointNum(BSTNode<T>*p){
    if(p==0)
        return 0;
    int left = pointNum(p->left);
    int right = pointNum(p->right);
    int num = 1+left+right;
    return num;
}


template<class T>
int BST<T>::leafNum(BSTNode<T>*p){
    if(p==0)
        return 0;
    else if(p->left==0&&p->right==0)
        return 1;
    else
        return leafNum(p->left)+leafNum(p->right);
}


template<class T>
int BST<T>::rightNum(BSTNode<T>*p){
    if(p==0)
        return 0;
    else if(p->right)
        return 1+ rightNum(p->left) + rightNum(p->right);
}


template<class T>
int BST<T>::deep(BSTNode<T>*p){
    if(p==0)
        return 0;
    else{
        if(deep(p->left) > deep(p->right))
            return 1+deep(p->left);
        else
            return 1+deep(p->right);
    }
}
template<class T>
void BST<T>::clear(BSTNode<T>*p){
    while(p!=0){
        if(p->left);
        clear(p->left);
        if(p->right);
        clear(p->right);
        delete(p);
    }


}
//二叉查找树的查找
template<class T>
T* BST<T>::search(BSTNode<T>* p,const T& el) const{
    while(p!=0){
        if(el == p->el)
            return &p->el;
        else if(el < p->el)
            p=p->left;
        else
            p=p->right;
    }
    return 0;
}


//广度优先遍历
template<class T>
void BST<T>::breadthFirst(){
    Queue<BSTNode<T>*> queue;
    BSTNode<T> * p =root;
    if(p!=0){
        queue.enqueue(p);
        while(!queue.empty()){
            p = queue.dequeue();
            visit(p);
            if(p->left!=0)
                queue.enqueue(p->left);
            if(p->right!=0)
                queue.enqueue(p->right);
        }
    }
}


//递归的深度优先遍历
//先序、中序、后序遍历：
template<class T>
void BST<T>::preorder(BSTNode<T>*p){
    if(p!=0){
        visit(p);
        preorder(p->left);
        preorder(p->right);
    }
}


template<class T>
void BST<T>::inorder(BSTNode<T>*p){
    if(p!=0){
        inorder(p->left);
        visit(p);
        inorder(p->right);
    }
}


template<class T>
void BST<T>::postorder(BSTNode<T>*p){
    if(p!=0){
        postorder(p->left);
        postorder(p->right);
        visit(p);
    }
}
//非递归的深度优先遍历
//先序、中序、后序遍历


template <class T>
void BST<T>::iterativePreorder(){
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>*p = root;
    if(p!=0){
        travStack.push(p);
        while(!travStack.empty()){
        p=travStack.top();
        travStack.pop();
        visit(p);
        if(p->right!=0)
            travStack.push(p->right);
        if(p->left!=0)
            travStack.push(p->left);
        }
    }
}


template<class T> //难点
void BST<T>::iterativePostorder(){
    Stack<BSTNode<T>*> travStack;
    BSTNode<T> *p = root, *q=root;
    while(p!=0){
        for(;p->left!=0;p=p->left)
            travStack.push(p);
        while(p->right ==0 || p->right ==q){
            visit(p);
            q = p;
            if(travStack.empty())
                return;
            p = travStack.top();
            travStack.pop();
        }
        travStack.push(p);
        p=p->right;
    }
}
/*对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，
但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，
当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。
这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。
因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。
*/


template<class T>
void BST<T>::iterativeInorder(){//此方法不好理解，下面的方法好理解
    Stack<BSTNode<T>*> travStack;
    BSTNode<T> *p = root;
    while(p!=0){
        while(p!=0){
            if(p->right)
                travStack.push(p->right);
            travStack.push(p);
            p=p->left;
        }
        p=travStack.top();
        travStack.pop();
        while(!travStack.empty()&&p->right==0){
            visit(p);
            p=travStack.top();
            travStack.pop();
        }
        visit(p);
        if(!travStack.empty()){
            p=travStack.top();
            travStack.pop();
        }
        else
            p=0;
    }
}


template<class T>
void BST<T>::iterInorder(){//此方法好理解
    Stack<BSTNode<T>*> s;
    BSTNode<T> * p = root;
    while(p!=0 ||!s.empty()){
        while(p!=0)
        {
            s.push(p);
            p=p->left;
        }
        if(!s.empty()){
            p=s.top();
            visit(p);
            s.pop();
            p=p->right;
        }
    }
}
//插入
template<class T>
void BST<T>::insert(const T&el){
    BSTNode<T> * p = root, *prev =0;
    while(p!=0){
        prev = p;
        if(el<p->el)
            p = p->left;
        else p = p->right;
    }
    if(root ==0)
        root = new BSTNode<T>(el);
    else if(el<prev->el)
        prev ->left = new BSTNode<T>(el);
    else prev->right = new BSTNode<T>(el);
}


//删除,合并删除（考虑到要被删除的节点有左右两个子节点）
template <class T>
void BST<T>::deleteByMerging(BSTNode<T>*& node){
    BSTNode<T> * tmp = node;
    if(node !=0){
        if(!node->right)
            node = node->left;
        else if(node->left==0)
            node = node->right;
        else{
            tmp = node->left;
            while(tmp->right!=0)
                tmp = tmp->right;
            tmp->right = node->right;
            tmp = node;
            node = node->left;
        }
        delete tmp;
    }
}


//合并删除操作：
template<class T>
void BST<T>::findAndDeleteByMerging(const T&el){
    BSTNode<T> *node =root, *prev =0;
    while(node !=0){
        if(node->el ==el)
            break;
        prev = node;
        if(node->el <el)
            node = node ->right;
        else node = node->left;
    }


    if(node !=0 && node->el==el)
        if(node == root)
            deleteByMerging(root);
        else if(prev->left == node)
            deleteByMerging(prev->left);
        else deleteByMerging(prev->right);
    else if(node ==0)
        cout <<"el "<<el<<" is not int the tree\n";
    else cout<<"the tree is empty\n";
}


//复制删除
template<class T>
void BST<T>::deleteByCopying(BSTNode<T>*& node){
    BSTNode<T> * previous,*tmp=node;
    if(node->right ==0)
        node = node->left;
    else if(node->left ==0)
        node = node->right;
    else{
        tmp = node->left;
        previous = node;
        while(tmp->right !=0){
            previous = tmp;
            tmp = tmp->right;
        }
    node->el = tmp->el;
    if(previous == node)
        previous->left = tmp->left;
    else previous->right = tmp->left;
    }
    delete tmp;
}


//找到并进行复制删除
template<class T>
void BST<T>::findAndDeleteByCopying(const T&el){
    BSTNode<T> *node =root, *prev =0;
    while(node !=0){
        if(node->el ==el)
            break;
        prev = node;
        if(node->el <el)
            node = node ->right;
        else node = node->left;
    }


    if(node !=0 && node->el==el)
        if(node == root)
            deleteByCopying(root);
        else if(prev->left == node)
            deleteByCopying(prev->left);
        else deleteByCopying(prev->right);
    else if(node ==0)
        cout <<"el "<<el<<" is not int the tree\n";
    else cout<<"the tree is empty\n";
}
#endif // GENBST_H_INCLUDED


main.cpp

#include <iostream>
#include "genBST.h"
using namespace std;


int main()
{
    BST<int> bst;
    //插入
    bst.insert(15);
    bst.insert(10);
    bst.insert(5);
    bst.insert(11);
    bst.insert(12);
    bst.insert(30);
    bst.insert(21);
    bst.insert(40);
    bst.insert(3);
    bst.insert(4);
    bst.insert(2);


    //广度优先遍历
    bst.breadthFirst();
    cout<<"\n节点数：" <<bst.pointNum()<<endl;
    cout <<"叶子数： "<<bst.leafNum()<<endl;
    cout <<"右子节点数目："<<bst.rightNum()<<endl;
    cout<<"数的高度为： "<<bst.deep()<<endl;
    if(bst.isBalance())
        cout<<"树是平衡二叉树"<<endl;
    else
        cout<<"树不是平衡二叉树"<<endl;
    if(bst.isComplate())
         cout<<"树是完全二叉树"<<endl;
    else
        cout<<"树不是完全二叉树"<<endl;
    if(bst.isBinarySort())
         cout<<"树是二叉排序树"<<endl;
    else
        cout<<"树不是二叉排序树"<<endl;
    cout<<endl;
    //深度
    //递归遍历
    bst.preorder();
    cout<<endl;
    bst.inorder();
    cout <<endl;
    bst.postorder();
    cout<<endl;
    //非递归遍历
    bst.iterativePreorder();
    cout<<endl;
    cout<<"非递归中序遍历："<<endl;
    bst.iterativeInorder();
    cout<<endl;
    bst.iterInorder();
    cout<<endl;
    bst.iterativePostorder();
    cout<<endl;
    //查找
    if(bst.search(11))
        cout << "the number is int the tree"<<endl;
    else
        cout<<"the number is not in the tree"<<endl;
    //合并删除
    bst.findAndDeleteByMerging(10);
    bst.breadthFirst();
    cout<<endl;
    //复制删除
    bst.findAndDeleteByCopying(30);
    bst.breadthFirst();
    cout<<endl;
    cout<<"节点数：" <<bst.pointNum()<<endl;
    cout <<"叶子数： "<<bst.leafNum()<<endl;
    cout <<"右子节点数目："<<bst.rightNum()<<endl;
    cout<<"数的高度为： "<<bst.deep()<<endl;
    if(bst.isBalance())
        cout<<"树是平衡二叉树"<<endl;
    else
        cout<<"树不是平衡二叉树"<<endl;
    if(bst.isComplate())
         cout<<"树是完全二叉树"<<endl;
    else
        cout<<"树不是完全二叉树"<<endl;
    if(bst.isBinarySort())
         cout<<"树是二叉排序树"<<endl;
    else
        cout<<"树不是二叉排序树"<<endl;
    //bst.makefree();
    return 0;
}

徐赤赤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的前中后遍历(递归与非递归)、BST插入、删除、创建、查找
tromaker3的博客
03-23 184
#include <iostream> #include <stack> using namespace std; #define len 15 typedef int ElemType; typedef struct BiTNode { ElemType data; struct BiTNode *lchild,*rchild; }BiTNode ,*BiTre...
二叉树的删除递归与非递归
weixin_44579258的博客
07-04 1268
二叉树的节点的创建，请点击 class BST<T extends Comparable<T>>{ private BSTNode<T> root; // 指向根节点 /** * BST树的初始化 */ public BST() { th...
二叉树插入删除查找递归及非递归的实现
小牛的博客
07-21 537
二叉树建树、插入、删除、查找最大最小值、查找特定值的递归及非递归实现。 注意：一定要先建二叉树，必须要有一个开辟了内存空间的节点作为头结点（并且赋了值）！！！ #include <iostream> #include <cstdio> #include <string> #include <vector> #include <queue>...
二叉排序树的查询、插入和删除操作
洛安
03-16 437
//二叉排序树查找 //创建二叉树的结点结构定义 typedef struct BiTNode { int data; struct BiTNode *lchild, *rchild; }BiTNode,*BiTree; //递归查找二叉排序树T中是否存在key //指针f指向T的双亲，其初始调用值为NULL //若查找成功，则指针p指向该数据元素结点，并返回TRUE //若查找
二叉树的遍历——递归以及非递归实现
06-03
vs2010下运行编写，使用了STL栈，实现了基本的插入、删除、计算深度、查找，主要是遍历，包括递归遍历，以及非递归的前序中序后序遍历，每个函数都有测试用例，如果存在错误，请在给我留言。
二叉树的创建和各种遍历递归和非递归
01-12
在本主题中，我们将深入探讨如何使用C语言实现二叉树的创建、不同类型的遍历（递归与非递归）以及计算叶子节点的数量和树的高度。 首先，我们来创建一个二叉树的节点结构。在C语言中，可以定义一个结构体类型，如下...
二叉树遍历C语言(递归-非递归)六种算法.rar-综合文档
05-11
二叉树遍历是计算机科学中的一个重要概念，特别是在数据结构和算法的学习中。二叉树是一种特殊的树形数据结构...在实际应用中，我们还需要考虑如何创建、插入、删除二叉树节点，以及如何优化遍历过程，以提高算法效率。
二叉树的创建与遍历.rar
最新发布
05-27
在实际应用中，根据具体需求，我们可以选择不同的二叉树类型和遍历策略，优化搜索、插入和删除操作的效率。对于压缩包中的“二叉树的创建与遍历.docx”文档，建议详细阅读，其中可能会包含更多关于二叉树实例、图示...
二叉树非递归遍历.rar
02-20
查找算法，二叉排序树，二叉树层次遍历，二叉树非递归遍历，二叉树的建立，关键字匹配查找等。 如有问题，可随时私信。 初学C语言必须掌握的一些基础知识，包括直接选择排序、直接插入排序、冒泡排序、快速排序。 ...
插入二叉树的实现
菜鸟先飞
07-26 2442
数据结构 - 插入二叉树的实现 &lt;!doctype html&gt; &lt;html lang="zh-CN"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;插入二叉树&lt;/title&gt; &lt;/head&gt; &lt;body&g
二叉搜索树的插入、查找、删除的递归与非递归实现
小心眼儿猫的博客
05-16 1552
二叉搜索树： 1、要么为一个空树 2、要么不是一个空树 2.1、如果有左子树，对于该树中的每一个节点来说，该节点的左子树上的所有节点都要比该节点小 2.2、如果有右子树，对于该树中的每一个节点来说，该节点的右子树上的所有节点都要比该节点大 下面我们采用递归方法以及非递归方法来实现一下对于二叉搜索树的插入、查找以及删除操作。 1、基本操作：这里的基本操作思路简单，且在...
数据结构--二叉排序树的非递归查找算法
zlhcsm的博客
08-19 4261
BSTNode *BST_Search(BiTree T,ElemType key,BSTNode *&amp;p){ //查找函数返回指向关键字为key的节点指针，若不存在，返回NULL p=NUll; //p指向被查找节点的双亲，用于插入和删除操作中 while(T !=Null$&amp;&amp;key!=T-&gt;data){ p=T; ...
二叉查找树的查找、插入、删除、释放等基本操作的实现（C语言）
大树的专栏
06-14 8977
二叉查找树是一种特殊性质的二叉树，该树中的任何一个节点，它的左子树（若存在）的元素值小于节点的元素值，右子树（若存在）的元素值大于节点的元素值。 实现了二叉树查找树的实现以及基本操作，包括查找、插入、删除、初始化、释放等。 源码下载地址：http://download.csdn.net/detail/mcu_tian/9548788 二叉查找树节点的结构定义 相比二叉树，二叉查找树的元素结
二叉排序树中查找元素的递归和非递归写法
buptwds的专栏
07-18 7742
上一篇介绍了二分查找的递归和非递归写法，这一篇文章主要记录二叉排序树中查找元素的递归和非递归写法。二叉排序树又称为二叉查找树，也称为二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等的
leetcode 450 删除二叉搜索树中的节点
AndyJ的学习放弃之旅
08-10 514
细心做。 题： 450. 删除二叉搜索树中的节点 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。 一般来说，删除节点可分为两个步骤： 首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为 O(h)，h 为树的高度。 示例: root = [5,3,6,2,4,null,7] key = 3 5 / \ 3 6 / \ \ 2
排序二叉树的插入、删除操作(递归方式)。
weixin_30797027的博客
09-10 74
/*------------------------------------------------------------------*/typedef struct node{　　int data;　　struct node* lchild;　　struct node* rchild;}Tree,*PTree; //data of tree struct /*-------...
二叉树的建立、销毁、各种遍历（递归、非递归）
Shelsea_x的专栏
02-12 759
出自 http://blog.csdn.net/luxiaoxun/article/details/7536992 //二叉树操作 class Node { public: char data; Node *left; Node *right; Node():data(' '),left(NULL),right(NULL){} Node(c
2018.9 快手笔试编程题
DK
09-25 272
题目描述：给你二叉树的先序和中序遍历的值，求出中序遍历的求和树。每个节点的和等于其左右孩子节点的value的和。 思路：先建树，直接递归求和输出就好了。。 我简化了输入，原题的输入是字符串输入，当时一直段错误，卡了快一个小时，这个代码能过样例，不知道能不能过全部的数据。 #include &lt;iostream&gt; #include &lt;cstring&gt; #include ...
二叉树遍历非递归算法解析与实现
二叉树广泛应用于数据结构和算法设计中，因为它们支持高效的操作，如查找、插入和删除。本资源聚焦于非递归算法对二叉树的遍历，这是一种避免了递归函数调用带来的额外开销的方法。 三类主要的二叉树遍历方法包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值