（数据结构）如何手搓一棵二叉树？

已于 2022-10-27 00:15:17 修改
阅读量452 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2022-09-22 13:11:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61735576/article/details/126988909
版权

目录

二叉树结点 binnode

函数总览

构造：

size()

insertAsLc()

insertAsRc()

succ()

前序遍历

递归版本

迭代版本

中序遍历

递归版本

迭代版本

后序遍历

递归版本

迭代版本

层级遍历

代码

二叉树

函数总览：

updateHeight

updateHeightAbove

higerchild

insert函数

代码

二叉树是很多数据结构的基础

众所周知，二叉树中每个节点最多有两个儿子

对于二叉树，最重要的就是前中后序遍历，这也是本文写的最多的部分

整棵树分为两大部分实现，二叉树节点（node）和树本身

二叉树结点 binnode

这里我们后面前中后序遍历要用到栈和队列

我们先把它include进来

(53条消息) 手写vector，list，stack，queue代码_lxrrrrrrrr的博客-CSDN博客

当然改成stl的也可以

函数总览

​
#define lxrbinnodeposi(T) lxrbinnode<T>*

typedef enum{RED,BLACK} Color;

template <typename T>
class lxrbinnode{
protected:
    template <typename VST>
    void visitAlongLeftBranch(VST &visit,lxrstack<lxrbinnodeposi(T)> &S);
    void goAlongLeftBranch( lxrstack<lxrbinnodeposi(T)> &S);
    void goToHLVFL(lxrstack<lxrbinnodeposi(T)> &S);

public:
    lxrbinnodeposi(T) parent;
    lxrbinnodeposi(T) leftchild;
    lxrbinnodeposi(T) rightchild;
    Color             color;
    T                 data;
    int               height;

    //constructor
    lxrbinnode() : parent(nullptr),leftchild(nullptr),rightchild(nullptr),height(0),color(BLACK),npl(0) {};
    lxrbinnode(T const &val,lxrbinnodeposi(T) p=nullptr,Color color=BLACK):parent(p),leftchild(nullptr),rightchild(nullptr),data(val),height(0),color(color),npl(0) {};

    int size() const; //compute the size of subtree rooted at now node
    lxrbinnodeposi(T) insertAsLc(T const &val); //assume that this.leftchild==nullptr
    lxrbinnodeposi(T) insertAsRc(T const &val); //assume that this.rightchild=nullptr
    lxrbinnodeposi(T) succ(); //return the direct succ of now node

    //tree traversal
    template <typename VST> void preOrder_Re(VST visit);//use recursion to preorder traversal
    template <typename VST> void preOrder_It1(VST visit);//use iteration to preorder traversal
    template <typename VST> void preOrder_It2(VST visit);//use iteration to preorder traversal

    template <typename VST> void inOrder_Re(VST visit);//use recursion to middle traversal
    template <typename VST> void inOrder_It1(VST visit);//use iteration to middle traversal
    template <typename VST> void inOrder_It2(VST visit);//use iteration to middle traversal

    template <typename VST> void postOrder_Re(VST visit);//use recursion to postorder traversal
	template <typename VST> void postOrder_It(VST visit);//use iteration to postorder traversal

	template <typename VST> void levelOrder(VST visit);//traversal with depth
};

​

对于每个节点，包含几个基础的变量

parent：父节点

leftchild：左孩子

rightchild：右孩子

color：颜色（主要是为了之后写红黑树时用，暂时不管他）

data：这个节点的value

height：高度

首先介绍几个基础函数

构造：

构造非常简单，我们只需要定义一个默认构造和带值构造即可

lxrbinnode() : parent(nullptr),leftchild(nullptr),rightchild(nullptr),height(0),color(BLACK) {};
lxrbinnode(T const &val,lxrbinnodeposi(T) p=nullptr,Color color=BLACK):parent(p),leftchild(nullptr),rightchild(nullptr),data(val),height(0),color(color) {};

size()

计算这个节点的子树+这个节点的size

也很好写，左右子树size+1即可

template <typename T>
int lxrbinnode<T>::size() const {
    int leftSize=this->leftchild ? this->leftchild->size() : 0;
    int rightSize=this->rightchild ? this->rightchild->size() :0;
    return leftSize+rightSize+1;
}

insertAsLc()

在当前节点的左边插入一个新节点，值为val

