数据结构笔记6: 二叉树和其他树

最新推荐文章于 2023-09-13 10:49:33 发布
最新推荐文章于 2023-09-13 10:49:33 发布
阅读量482 收藏 6
点赞数 2
文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Roslin_v/article/details/121121232
版权

树的一般定义

树

  • 线性表、表：不适合描述层次结构数据
  • 树(tree)：是一个非空的有限元素的集合，其中有一个特殊的元素称为根，余下的元素组成树的若干子树
  • 递归的思想：每棵树=根+若干棵子树，每棵子树=子树的根+若干棵它的子树

相关术语

  • 元素：节点
  • 根节点与子树的根节点的关系：边
  • 边的两端：父母(parent)&孩子(children)
  • 相同父母的节点：兄弟(sibling)
  • 叶节点（终端节点）：没有孩子的节点
  • 根节点(root)：没有父亲的节点
  • 层(level)：根为1，根的孩子为2，……
  • 节点的度(degree)：孩子的数目

树的种类

  • 自由树：根不确定，但可以设定一个根，能够确定其层级结构
  • 有根树：节点无顺序
  • 有序树：节点是有顺序的，在左边还是右边不一样

森林和有序森林

  • 森林(forest)：树的集合，通常认为是有根树的集合
  • 有序森林(ordered forest)：有序树的有序集合
  • 有根（有序）树去掉根节点➡️（有序）森林
    （有序）森林添加辅节点➡️有根（有序）树 

二叉树的定义

二叉树的定义

  • 二叉树(binary tree)：有限元素集合，或者为空，或者有一个特殊元素根，余下的元素构成2个二叉树（可以为空），即左子树和右子树

二叉树的种类

  • 满二叉树：高度为h，节点数为2^h-1
  • 完全二叉树：高度为h的满二叉树中节点按从上到下，从左到右的顺序从1到2^h-i进行编号，从中删除编号最后的k个节点，编号为2^h-i, 1\leq i\leq k，深度为[{log_{2}}^{n+1}]

二叉树的特性

  • 二叉树的高度为h,h\geq 0,则它至少有h个节点，最多有2^h-1个节点
  • 包含n个节点的二叉树的高度，最大为n，最小为[{log_{2}}^{n+1}]
  • 设完全二叉树中一节点的序号为i, 1\leq i\leq n，则
    （1）i=1时，该元素为二叉树的根；若i> 1，则该元素父节点的编号为[\frac{i}{2}]
    （2）2i> n时，该元素无左孩子，否则，其左孩子的编号为2i
    （3）2i+1>n时，该元素无右孩子，否则，其右孩子编号为2i+1
  • 设二叉树中度为2的节点有n_{2}个，度为1的节点有n_{1}个，度为0的节点有n_{0}个，则n_{0}=n_{2}+1

    n_{0}=(\sum_{i=1}^{n}(i-1)n_{i})+1

二叉树的描述

公式化描述

  • 用一个一维数组当作一个完全二叉树，缺少节点的位置空出来 ➡️浪费空间，且节点的位置之间没有内在约束关系

链表描述

  • 树节点：节点类对象，包含数据域、left、right
  • n-1条边 ➡️ 2n-(n-1)=n+1个空指针
template<class T>
class BinaryTreeNode {
public:
    BinaryTreeNode() {
        LeftChild = RightChild = 0;
    }
    BinaryTreeNode(const T& e) {
        data = e; 
        LeftChild = RightChild = 0;
    }
    BinaryTreeNode(const T& e, BinaryTreeNode *l, BinaryTreeNode *r){
        data = e; 
        LeftChild = l; 
        RightChild = r;
    }
private:
    T data;
    //BinaryTreeNode *parent; 方便寻找父节点
    BinaryTreeNode *leftchild;
    BinaryTreeNode *rightchild;
}

template<class T> 
class BinaryTree { 
public:
    BinaryTree() {
        root = 0;}
    ; 
    ~BinaryTree(){};
    bool IsEmpty() const{ //根据是否有根来判断二叉树是否为空
        return ((root) ? false : true);
    } 
    bool Root(T& x) const; //返回二叉树的根
    void MakeTree(const T& element,
    BinaryTree<T>& left, BinaryTree<T>& right); 
    void BreakTree(T& element, BinaryTree<T>& left,BinaryTree<T>& right);
    void PreOrder(void(*Visit)(BinaryTreeNode<T> *u)){ //先序遍历
        PreOrder(Visit, root);
    }
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u)) { //中序遍历
        InOrder(Visit, root);
    }
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u)) { //后序遍历
        PostOrder(Visit, root);
    }
    void LevelOrder(void(*Visit)(BinaryTreeNode<T> *u)); //层级遍历
private:
    BinaryTreeNode<T> *root; //根指针
    void PreOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t); 
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t); 
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t); 
};

template<class T>
bool BinaryTree<T>::Root(T& x) const { //把根节点数据存在x里，如果不存在根节点，返回false
    if (root) {
        x = root->data; 
        return true;
    }
    else 
        return false; 
}

template<class T>
void BinaryTree<T>::MakeTree(const T& element,BinaryTree<T>& left, BinaryTree<T>& right){ //合成二叉树
    root = new BinaryTreeNode<T> (element, left.root, right.root);
    left.root = right.root = 0; 
}

template<class T>
void BinaryTree<T>::BreakTree(T& element,BinaryTree<T>& left, BinaryTree<T>& right){ //分裂二叉树
    if (!root) //检查是否为空
        throw BadInput(); 
    element = root->data; 
    left.root = root->LeftChild; 
    right.root = root->RightChild;
    delete root; 
    root = 0;
}

template <class T>
int BinaryTree<T>::Height(BinaryTreeNode<T> *t) const{ //计算高度的递归函数
    if (!t) return 0; 
    int hl = Height(t->LeftChild); 
    int hr = Height(t->RightChild); 
    if (hl > hr) 
        return ++hl;
    else 
        return ++hr;
}

template <class T>
int BinaryTree<T>::Size(BinaryTreeNode<T> *t) const{ //统计节点数目
    if (!t) 
        return 0;
    else 
        return Size(t->LeftChild)+Size(t- >RightChild)+1;
}

二叉树的遍历

先序、中序、后序遍历（深度优先）

  • 按照某种顺序访问树中的每个节点，要求每个节点被访问一次且仅被访问一次
  • 遍历顺序（递归）
    （1）先序遍历：根节点➡️左子树➡️右子树
    （2）中序遍历：左子树➡️根节点➡️右子树   
    （3）后序遍历：左子树➡️右子树➡️根节点
//先序遍历
template<class T>
void PreOrder(BinaryTreeNode<T> *t){ //二叉树的根节点
    if (t) {
        Visit(t);
        PreOrder(t->LeftChild); 
        PreOrder(t->RightChild); 
    }
}

//中序遍历
template <class T>
void InOrder(BinaryTreeNode<T> *t) {
    if (t) {
        InOrder(t->LeftChild);
        Visit(t);
        InOrder(t->RightChild);
    }
}

//后序遍历
template <class T>
void PostOrder(BinaryTreeNode<T> *t) {
    if (t) {
        PostOrder(t->LeftChild); 
        PostOrder(t->RightChild); 
        Visit(t); 
    } 
}
  • 输出完全括号化的中缀表达式
template <class T>
void Infix(BinaryTreeNode<T> *t) {
    if (t) {
        cout << '(';
        Infix(t->LeftChild); 
        cout << t->data; 
        Infix(t->RightChild); 
        cout << ')';
    }
}

逐层遍历（宽度优先）

  • 根➡️叶逐层遍历，同层从左到右
template<class T>
void LevelOrder(BinaryTreeNode<T> *t){ //二叉树的根节点
    LinkedQueue<BinaryTreeNode<T>*> Q; //记录同一层的节点
    while(t){
        Visit(t);
        if(t->LeftChild)
            Q.Add(t->LeftChild);
        if(t->RightChild)
            Q.Add(t->RightChild);
        try{
            Q.Delete(t); //把队首元素取出来，放到t里面
        } catch(OutOfBounds){
            return;
        }
    }
}

由遍历顺序推导二叉树结构

二叉树和森林的互转

  • 一般树
    （1）父指针表示法：无法寻找
    （2）左孩子右兄弟指针表示法 ➡️ 二叉树（一定没有右子树）
  • 森林转换为二叉树
    （1）每棵树单独转换成一棵二叉树
    （2）把每棵树接在第一棵树的右子树上