只需让新节点的parent指向此节点

此节点的leftchild指向新节点即可

template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::insertAsLc(T const &val){
    lxrbinnodeposi(T) currNode=new lxrbinnode<T>(val);
    currNode->parent=this;
    this->leftchild=currNode;
    return currNode;
}

insertAsRc()

同理

template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::insertAsRc(T const &val){
    lxrbinnodeposi(T) currNode=new lxrbinnode<T>(val);
    currNode->parent=this;
    this->rightchild=currNode;
    return currNode;
}

succ()

返回当前节点的直接后继

在二叉树中，我们定义直接后继等于在该树中序遍历中，此节点的下一个节点

不懂中序遍历可以往后看，后面会仔细讲

实现过程，看一遍中序遍历流程图就可以看懂

如果该节点有右儿子，我们只需要走到他的右儿子，继续一直向左走就可以找到

如果没有右儿子，我们就要往上找，只要该节点是他父节点的右儿子就一直向上走

走到顶再走一步即使答案

代码如下：

template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::succ(){
    lxrbinnodeposi(T) succ;
    if(rightchild){
        succ=rightchild;
        while(succ->leftchild) succ=succ->leftchild;
    }
    else{
        succ=this;
        while(succ->parent&&succ==succ->parent->rightchild) succ=succ->parent;
        succ=succ->parent;
    }
    return succ;
}

接下来讨论前中后序遍历的递归和迭代版本

前序遍历

所谓前序遍历，就是对于每一个三元组，总是根在前面，左儿子其次，右儿子在后

从根节点开始，不断向左子树访问，直到当前结点x不拥有左子树，这也相当于左子树已经访问完毕，此时转入当前结点x的右子树。右子树访问完毕后，即以x为根的子树已经访问完毕，此时应该转入x父亲的右子树，随后是x父亲的父亲的右子树，然后是x父亲的父亲的...整个访问过程可以如下面这张图所示：

递归版本比较好写，迭代版用栈即可

递归版本

如上所说

先遍历此节点，如果有左儿子优先走左儿子，否则走右儿子

template <typename T>
template <typename VST>
void lxrbinnode<T>::preOrder_Re(VST visit){
    visit(this->data);
    if(this->leftchild) this->leftchild->preOrder_Re(visit);
    if(this->rightchild) this->rightchild->preOrder_Re(visit);
}

迭代版本

用一个栈辅助操作，思想同上

先遍历此节点，由于栈是先进后出，所以我们要优先把右儿子压进栈中，然后压左儿子，

这样我们可以保证左儿子先出栈，也就保证了前序性

代码如下

template <typename T>
template <typename VST>
void lxrbinnode<T>::preOrder_It1(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    S.push(curr);
    while(!S.empty()){
        curr=S.pop();
        visit(curr->data);
        if(curr->rightchild) S.push(curr->rightchild);
        if(curr->leftchild) S.push(curr->leftchild);
    }
}

中序遍历

定义大同小异

对于每一个三元组，总是左儿子在前，根其次，右儿子在后 

同样是从根节点开始，不断地沿着左子树向下走。不同的是，这里向下行进的过程中不能访问当前结点，只有等到当前结点的左子树完成访问时，才能轮到当前结点，因此想到引入一个栈来实现延迟缓冲的功能。走到最左侧的第一个没有左子树的叶子结点时，没有左子树也相当于已经完成了左子树的访问，于是随后便访问当前结点x，然后转入到x的右子树。

当x的右子树完成访问时，即标志着以x为根的子树访问完毕，随机访问x的父亲结点，然后访问x的父亲的右子结点。x的右兄弟结点访问完毕时，即标志着以x的父亲的根的子树访问完毕，随机访问x父亲的父亲，然后是x父亲的父亲的父亲...整个访问过程如下图所示：

递归版本

递归版本好写的原因在于不用动脑子

将三行代码按顺序排列即可

template <typename T>
template <typename VST>
void lxrbinnode<T>::inOrder_Re(VST visit){
    if(this->leftchild) this->leftchild->inOrder_Re(visit);
    visit(this->data);
    if(this->rightchild) this->rightchild->inOrder_Re(visit);
}

迭代版本

迭代版本要稍微麻烦一点

goAlongLeft函数的作用是对于每一个节点，一直向左走，这一条左链都压入栈