作业6

用循环数组实现双端队列

template<typename T>
class doubleQueue{
public:
    doubleQueue<T>& create(int m);
    bool isEmpty();
    bool isFull();
    doubleQueue<T>& addLeft(T t);
    doubleQueue<T>& addRight(T t);
    T getLeft();
    T getRight();
    doubleQueue<T>& deleteLeft();
    doubleQueue<T>& deleteRight();
    void print();
private:
    T *dq;
    int maxSize;
    int capacity;
    int left; //最左端元素所在的位置的前一个
    int right; //最右端元素所在的位置的后一个
};

template<typename T>
doubleQueue<T>& doubleQueue<T>::create(int m){
    maxSize=m;
    dq=new T[maxSize];
    left=0;
    right=0;
    capacity=0;
    return *this;
}

template<typename T>
bool doubleQueue<T>::isEmpty(){
    if(capacity==0)
        return true;
    else
        return false;
}

template<typename T>
bool doubleQueue<T>::isFull(){
    if(capacity==maxSize)
        return true;
    else
        return false;
}

template<typename T>
doubleQueue<T>& doubleQueue<T>::addLeft(T t){
    if(isFull()){
        cout<<"FULL!"<<endl;
        return *this;
    }
    if(left==right)
        right=(right+1)%maxSize;
    dq[left]=t;
    capacity++;
    left--;
    if(left<0)
        left=maxSize-1;
    return *this;
}

template<typename T>
doubleQueue<T>& doubleQueue<T>::addRight(T t){
    if(isFull()){
        cout<<"FULL!"<<endl;
        return *this;
    }
    if(left==right){
        left--;
        if(left<0)
            left=maxSize-1;
    }
    dq[right]=t;
    capacity++;
    right=(right+1)%maxSize;
    return *this;
}

template<typename T>
T doubleQueue<T>::getLeft(){
    return dq[(left+1)%maxSize];
}

template<typename T>
T doubleQueue<T>::getRight(){
    int index=right-1;
    if(index<0)
        index=maxSize-1;
    return dq[index];
}

template<typename T>
doubleQueue<T>& doubleQueue<T>::deleteLeft(){
    if(isEmpty())
        cout<<"WRONG!"<<endl;
    left=(left+1)%maxSize;
    dq[left]=-1;
    capacity--;
    return *this;
}

template<typename T>
doubleQueue<T>& doubleQueue<T>::deleteRight(){
    if(isEmpty())
        cout<<"WRONG!"<<endl;
    right--;
    if(right<0)
        right=maxSize-1;
    dq[right]=-1;
    capacity--;
    return *this;
}

template<typename T>
void doubleQueue<T>::print(){
    if(isEmpty()){
        cout<<"EMPTY!"<<endl;
        return;
    }
    for(int i=(left+1)%maxSize;i!=right;i=(i+1)%maxSize)
        cout<<dq[i]<<" ";
    cout<<endl;
}

int main(){
    int t;
    cout<<"Please input double-queue's max size!"<<endl;
    cin>>t;
    doubleQueue<int> DQ;
    DQ.create(t);
    string command;
    cout<<"Please input command!"<<endl;
    cin>>command;
    while(command!="End"){
        if(command=="AddLeft"){
            cin>>t;
            DQ.addLeft(t);
            DQ.print();
        }
        else if(command=="AddRight"){
            cin>>t;
            DQ.addRight(t);
            DQ.print();
        }
        else if(command=="GetLeft")
            DQ.getLeft();
        else if(command=="GetRight")
            DQ.getRight();
        else if(command=="DeleteLeft"){
            DQ.deleteLeft();
            DQ.print();
        }
        else if(command=="DeleteRight"){
            DQ.deleteRight();
            DQ.print();
        }
        else if(command=="IsEmpty"){
            if(DQ.isEmpty())
                cout<<"Yes"<<endl;
            else
                cout<<"No"<<endl;
        }
        else if(command=="IsFull"){
            if(DQ.isFull())
                cout<<"Yes"<<endl;
            else
                cout<<"No"<<endl;
        }
        cout<<"Please input command!"<<endl;
        cin>>command;
    }
    return 0;
}

构造并输出中缀表达式树

//a+b+c*(d+e)
//缺陷：存储方式不是以完全二叉树形式存储，时间性能较差

void findDelete(string& str){ //删除表达式中的括号
    string temp;
    for(int i=0;i<str.length();i++){
        if(str[i]=='('||str[i]==')'){
            temp=str.substr(0,i)+str.substr(i+1,str.length()-i-1);
            str=temp;
        }
    }
}

template<typename T>
class BinaryTree;

template<typename T>
class node{
    friend BinaryTree<T>; //声明友元
public:
    node(){
        parent=leftchild=rightchild=NULL;
    }
    node(const T& t){
        data=t;
        parent=leftchild=rightchild=NULL;
    }
    node(const T& t,node *l,node*r){
        data=t;
        leftchild=l;
        rightchild=r;
        leftchild->parent=this;
        rightchild->parent=this;
    }
    T data;
    node<T> *parent; //父节点
    node<T> *leftchild;
    node<T> *rightchild;
};

static int indent; //控制缩进的静态量

template<typename T>
class BinaryTree{
public:
    BinaryTree(){
        root=NULL;
    }
    bool isEmpty(){
        return ((root==NULL)? true:false);
    }
    node<T>* getRoot(){ //返回根节点
        return root;
    }
    node<T>* findLast(){ //找到最后一个叶节点并输出
        node<T>* t=root;
        while(t->rightchild){
            t=t->rightchild;
            indent++;
        }
        for(int i=0;i<2*indent;i++)
            cout<<" ";
        cout<<t->data<<endl;
        return t;
    }
    void combine(const T& t,BinaryTree<T>& left,BinaryTree<T>& right){ //合并树
        root=new node<T>(t,left.root,right.root);
        left.root=right.root=NULL;
    }
    void inorder(node<T> *t); //中序遍历输出
    BinaryTree<T>& store(string exp); //存储中缀表达式
private:
    node<T> *root; //根节点
};

template<typename T>
BinaryTree<T>& BinaryTree<T>::store(string exp){
    int i=0;
    for(;i<exp.length();i++){ //找到运算符
        if(exp[i]=='+'||exp[i]=='-'||exp[i]=='*'||exp[i]=='/')
            break;
    }
    if(i==exp.length()){ //如果运算符两边的表达式只有一个字母
        root=new node<T>(exp[0]);
        return *this;
    }
    string tempLeft,tempRight; //把运算符两边分开成两个表达式
    tempLeft=exp.substr(0,i);
    tempRight=exp.substr(i+1,exp.length()-i-1);
    BinaryTree<T> leftTree,rightTree;
    combine(exp[i], leftTree.store(tempLeft), rightTree.store(tempRight)); 
    //递归调用store
    return *this;
}

template <typename T>
void BinaryTree<T>::inorder(node<T> *t) {
    t=t->parent;
    for(int i=0;i<2*(indent-1);i++)
        cout<<" ";
    cout<<t->data<<endl;
    for(int i=0;i<2*indent;i++)
        cout<<" ";
    cout<<t->leftchild->data<<endl;
    indent--;
    if(t->parent){
        inorder(t);
    }
}

int main(){
    string exp;
    cin>>exp;
    BinaryTree<char> expression;
    findDelete(exp);
    expression.store(exp);
    expression.inorder(expression.findLast());
    return 0;
}
//a+b+c*(d+e)
 
template<typename T>
class BinaryTree;
 
template<typename T>
class node{
    friend BinaryTree<T>; //声明友元
public:
    node(){
        leftchild=rightchild=NULL;
    }
    node(const T& t){
        data=t;
        leftchild=rightchild=NULL;
    }
    node(const T& t,node *l,node*r){
        data=t;
        leftchild=l;
        rightchild=r;
    }
    T data;
    node<T> *leftchild;
    node<T> *rightchild;
};
 
template<typename T>
class BinaryTree{
public:
    BinaryTree(){
        root=NULL;
    }
    bool isEmpty(){
        return ((root==NULL)? true:false);
    }
    node<T>* getRoot(){ //返回根节点
        return root;
    }
    void inorder(node<T> *t,int begin); //中序遍历输出
    void makeTree(stack<node<T>*> &s){ //存入二叉树
        node<char> *p=new node<char>(expre.top());
        expre.pop();
        p->rightchild=s.top();
        s.pop();
        p->leftchild=s.top();
        s.pop();
        s.push(p);
        root=p;
    }
    BinaryTree<T>& store(string exp); //存储中缀表达式
private:
    stack<char> expre; //储存表达式字符的栈
    stack<node<T>*> binaryTreeNode; //储存子树的根节点
    node<T> *root; //根节点
};
 