具体实现：对于每一个节点，先一直向左走，将他的所有左儿子都压入栈，之后每一个左儿子

按顺序出栈，遍历此节点，再遍历此节点的右节点，之后下一个左儿子出栈.....

代码如下

template <typename T>
void lxrbinnode<T>::goAlongLeftBranch(lxrstack<lxrbinnodeposi(T)> &S){
    lxrbinnodeposi(T) curr=this;
    while(curr){
        S.push(curr);
        curr=curr->leftchild;
    }
}
template <typename T>
template <typename VST>
void lxrbinnode<T>::inOrder_It1(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    while(true){
        curr->goAlongLeftBranch(S);
        if(S.empty()) break;

        curr=S.pop();
        visit(curr->data);
        curr=curr->rightchild;
    }
}

后序遍历

定义：对于每一个三元组，总是左儿子在前，右儿子其次，最后为根

首要的还是分析后续遍历各个节点之间的先后次序，哪个结点首先被访问，每个结点的直接后继是谁？

从根节点出发，不断沿着左子树向下进行，直到当前结点不具有左子树。此时应该进入右子树，然后重复上面的过程。这样，第一个被访问的结点，应该是最高左侧可见结点，即从左边向右看过去，未被遮挡的最高叶节点，该结点既可以是左节点，也可是右节点。从而，显而易见，这里也需要引入一个栈来实现延迟缓冲的作用。根据上面的分析，应该是当前结点首先入栈，其次是右孩子，最后是左孩子。

当一个结点访问完毕时，代表着以该结点为根的子树访问完毕，此时应该弹栈以访问下一个结点。此时弹栈无非两种情况：

当前结点是左结点。则弹栈的结点是当前结点的右结点。对右结点的处理应该继续迭代地访问右结点的最高左侧可见结点。

当前结点是右结点。则弹栈的结点是当前结点的父结点。此时应该访问当前结点，然后直接进入下一步的迭代，再次进行弹栈操作。

递归版本

和之前一样，交换下位置即可

template <typename T>
template <typename VST>
void lxrbinnode<T>::postOrder_Re(VST visit){
    if(this->leftchild) this->leftchild->postOrder_Re(visit);
    if(this->rightchild) this->rightchild->postOrder_Re(visit);
    visit(this->data);
}

迭代版本

和上面叙述类似

代码如下

template <typename T>
void lxrbinnode<T>::goToHLVFL(lxrstack<lxrbinnodeposi(T)> &S){
    lxrbinnodeposi(T) curr;
    while(curr=S.top()){
        if(curr->leftchild){
            if(curr->rightchild) S.push(curr->rightchild);
            S.push(curr->leftchild);
        }
        else S.push(curr->rightchild);
    }
    S.pop();
}
template <typename T>
template <typename VST>
void lxrbinnode<T>::postOrder_It(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    S.push(curr);
    while(!S.empty()){
        if(S.top()!=curr->parent) goToHLVFL(S);
        curr=S.pop();
        visit(curr->data);
    }
}

层级遍历

层级遍历，就是按照深度一层一层的遍历

实现：考虑用队列（queue）对于每一个出队的节点。将他的左右儿子进队

这样能保证每一层都可以按序列出队

代码如下

template <typename T>
template <typename VST>
void lxrbinnode<T>::levelOrder(VST visit){
    lxrqueue<lxrbinnodeposi(T)> q;
    lxrbinnodeposi(T) curr=this;
    q.enqueue(curr);
    while(!q.empty()){
        curr=q.dequeue();
        visit(curr->data);
        if(curr->leftchild) q.enqueue(curr->leftchild);
        if(curr->rightchild) q.enqueue(curr->rightchild);
    }
}

截至现在，二叉树节点文件已经完毕

总代码如下：

代码

#ifndef LXRBINNODE_H_
#define LXRBINNODE_H_

#include "../03 stack and queue/lxrstack.h"
#include "../03 stack and queue/lxrqueue.h"
#define lxrbinnodeposi(T) lxrbinnode<T>*

typedef enum{RED,BLACK} Color;

template <typename T>
class lxrbinnode{
protected:
    template <typename VST>
    void visitAlongLeftBranch(VST &visit,lxrstack<lxrbinnodeposi(T)> &S);
    void goAlongLeftBranch( lxrstack<lxrbinnodeposi(T)> &S);
    void goToHLVFL(lxrstack<lxrbinnodeposi(T)> &S);

public:
    lxrbinnodeposi(T) parent;
    lxrbinnodeposi(T) leftchild;
    lxrbinnodeposi(T) rightchild;
    Color             color;
    T                 data;
    int               height;

    //constructor
    lxrbinnode() : parent(nullptr),leftchild(nullptr),rightchild(nullptr),height(0),color(BLACK),npl(0) {};
    lxrbinnode(T const &val,lxrbinnodeposi(T) p=nullptr,Color color=BLACK):parent(p),leftchild(nullptr),rightchild(nullptr),data(val),height(0),color(color),npl(0) {};

    int size() const; //compute the size of subtree rooted at now node
    lxrbinnodeposi(T) insertAsLc(T const &val); //assume that this.leftchild==nullptr
    lxrbinnodeposi(T) insertAsRc(T const &val); //assume that this.rightchild=nullptr
    lxrbinnodeposi(T) succ(); //return the direct succ of now node

    //tree traversal
    template <typename VST> void preOrder_Re(VST visit);//use recursion to preorder traversal
    template <typename VST> void preOrder_It1(VST visit);//use iteration to preorder traversal
    template <typename VST> void preOrder_It2(VST visit);//use iteration to preorder traversal

    template <typename VST> void inOrder_Re(VST visit);//use recursion to middle traversal
    template <typename VST> void inOrder_It1(VST visit);//use iteration to middle traversal
    template <typename VST> void inOrder_It2(VST visit);//use iteration to middle traversal

    template <typename VST> void postOrder_Re(VST visit);//use recursion to postorder traversal
	template <typename VST> void postOrder_It(VST visit);//use iteration to postorder traversal

	template <typename VST> void levelOrder(VST visit);//traversal with depth
};

template<typename T>
template<typename VST>
void lxrbinnode<T>::visitAlongLeftBranch(VST &visit, lxrstack<lxrbinnodeposi(T)> &S){
    lxrbinnodeposi(T) curr=this;
    while(curr){
        visit(curr->data);
        S.push(curr->rightchild);
        curr=curr->leftchild;
    }
}
template <typename T>
void lxrbinnode<T>::goAlongLeftBranch(lxrstack<lxrbinnodeposi(T)> &S){
    lxrbinnodeposi(T) curr=this;
    while(curr){
        S.push(curr);
        curr=curr->leftchild;
    }
}
template <typename T>
void lxrbinnode<T>::goToHLVFL(lxrstack<lxrbinnodeposi(T)> &S){
    lxrbinnodeposi(T) curr;
    while(curr=S.top()){
        if(curr->leftchild){
            if(curr->rightchild) S.push(curr->rightchild);
            S.push(curr->leftchild);
        }
        else S.push(curr->rightchild);
    }
    S.pop();
}

//public interfaces
template <typename T>
int lxrbinnode<T>::size() const {
    int leftSize=this->leftchild ? this->leftchild->size() : 0;
    int rightSize=this->rightchild ? this->rightchild->size() :0;
    return leftSize+rightSize+1;
}
template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::insertAsLc(T const &val){
    lxrbinnodeposi(T) currNode=new lxrbinnode<T>(val);
    currNode->parent=this;
    this->leftchild=currNode;
    return currNode;
}
template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::insertAsRc(T const &val){
    lxrbinnodeposi(T) currNode=new lxrbinnode<T>(val);
    currNode->parent=this;
    this->rightchild=currNode;
    return currNode;
}
template <typename T>
lxrbinnodeposi(T) lxrbinnode<T>::succ(){
    lxrbinnodeposi(T) succ;
    if(rightchild){
        succ=rightchild;
        while(succ->leftchild) succ=succ->leftchild;
    }
    else{
        succ=this;
        while(succ->parent&&succ==succ->parent->rightchild) succ=succ->parent;
        succ=succ->parent;
    }
    return succ;
}