template<typename T>
BinaryTree<T>& BinaryTree<T>::store(string exp){
    for(int i=0;i<exp.length();i++){ //遍历表达式
        if(exp[i]=='(') //如果遇到左括号
            expre.push(exp[i]); //压栈
        else if(exp[i]==')'){ //如果遇到右括号
            while(expre.top()!='(') //把两个括号之间的表达式存入二叉树
                makeTree(binaryTreeNode);
            expre.pop(); //把左括号弹出
        }
        else if(exp[i]=='+'||exp[i]=='-'){ //如果遇到+ -
            if(!expre.empty()){ //当表达式栈不为空
                while(expre.top()=='*'||expre.top()=='/') //如果栈顶是* /则先算
                    makeTree(binaryTreeNode);
            }
            expre.push(exp[i]); //记得把+ -压栈
        }
        else if(exp[i]=='*'||exp[i]=='/') //如果遇到* / 优先级最高，直接压栈
            expre.push(exp[i]);
        else{ //默认除了上述操作符以外就是操作数
            node<char> *p=new node<char>(exp[i]);
            binaryTreeNode.push(p); //放入子树的根节点栈
        }
    } //遍历结束
    while(expre.top()=='*'||expre.top()=='/') //计算* /
        makeTree(binaryTreeNode);
    stack<node<T>*> temp;
    while(!binaryTreeNode.empty()){ //子树的根节点栈不为空时
        temp.push(binaryTreeNode.top()); //入栈
        binaryTreeNode.pop();
    }
    while(expre.size()!=0) //把剩下的表达式字符存入树中
        makeTree(temp);
    return *this;
}
 
template <typename T>
void BinaryTree<T>::inorder(node<T> *t,int indent) { //indent用来记录缩进
    node<char> *p=t;
    if(p){
        inorder(p->leftchild,indent+1); //递归输出左子树
        cout<<setw(3*indent)<<" "<<p->data<<endl; //输出根
        inorder(p->rightchild,indent+1); //递归输出右子树
    }
}
 
int main(){
    string exp;
    cin>>exp;
    BinaryTree<char> expression;
    expression.store(exp);
    expression.inorder(expression.getRoot(),0);
    return 0;
}

二叉树 

// 1 2 3 4 5 6 7 8 9 10
// 1 3 2 7 6 5 4 10 9 8

template<typename T>
class BinaryTree;
 
template<typename T>
class node{
    friend BinaryTree<T>; //声明友元
public:
    node(){
        leftchild=rightchild=NULL;
    }
    node(const T& t){
        data=t;
        leftchild=rightchild=NULL;
    }
    node(const T& t,node *l,node*r){
        data=t;
        leftchild=l;
        rightchild=r;
    }
    T data;
    node<T> *leftchild;
    node<T> *rightchild;
};

template<typename T>
class BinaryTree{
public:
    BinaryTree(){
        root=NULL;
    }
    bool isEmpty(){
        return ((root==NULL)? true:false);
    }
    node<T>* getRoot(){ //返回根节点
        return root;
    }
    int size(node<T> *t){ //返回节点的数目
        if(!t)
            return 0;
        else
            return size(t->leftchild)+size(t->rightchild)+1;
    }
    void combine(const T& t,BinaryTree<T>& left,BinaryTree<T>& right){ //合并树
        root=new node<T>(t,left.root,right.root);
        left.root=right.root=NULL;
    }
    node<T>* store(T *t,int len,int index){ //以完全二叉树的形式存储数据
        if(index>=len)
            return NULL;
        node<T> *temp=new node<T>;
        temp->data=t[index];
        temp->leftchild=store(t,len,index*2+1); //映射关系
        temp->rightchild=store(t,len,index*2+2);
        root=temp;
        return root;
    }
    void swap(node<T> *t){ //交换二叉树里所有的左右子树
        if(t->leftchild||t->rightchild){ //只要左子树或右子树存在
            node<T> *temp=t->leftchild;
            t->leftchild=t->rightchild;
            t->rightchild=temp;
        }
        if(t->leftchild)
            swap(t->leftchild); //在左子树内部实行交换
        if(t->rightchild)
            swap(t->rightchild);
    }
    void levelOrder(node<T> *t){ //以层级遍历输出数据
        queue<node<T>*> q; //存储有左右子树的节点
        while(t){
            cout<<t->data<<" ";
            if(t->leftchild)
                q.push(t->leftchild); //入队
            if(t->rightchild)
                q.push(t->rightchild);
            if(!q.empty()){
                t=q.front();
                q.pop(); //出队
            }
            else //队列为空时退出（仅限于完全二叉树）
                break;
        }
        cout<<endl;
    }
    int width(node<T> *t){ //返回二叉树的宽度，即同一层最多的叶节点数
        queue<node<T>*> q;
        int w=0;
        while(t){
            if(t->leftchild)
                q.push(t->leftchild);
            if(t->rightchild)
                q.push(t->rightchild);
            if(q.size()>w)
                w=q.size()-1;
            if(!q.empty()){
                t=q.front();
                q.pop();
            }
            else
                break;
        }
        return w;
    }
private:
    node<T> *root; //根节点
};