//tree traversal
template <typename T>
template <typename VST>
void lxrbinnode<T>::preOrder_Re(VST visit){
    visit(this->data);
    if(this->leftchild) this->leftchild->preOrder_Re(visit);
    if(this->rightchild) this->rightchild->preOrder_Re(visit);
}
template <typename T>
template <typename VST>
void lxrbinnode<T>::preOrder_It1(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    S.push(curr);
    while(!S.empty()){
        curr=S.pop();
        visit(curr->data);
        if(curr->rightchild) S.push(curr->rightchild);
        if(curr->leftchild) S.push(curr->leftchild);
    }
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::preOrder_It2(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    while(true){
        if(curr) curr->visitAlongLeftBranch(visit,S);
        if(S.empty()) break;
        curr=S.pop();
    }
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::inOrder_Re(VST visit){
    if(this->leftchild) this->leftchild->inOrder_Re(visit);
    visit(this->data);
    if(this->rightchild) this->rightchild->inOrder_Re(visit);
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::inOrder_It1(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    while(true){
        curr->goAlongLeftBranch(S);
        if(S.empty()) break;

        curr=S.pop();
        visit(curr->data);
        curr=curr->rightchild;
    }
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::inOrder_It2(VST visit){
    lxrbinnodeposi(T) curr=this;
    bool backTrack=false;
    while(curr){
        if(!backTrack){
            while(curr->leftchild) curr=curr->leftchild;
            backTrack=true;
        }
        else{
            visit(curr->data);
            if(curr->rightchild){
                curr=curr->rightchild;
                backTrack=false;
            }
            else{
                while(curr->parent&&curr==curr->parent->rightchild) curr=curr->parent;
                curr=curr->parent;
            }
        }
    }
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::postOrder_Re(VST visit){
    if(this->leftchild) this->leftchild->postOrder_Re(visit);
    if(this->rightchild) this->rightchild->postOrder_Re(visit);
    visit(this->data);
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::postOrder_It(VST visit){
    lxrstack<lxrbinnodeposi(T)> S;
    lxrbinnodeposi(T) curr=this;
    S.push(curr);
    while(!S.empty()){
        if(S.top()!=curr->parent) goToHLVFL(S);
        curr=S.pop();
        visit(curr->data);
    }
}

template <typename T>
template <typename VST>
void lxrbinnode<T>::levelOrder(VST visit){
    lxrqueue<lxrbinnodeposi(T)> q;
    lxrbinnodeposi(T) curr=this;
    q.enqueue(curr);
    while(!q.empty()){
        curr=q.dequeue();
        visit(curr->data);
        if(curr->leftchild) q.enqueue(curr->leftchild);
        if(curr->rightchild) q.enqueue(curr->rightchild);
    }
}

#endif

二叉树

接下来手搓二叉树部分

函数总览：

template <typename T>
class lxrbintree{
protected:
    lxrbinnodeposi(T) __root;
    int               __size;
    virtual bool updateHeight(lxrbinnodeposi(T) x);
    virtual void updateHeightAbove(lxrbinnodeposi(T) x);
    lxrbinnodeposi(T) higherChild(lxrbinnodeposi(T) x);
public:
    //constructor
    lxrbintree():__root(nullptr),__size(0) {};

    //deconstructor
    ~lxrbintree()=default;

    bool           empty() const { return __size == 0; }
    int            size()  const {return __size;}
    lxrbinnodeposi(T) root() const {return __root;}
    lxrbinnodeposi(T) insertAsRoot(T const &val);
    lxrbinnodeposi(T) insertAsLc(lxrbinnodeposi(T) x,T const &val);
    lxrbinnodeposi(T) insertAsRc(lxrbinnodeposi(T) x,T const &val);
};

对于每一棵二叉树，主要变量有

__root:根节点

__size:全树节点总数

接下来介绍主要函数

updateHeight

该函数主要作用是通过子节点更新该节点的高度

实现非常简单

该节点高度=MAX（左子树高度，右子树高度）+1

代码如下

template <typename T>
bool lxrbintree<T>::updateHeight(lxrbinnodeposi(T) x){
    int prevHeight=x->height;
    int leftHeight=x->leftchild ? x->leftchild->height:-1;
    int rightHeight=x->rightchild ? x->rightchild->height:-1;
    x->height=MAX(leftHeight,rightHeight)+1;
    return prevHeight != x->height;
}

updateHeightAbove

作用：如果对节点x进行改动，高度变化会随着x的祖先一直向上更新

该函数作用即为更新x改动后对高度的影响

实现：一直枚举x的祖先，更新到顶部为止

代码如下：

template <typename T>
void lxrbintree<T>::updateHeightAbove(lxrbinnodeposi(T) x){
    for(; x&& updateHeight(x);x=x->parent);
}

higerchild

顾名思义，返回这个节点高度更高的儿子

如果只有一个儿子直接返回那个儿子

否则比较一下

代码如下

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::higherChild(lxrbinnodeposi(T) x){
    if(!x->leftchild) return x->rightchild;
    if(!x->rightchild) return x->leftchild;
    return x->leftchild->height < x->rightchild->height ? x->rightchild:x->leftchild;
}

insert函数

该函数为插入函数，只要为插入根节点，在节点x的左儿子插入一个节点

在节点x的右儿子插入一个节点

我们只需要插入之后更新一下高度即可

代码如下

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsRoot(T const &val){
    __size=1;
    return __root=new lxrbinnode<T>(val);
}

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsLc(lxrbinnodeposi(T) x,T const &val){
    ++__size;
    lxrbinnodeposi(T) res=x->insertAsLc(val);
    updateHeightAbove(x);
    return res;
}

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsRc(lxrbinnodeposi(T) x,T const &val){
    ++__size;
    lxrbinnodeposi(T) res=x->insertAsRc(val);
    updateHeightAbove(x);
    return res;
}

代码

总体代码如下

#ifndef LXRBINTREE_H_
#define LXRBINTREE_H_

#include "lxrbinnode.h"
#define FROMPARENTTO(X) (X->parent? __root:X==X->parent->leftchild? X->parent->leftchild: X->parent->rigthchild)
// if(x->parent!=0){
//     return __root;
// }
// else{
//     if(X==X->parent->leftchild){
//         return X->parent->leftchild;
//     }
//     else{
//         return x->parent->rightchild;
//     }
// }
#define STATURE(X) ((X)?(X)->height:-1)
#define MAX(X,Y) ((X)>(Y)?(X):(Y))

template <typename T>
class lxrbintree{
protected:
    lxrbinnodeposi(T) __root;
    int               __size;
    virtual bool updateHeight(lxrbinnodeposi(T) x);
    virtual void updateHeightAbove(lxrbinnodeposi(T) x);
    lxrbinnodeposi(T) higherChild(lxrbinnodeposi(T) x);
public:
    //constructor
    lxrbintree():__root(nullptr),__size(0) {};

    //deconstructor
    ~lxrbintree()=default;

    bool           empty() const { return __size == 0; }
    int            size()  const {return __size;}
    lxrbinnodeposi(T) root() const {return __root;}
    lxrbinnodeposi(T) insertAsRoot(T const &val);
    lxrbinnodeposi(T) insertAsLc(lxrbinnodeposi(T) x,T const &val);
    lxrbinnodeposi(T) insertAsRc(lxrbinnodeposi(T) x,T const &val);
};

//protected methods
template <typename T>
bool lxrbintree<T>::updateHeight(lxrbinnodeposi(T) x){
    int prevHeight=x->height;
    int leftHeight=x->leftchild ? x->leftchild->height:-1;
    int rightHeight=x->rightchild ? x->rightchild->height:-1;
    x->height=MAX(leftHeight,rightHeight)+1;
    return prevHeight != x->height;
}

template <typename T>
void lxrbintree<T>::updateHeightAbove(lxrbinnodeposi(T) x){
    for(; x&& updateHeight(x);x=x->parent);
}

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::higherChild(lxrbinnodeposi(T) x){
    if(!x->leftchild) return x->rightchild;
    if(!x->rightchild) return x->leftchild;
    return x->leftchild->height < x->rightchild->height ? x->rightchild:x->leftchild;
}

//public interfaces
template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsRoot(T const &val){
    __size=1;
    return __root=new lxrbinnode<T>(val);
}

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsLc(lxrbinnodeposi(T) x,T const &val){
    ++__size;
    lxrbinnodeposi(T) res=x->insertAsLc(val);
    updateHeightAbove(x);
    return res;
}

template <typename T>
lxrbinnodeposi(T) lxrbintree<T>::insertAsRc(lxrbinnodeposi(T) x,T const &val){
    ++__size;
    lxrbinnodeposi(T) res=x->insertAsRc(val);
    updateHeightAbove(x);
    return res;
}


#endif

自此，一颗完整的二叉树就搓好了

二叉树可以派生出二叉搜索树BST

而BST又可以派生出一系列高级搜索树

后续会更新一些后面的搜索树，会include此文件

lxrrrrrrrr
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构:手撕二叉树
m0_60388241的博客
05-21 250
二叉树的基础概念: 树:高效的查找与搜索 1.为什么会存在树结构? 企业中员工的分类就是一个"树"结构!!! 如果是一个线性结构,大家都在一个"目录"中: 比如当前企业一共有300号员工,要找到一个特定员工最坏情况下要找300次 如果是一个树结构: 按照员工的职级分类,300个员工一共分为5级,搜索一个特点员工只需要5次即可找到 OS系统中的文件就是基于树结构管理的 OS系统中的所有文件都放在一个目录下,若当前操作系统有1亿个文件,最坏情况遍历1亿次才能找到特定元..
手撕B树
weixin_44627989的博客
04-03 606
title: 手撕B树 B树 B树和B+树都是多路查找树。具备分支多层数少的优点常用于数据库索引存储 BTree大量应用在数据库（mongodb）和文件系统当中，B+Tree经常用于数据库索引（空间局部性原理） B树代表每个节点可存储的数据节点不超过m-1，且每个节点的子节点不超过m个的树。根节点的子节点为0或至少为2 B+树与B树区别就是B+树只在没有子节点的底层节点存储数据而其他包含子节点的...
（数据结构）如何手搓一棵B树（B-Tree）
m0_61735576的博客
09-23 448
B树其实是由二叉搜索树变化而来，它的本质仍然是二叉搜索树。如下面的图所示，将原有的二叉搜索树的结点进行适当的合并，得到超级结点。由这些超级结点组成的新的树，就是一棵B树。
数据结构之手斯B树（心中有B树，做人要谦虚）
qq_56999918的博客
02-17 764
1970年，R.Bayer和E.mccreight提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树(有些地方写 的是B-树，注意不要误读成"B减树")。一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性质： 1. 根节点至少有两个孩子 2. 每个非根节点至少有M/2(上取整)个孩子,至多有M个孩子 3. 每个非根节点至少有M/2-1(上取整)个关键字,至多有M-1个关键字，并且以升序排列 4. key[i]和key[i+1]之间的孩子节点的值介于ke...
排序算法 python手搓
qq_34866917的博客
10-22 147
快排 def quick_sort(arr): """快速排序""" if len(arr) < 2: return arr # 选取基准，随便选哪个都可以，选中间的便于理解 mid = arr[0] # 定义基准值左右两个数列 left, right = [], [] # 从原始数组中移除基准值 arr.rem...
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是我们常见的数据结构之一，在学习二叉树之前我们需要知道什么是树，什么是二叉树，本篇主要讲述了二叉树，以及二叉树的遍历。 你能get到的知识点？ 1、树的介绍 2、二叉树的介绍 3、二叉树遍历的四种方法 4、...
数据结构作业唯一确定一棵二叉树.doc
12-02
数据结构作业唯一确定一棵二叉树.doc
数据结构作业：唯一确定一棵二叉树.doc
01-06
数据结构作业：唯一确定一棵二叉树.doc
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
广工数据结构实验——平衡二叉树
07-06
广工数据结构实验——平衡二叉树 里面含有：源代码、可执行程序、说明文档
（数据结构）如何手搓一棵红黑树（RedBlack-Tree）
m0_61735576的博客
09-29 766
红黑树作为一种及其高级的数据结构，插入和删除效率很高，被广泛用于各种底层设计上与B树有着不解之缘其中一颗红黑树必须满足这样的性质1 根节点是黑色2 每个叶子节点(就是最末端的节点也就是null)是黑色(一般画图省略null)3 如果一个节点是红色,那么它的两个子节点都是黑色(也就是说不能有两个相邻的红色节点)4 从任一 节点开始到其所有子孙叶结点的路径中所包含的黑色结点数量必须相同。
数据结构—二叉树链式结构的实现
IfYouHave的博客
03-17 453
普通二叉树的增删查改没有什么意义，主要学习遍历、结构而存储数据，不如用顺序表，链表，那么学习他的意义是为了什么？1.为了后面学习更为复杂的二叉树打基础。（搜索二叉树、ALV树、红黑树、B树、B+树、B*树）2.有很多二叉树的OJ算法题，都是出在普通二叉树上。
数据结构复习之红黑树B树B+树（HashMap底层红黑树，磁盘I/OB树、数据库索引B+树）
千里之行，始于足下
04-24 821
五、红黑树 2-3查找树能保证在插入元素之后，树依然保持平衡状态，它的最坏情况下所有子结点都是2-结点，树的高度为lgN，相比普通的二叉查找树保证了最坏情况下的时间复杂度。红黑树是2-3树思想的简单实现 红黑树主要是对2-3树进行编码，红黑树背后的基本思想是（标准的二叉查找树）和一些额外的信息替换3-结点来表示2-3树。所以将树中的链接分为两种类型： 红链接：将两个2-结点链接起来构成一个3-结点...
java手动构建二叉树并实现广度遍历、深度遍历（前序中序后序）
you do ,you win
04-21 1943
文章目录什么是二叉树属性节点TreeNode手动构建如下所示二叉树遍历广度遍历算法思想实现细节深度遍历先序遍历（根左右）算法思想实现细节中序遍历（左根右）算法思想实现细节后续遍历（左右根）算法思想实现细节 什么是二叉树 在计算机科学中，树是一种重要的非线性数据结构，直观的看，它是数据元素按分支关系组织起来的结构。二叉树是每个节点最多有两个子树的有序树。通常子树的根被称作“左子树”和“右子树”。二叉树常被用做二叉查找树和二叉堆或是二叉排序树。二叉树的每个节点至多只有两颗子树，二叉树有左右之分，次序不能颠倒。
java手写二叉树
片生石的博客
11-22 704
package com.pp.tree; import java.util.Objects; public class Binarytree { private Node root; private void addNode(int data){ if (Objects.isNull(root)){ root = new Node(data); }else{ root.add(data); .
数据结构----二叉树的遍历-前序-中序-后序-层序(详解)
m0_60565784的博客
05-23 1217
前言 喜欢的老铁留下你们的三连 文章目录1.回顾二叉树的概念2.二叉树遍历有：前序/中序/后序的递归结构遍历2.1 前序2.2中序 1.回顾二叉树的概念 二叉树是： 空树 非空：根节点，根节点的左子树、根节点的右子树组成的。 2.二叉树遍历有：前序/中序/后序的递归结构遍历 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Pos
数据结构复习之树与二叉树（上）
千里之行，始于足下
04-22 158
数据结构之树 一、树的基本概念 树是一种重要的数据结构，树是由n(n>=1)个有限结点组成的一个具有层次关系的集合。 树的特点： 每个结点有零个或多个子结点 没有父结点的结点为跟结点 每个非根结点只有一个父结点 每个结点及其后代整体可以看做一棵树，称为当前结点的父结点的一个子树 树的相关术语： 结点的度：一个结点含有的子树的数量称为该结点的度 叶结点：度为零的结点，也可以称为终端结点 ...
C++模板参数替换的理解
weixin_33939380的博客
03-28 494
还是邓俊辉老师数据结构中List那一章的例子。List的遍历问题。 main.cpp里调用PRINT ( La ); // La是一个自定义的List对象 PRINT这个宏的定义就在main.cpp里#define PRINT(x) { print(x); crc(x); checkOrder(x); } print的声明在UniPrint/pri...
C++ 数据结构学习 ---- 向量
qq_58240448的博客
09-20 1150
学习c++数据结构---向量
Java实现 BST 数据结构
最新发布
09-17
BST (二叉搜索树) 是一种特殊的树形数据结构，它的每个节点都有一个值，满足左子树上的所有节点的值均小于它的根节点的值，而右子树上的所有节点的值均大于它的根节点的值。 下面是一个简单的 BST 的 Java 实现： ``` class BST { private class Node { int val; Node left, right; public Node(int val) { this.val = val; } } private Node root; public void insert(int val) { root = insert(root, val); } private Node insert(Node node, int val) { if (node == null) { return new Node(val); } if (val < node.val) { node.left = insert(node.left, val); } else { node.right = insert(node.right, val); } return node; } public boolean search(int val) { return search(root, val); } private boolean search(Node node, int val) { if (node == null) { return false; } if (val == node.val) { return true; } else if (val < node.val) { return search(node.left, val); } else { return search(node.right, val); } } } ``` 以上代码实现了 BST 的插入和查找操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值