int main(){
    BinaryTree<int> b;
    int n;
    cin>>n;
    int *p=new int[n];
    for(int i=0;i<n;i++)
        cin>>p[i];
    b.store(p, n, 0);
    b.levelOrder(b.getRoot());
    cout<<"There are "<<b.size(b.getRoot())<<" leaf nodes."<<endl;
    cout<<"The with of this binary tree is "<<b.width(b.getRoot())<<endl;
    b.swap(b.getRoot());
    cout<<"Swaped binary tree:"<<endl;
    b.levelOrder(b.getRoot());
    return 0;
}

Roslin_v
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构笔记：二叉树
01-20
分类目录——数据结构笔记 二叉树：每个节点最多含有两个子树的树称为二叉树 二叉树的性质 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 深度为k的二叉树至多有2^k-1个结点（k>0） 对于任意一棵二叉树，如果其叶...
数据结构与算法——树和二叉树***
随意的风的专栏
08-26 962
第五章 ：树和二叉树 树和图是两种重要的非线性结构。线性结构中结点具有唯一前驱和唯一后继的关系，而非线性结构中结点之间的关系不再具有这种唯一性。其中，树形结构中结点间的关系是前驱唯一而后继不唯一，即元素之间是一对多的关系；在图结构中结点之间的关系是前驱、后继均不唯一，因此也就无所谓前驱、后继了。直观地看，树形结构既有分支关系，又具有层次关系，它非常类似于自然界中的树。树形结构在现实世界中广泛存在...
Java集合细究之TreeSet和TreeMap的两种排序方式
weixin_66813230的博客
03-15 2129
一、TreeSet比较常见形式 TreeSet可以对元素按照某种规则进行排序： public class test { public static void main(String[] args) { Set<Integer> s1=new TreeSet<>(); s1.add(23); s1.add(3); s1.add(2); s1.add(13); ...
JAVA TreeSet集合存储 TreeMap集合存取 知识点[案例+代码+总结]
心态的博客
05-10 1816
JAVA TreeSet集合存储 TreeMap集合存取 知识点[案例+代码+总结] 理解与HashSet集合、HashMap集合不同的地方。
现在用Set集合邦邦两拳打面试官的脸吧！别用针扎了~~
X6954636的博客
07-26 357
请添加vx小助手：xiehuangbao1123 领取java全套学习资料 Set集合 Set集合概述和特点【应用】 无序不可重复 没有索引,不能使用普通for循环遍历。可以使用 迭代器 或者 增强foreach语句 遍历 TreeSet集合 TreeSet集合概述和特点【应用】 无序不可重复 没有索引 可以将元素按照规则进行排序（特色） TreeSet()：根据其元素的自然排序进行排序 TreeSet(Comparator comparator) ：根据指定的比较器进行排序 TreeS..
树（Tree）和二叉树（Binary Tree）——（概念篇）
2301_78995005的博客
09-13 125
1、树的基本概念及结构2、二叉树的概念及结构以上是树和二叉树的基本概念和性质，学好树和二叉树为以后高阶数据结构打下稳固基础，奥利给！！！
数据结构复习笔记-树和二叉树推荐.pdf
03-13
数据结构复习笔记-树和二叉树推荐.pdf
清华严蔚敏《数据结构》 树和二叉树
05-06
清华严蔚敏《数据结构》教学笔记(加学习要点、习题答案)
Python—-数据结构—-树—–二叉树
12-22
二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree） 二叉树的性质 性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 性质2: 深度为k的二叉树至多...
数据结构笔记.docx
12-19
数据结构笔记 数据结构是计算机科学中的一门重要学科，涉及到数据的存储、表示和操作等方面。本笔记涵盖了数据结构的基本概念、线性表、栈和队列、树、图、排序和查找等重要知识点。 一、数据结构的基本概念 数据...
数据结构-树和二叉树01（定义、度、深度、有序树、森林）
热门推荐
路漫漫其修远兮
02-23 1万+
树的定义 树作为一种一对多的数据结构，其定义如下：            树（Tree）是n（n ≥ 0）个结点得有限集。n = 0时称为空树。在任何一颗非空树中： （1）有且仅有一个特定的称为根（Root）的结点； （2）当n &gt; 1时，其余结点可分为m（m &gt; 0）个互不相交的有限集，其中每个集合本事又是一棵树，并且称为根的子树。       图中，A为根结点A，...
理论基础 —— 二叉树 —— 树、森林、二叉树的转换
Alex_McAvoy的博客
06-09 474
【概述】 从树的孩子兄弟表示法和二叉树的二叉链表表示可以看出，树的孩子兄弟表示法实质上是二叉树的二叉链表存储形式，第一个孩子指针和右兄弟指针分别相当于二叉链表的左孩子指针和右孩子指针。 因此，从物理结构上看，树的孩子兄弟表示法和二叉树的二叉链表是相同的，只是解释不同。 以二叉链表为媒介，可导出树与二叉树的对应关系，即给出一棵树，可以找到唯一的一棵二叉树与之对应，这样树的操作实现就可借助二叉树...
java 基本二叉树实现
joob000的博客
07-25 135
二叉树的实现：       //传入值         boot.date=temp.charAt(0);       //传入左子树         boot.lson=maketree(temp.charAt(0)+" 的左子树");       //传入右子树         boot.rson=maketree(temp.charAt(0)+" 的右子树");         ret...
牛客网二叉树题解
antRain的博客
07-21 501
牛客网二叉树题解
二叉树类BinaryTree
haojiani00的博客
10-25 691
二叉树是结点的有限集合, 该集合或者为空集, 或者是由一个根和两棵互不相交的称为该根的左子树和右子树的二叉树组成. 二叉树可以为空集, 可以有空二叉树, 也可以有空的左子树 或/和 又子树. 二叉树的性质: 1.第i层至多有2^(i - 1)个结点. 2.高度为h的二叉树上至多有2*h - 1个结点. 3.包含n个元素的二叉树高度至少为>= log2(n + 1)取整. 3.任意
java实现二叉树的建立及遍历方法
csuccm的专栏
05-01 962
写一个树的结点类：          public class TreeNode {     private Object value;//结点取值     private TreeNode lChild;//结点的左子树     private TreeNode rChild;//结点的右子树     public Object getValue() {         retu
二叉树操作的总结
ALTLI的博客
12-09 389
1.根据前序序列和中序序列创建二叉树 2.求二叉树中节点的个数 3.求二叉树中叶子节点的个数 4.求二叉树的高度 5.求二叉树的宽度 6.求二叉树第K层的节点个数 7.判断二叉树是否是完全二叉树 8.求二叉树中节点的最大距离 9.求二叉树中两个节点的最近公共祖先节点 10.输出一个二叉树的前序序列 11.输出一个二叉树的中序序列 12.输出一个二叉树的后序序列 13.输出一个二叉树的层次序列 14.左右子树互换 15.判断两棵树是否是相同 16.判断第二棵树是否是第一棵树的子树 17.合并两棵二叉树 18.
数据结构 二叉树笔记
最新发布
12-24
二叉树是一种常见的数据结构，它由节点和边组成。每个节点最多有两个子树，分别称为左子树和右子树。二叉树具有以下性质： 1. 在二叉树的第i层上，最多有2^(i-1)个节点（i>0）。 2. 深度为k的二叉树最多有2^k-1个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值