数据结构笔记9-二叉树

最新推荐文章于 2022-05-08 11:23:17 发布
最新推荐文章于 2022-05-08 11:23:17 发布
阅读量679 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43632507/article/details/103110570
版权

二叉树的定义
二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一
个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。

二叉树的特点：
①每个结点最多有两棵子树；
②二叉树是有序的，其次序不能任意颠倒。
注意：二叉树和树是两种树结构。

特殊的二叉树
一、斜树
1.所有结点都只有左子树的二叉树称为左斜树；
2.所有结点都只有右子树的二叉树称为右斜树；
3.左斜树和右斜树统称为斜树。
斜树的特点：
1.在斜树中，每一层只有一个结点；
2.斜树的结点个数与其深度相同。
二、满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
满二叉树的特点：
1.叶子只能出现在最下一层；
2.只有度为0和度为2的结点。
满二叉树在同样深度的二叉树中结点个数最多
满二叉树在同样深度的二叉树中叶子结点个数最多
三、完全二叉树
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满
二叉树中编号为i的结点在二叉树中的位置完全相同。
在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树。
完全二叉树的特点
1.叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；
2.完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。
3.深度为k的完全二叉树在k-1层上一定是满二叉树。

二叉树性质：①二叉树的第i层上最多有2i-1个结点（i≥1）
②一棵深度为k的二叉树中，最多有2k-1个结点，最少有k个结点。
③在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。 
④具有n个结点的完全二叉树的深度为 log2n +1。
⑤对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为
i（1≤i≤n）的结点（简称为结点i），有： 
（1）如果i＞1，
    则结点i的双亲结点的序号为  i/2；如果i＝1，
    则结点i是根结点，无双亲结点。 
(2)如果2i≤n，
    则结点i的左孩子的序号为2i；
    如果2i＞n，则结点i无左孩子。 
(3)如果2i＋1≤n，
    则结点i的右孩子的序号为2i＋1；如果2i＋1＞n，则结点 i无右孩子。

二叉树的遍历操作
二叉树的遍历是指从根结点出发，按照某种次序访问二叉树中的所有结点，使得每个结
点被访问一次且仅被访问一次。

前序（根）遍历
若二叉树为空，则空操作返回；否则：
①访问根结点；
②前序遍历根结点的左子树；
③前序遍历根结点的右子树。

中序（根）遍历
若二叉树为空，则空操作返回；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树。
 
后序（根）遍历
若二叉树为空，则空操作返回；否则：
①后序遍历根结点的左子树；
②后序遍历根结点的右子树。
③访问根结点。

层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同
一层中，则按从左到右的顺序对结点逐个访问。

二叉树的存储结构及实现
顺序存储结构
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置
（下标）应能体现结点之间的逻辑关系——父子关系。
#include<bits/stdc++.h>
#include<cstring>
using namespace std;

void Preorder(int root, char data[])
{
    if(data[root]!='\0')
    {
        cout<<data[root];

        Preorder(2*root,data);
        Preorder(2*root+1,data);

    }
    return;
}
void InOrder(int root, char data[])
{
    if(data[root]!='\0')
    {
        InOrder(2*root,data);
        cout<<data[root];
        InOrder(2*root+1,data);
    }
    return;
}
void PostOrder(int root, char data[])
{
    if(data[root]!='\0')
    {
        PostOrder(2*root,data);
        PostOrder(2*root+1,data);
        cout<<data[root] ;
    }
    return;
}
void create(char Preorder[],char Inorder[],int start_p, int end_p,
    int start_i,int end_i, char data[],int root)
{
    if(start_p>end_p)
    return;
    else{
        int k;
        for(int i=start_i;i<=end_i;i++)
        {
            if(Inorder[i]==Preorder[start_p])
            {
                k=i;
                break;
            }
        }
        data[root]=Preorder[start_p];
        create(Preorder,Inorder,start_p+1,start_p+k-start_i,start_i,k-1,data, 2*root);
        create(Preorder,Inorder,start_p+k-start_i+1,end_p,k+1,end_i,data,2*root+1);
    }
    return;
}

int main()
{

    int total=1;
    char preorder[100],inorder[100];
    cin>>preorder>>inorder;
    int length=0;
    while(preorder[length]!='\0')
        length++;
    char *data=new char[(int)pow(2,length+1)];
    memset(data,'\0',pow(2,length+1));
    create(preorder,inorder,0,length-1,0,length-1,data,1);
    PostOrder(1,data);
    return 0;
}

二叉链表
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有
关的数据信息外，还要设置指示左右孩子的指针。
结点结构： lchild  data  rchild
data：数据域，存放该结点的数据信息；
lchild：左指针域，存放指向左孩子的指针；
rchild：右指针域，存放指向右孩子的指针。
#include<iostream>
#include<cstring>
using namespace std;

struct Node{
    char data;
    Node *lchild,*rchild;
};
class Tree{
    Node *root;
    Node *creat();
    void release(Node *root);
    void qian(Node *root);
    void zhong(Node *root);
    void hou(Node *root);
public:
    Tree(){root=creat();}
    ~Tree(){release(root);}
    void qian(){qian(root);}
    void zhong(){zhong(root);}
    void hou(){hou(root);}
};
Node *Tree::creat(){
    Node *root;
    char c;
    cin>>c;
    if(c=='#') root=NULL;
    else{
        root=new Node;
        root->data=c;
        root->lchild=creat();
        root->rchild=creat();
    }
    return root;
}
void Tree::release(Node *root){
    if(root==NULL) return;
    else{
        release(root->lchild);
        release(root->rchild);
        delete root;
    }
}
void Tree::qian(Node *root){
    if(root==NULL) return;
    else{
        cout<<root->data;
        qian(root->lchild);
        qian(root->rchild);
    }
}
void Tree::zhong(Node *root){
    if(root==NULL) return;
    else{
        zhong(root->lchild);
        cout<<root->data;
        zhong(root->rchild);
    }
}
void Tree::hou(Node *root){
    if(root==NULL) return;
    else{
        hou(root->lchild);
        hou(root->rchild);
        cout<<root->data;
    }
}
前序遍历——非递归算法（伪代码）
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空 
　2.1 当root不空时循环
　　2.1.1 输出root->data;
    　2.1.2 将指针root的值保存到栈中；
    　2.1.3 继续遍历root的左子树（root=root->lchild）
　2.2 如果栈s不空，则
　　2.2.1 将栈顶元素弹出至root（root=s.pop()）；
　　2.2.2 准备遍历root的右子树(root=root->rchild)； 
template <class T>
void BiTree::PreOrder(BiNode<T> *root) {
  SeqStack<BiNode<T> *>  s;
     while (root!=NULL||!s.empty()) {
         while (root!= NULL){
             cout<<root->data;
             s.push（root）;
             root=root->lchild;  
         }
         if(!s.empty()){ 
             root=s.pop();
             root=root->rchild;  
         }
     }
}
中序遍历——非递归算法（伪代码）
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空 
　2.1 当root不空时循环
        2.1.1 将指针root的值保存到栈中；
    　2.1.2 继续遍历root的左子树（root=root->lchild）
　2.2 如果栈s不空，则
　　2.2.1 将栈顶元素弹出至root（root=s.pop()）；
 　　  2.2.2 输出root->data;
　　2.2.3 准备遍历root的右子树(root=root->rchild)； 
template <class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
{
    stack< BiNode<T> * > aStack;
    while(!aStack.empty()||root) {
        while(root){
            aStack.push(root);
            root=root->lchild; 
        }
        if(!aStack.empty()){
            root=aStack.top();                
            aStack.pop(); 
            cout<<root->data;
            root=root->rchild; 
        }
    }
}
层序遍历
1.队列Q初始化；
2. 如果二叉树非空，将根指针入队；
3.  循环直到队列Q为空
      3.1 q=队列Q的队头元素出队；
      3.2 访问结点q的数据域；
      3.3 若结点q存在左孩子，则将左孩子指针入队；
      3.4 若结点q存在右孩子，则将右孩子指针入队；
template<class T>
void BiTree<T>::LevelOrder(BinaryTreeNode<T>* root){
    queue<BiTreeNode<T>*> aQueue;
    if(root)
        aQueue.push(root);
    while(!aQueue.empty())
    {
        root=aQueue.front(); //取队列首结点
         aQueue.pop();
                     cout<<pointer->data;//访问当前结点
        if(root->lchild)    //左子树进队列
            aQueue.push(root->lchild);
        if(root->rchild) //右子树进队列
            aQueue.push(root->rchild);     
    }//end while
}

求二叉树的结点个数
int Tree::count(Node *root){
    int number=0;
    if(root==NULL) number=0;
    else
        number=count(root->lchild)+count(root->rchild)+1;
    return number;
}               
                
统计叶子节点的数目
int Tree::leafcount(Node *root){
    int number=0;
    if(root==NULL)
        number=0;
    else if(root->lchild==NULL&&root->rchild==NULL)
        number=1;
    else
        number=leafcount(root->lchild)+leafcount(root->rchild);
    return number;
}

计算树的高度
int Tree::cal_height(Node *root){
    int lheight=0,rheight=0;
    if(root==NULL) return 0;
    lheight=cal_height(root->lchild);
    rheight=cal_height(root->rchild);
    if(lheight>rheight) return lheight+1;
    else return rheight+1;
}

交换左右子树
void Tree::change(Node *root){
    if(root==NULL) return;
    else{
        swap(root->lchild,root->rchild);
        change(root->lchild);
        change(root->rchild);
    }
}

三叉链表
结点结构：lchild   data    parent    rchild
data、lchild和rchild三个域的含义同二叉链表的结点结构；
parent域为指向该结点的双亲结点的指针。
template<class T>
struct Node
{
    T data;
    Node<T> * lchild, *rchild,*parent;
};
template <class T>
BiNode<T> * BiTree<T>::Creat(BiNode<T> * &root ,BiNode<T> *parent){
    T ch;
    cout<<"请输入创建一棵二叉树的结点数据"<<endl;
    cin>>ch;
    if (ch=="#") root = NULL;
    else{ 
         root = new BiNode<T>;       //生成一个结点
          root->data=ch;
         root->parent=parent;
         Creat(root->lchild,root );    //递归建立左子树
         Creat(root->rchild,root);    //递归建立右子树
    } 
    return root;
}
template<class T>
BiTree<T>::BiTree( int i)
{
    number=0;
    Creat(root,NULL);

}

森林转换为二叉树
⑴ 将森林中的每棵树转换成二叉树；
⑵ 从第二棵二叉树开始，
    依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，
    当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。

二叉树转换为树或森林
⑴ 加线——若某结点x是其双亲y的左孩子，则把结点x的右孩子、右孩子的右孩子、……，都与结点y用线连起来；
⑵ 去线——删去原二叉树中所有的双亲结点与右孩子结点的连线；
⑶ 层次调整——整理由⑴、⑵两步所得到的树或森林，使之层次分明。

森林的遍历
森林有两种遍历方法：
⑴前序（根）遍历：前序遍历森林即为前序遍历森林中的每一棵树。 
⑵后序（根）遍历：后序遍历森林即为后序遍历森林中的每一棵树。

最优二叉树-哈夫曼树及哈夫曼编码
相关概念
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结
点的路径长度与相应叶子结点权值的乘积之和。 
    哈夫曼树：给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。
哈夫曼树的特点：
1. 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。 
2. 只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点.

哈夫曼算法的存储结构
weight  lchild  rchild  parent
weight：权值域，保存该结点的权值；
lchild：指针域，结点的左孩子结点在数组中的下标；
rchild：指针域，结点的右孩子结点在数组中的下标；
parent：指针域，该结点的双亲结点在数组中的下标。
struct element
{     int weight;
      int lchild, rchild, parent;
};
1.数组huffTree初始化，所有元素结点的双亲、左右孩子都置为-1；
2. 数组huffTree的前n个元素的权值置给定值w[n]；
3. 进行n-1次合并
    3.1 在二叉树集合中选取两个权值最小的根结点，
          其下标分别为i1, i2；
    3.2 将二叉树i1、i2合并为一棵新的二叉树k(初值为n；依次递增)；
void HuffmanTree(element huffTree[ ], int w[ ], int n ) {
    for (i=0; i<2*n-1; i++) {
       huffTree [i].parent= -1;
       huffTree [i].lchild= -1;
       huffTree [i].rchild= -1;   
    }
    for (i=0; i<n; i++) 
       huffTree [i].weight=w[i];
    for (k=n; k<2*n-1; k++) {
        Select(huffTree, &i1, &i2); 
        huffTree[k].weight=huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent=k;     
        huffTree[i2].parent=k; 
        huffTree[k].lchild=i1;    
        huffTree[k].rchild=i2;
    }
}

哈夫曼树应用——哈夫曼编码
编码：给每一个对象标记一个二进制位串来表示一组对象。
例：ASCII，指令系统
等长编码：表示一组对象的二进制位串的长度相等。
不等长编码：表示一组对象的二进制位串的长度不相等。

前缀编码：一组编码中任一编码都不是其它任何一个编码的前缀 。
前缀编码保证了在解码时不会有多种可能。

线索二叉树
线索链表
线索：将二叉链表中的空指针域指向前驱结点和后继结点的指针被称为线索；
线索化：使二叉链表中结点的空链域存放其前驱或后继信息的过程称为线索化；
线索二叉树：加上线索的二叉树称为线索二叉树。
结点结构：ltag    data    child   rtag

ltag={
    0: lchild指向该结点的左孩子
    1: lchild指向该结点的前驱结点
}
rtag={
    0: rchild指向该结点的右孩子
    1: rchild指向该结点的后继结点
}
enum flag {Child, Thread}; 
template  <class T>
struct ThrNode
{
     T data;
     ThrNode<T>  *lchild, *rchild;
     flag ltag, rtag;
};
template <class T>
class InThrBiTree{    
   public:
        InThrBiTree();     
         ~ InThrBiTree( );    
        ThrNode *Next(ThrNode<T> *p); 
        void InOrder(ThrNode<T> *root); 
   private:
        ThrNode<T> *root;  
        ThrNode<T> *  Creat(); 
        void ThrBiTree(ThrNode<T> *root);
};
template <class T>ThrNode<T>* InThrBiTree<T>::Creat( ){
    ThrNode<T> *root;
    T ch;
    cout<<"请输入创建一棵二叉树的结点数据"<<endl;
    cin>>ch;
    if (ch=="#") root = NULL;
    else{    
         root=new ThrNode<T>;    
         root->data = ch;
         root->ltag = Child; root->rtag = Child;
         root->lchild = Creat( );
         root->rchild = Creat( ); 
    } 
    return root;
}
中序线索化二叉树：递归实现
基本思想：
在遍历的过程中完成线索化
可以采用前序、中序、后序遍历建立前序线索二叉树、中序线索二叉树和后序线索二叉树。
中序线索二叉树的构造方法
中序线索化根结点的左子树；
对根结点进行线索化；
中序线索化根结点的右子树；
template <class T>  void ThrBiTree<T>::ThrBiTree (ThrNode<T>*root) {
    if (root==NULL) return;         //递归结束条件
    ThrBiTree(root->lchild);     
    if (!root->lchild){             //对root的左指针进行处理
        root->ltag = Thread;   
        root->lchild = pre;        //设置pre的前驱线索
   }
   if (!root->rchild) root->rtag = Thread; 

  if(pre != NULL){
       if (pre->rtag==Thread)  pre->rchild = root; 
  }
   pre = root;
   ThrBiTree(root->rchild);
}
线索二叉树的建立
template <class T>
InThrBiTree<T>::InThrBiTree( )
{ 
    //ThrNode<T>* pre = NULL;
    this->root = Creat( );    
    ThrBiTree(root);
}
在中序线索树中查找结点的中序遍历的后继
template <class T> ThrNode<T>* InThrBiTree<T>::Next(ThrNode<T>* p)
{
    ThrNode<T>* q;  //要查找的p的后继
    if (p->rtag==Thread)   q = p->rchild;
    else{   
        q = p->rchild; 
        while (q->ltag==Child)    {
            q = q->lchild;
        }
    }
    return q;
}
线索链表的遍历算法：中序遍历中序线索树
template <class T> 
void InThrBiTree<T>::InOrder(ThrNode<T> *root){
    ThrNode<T>* p = root;
    if (root==NULL)  return; 
    while (p->ltag==Child)   {       p = p->lchild;    }
    cout<<p->data<<" ";
    while (p->rchild!=NULL) {
        p = Next(p);
        cout<<p->data<<" ";
    }
    cout<<endl;
}

 

十只兔子OVO
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
数据结构与算法----树
weixin_45932712的博客
08-09 738
树树的递归定义 树是由n（n≥0）个节点组成的有限集合（记为T）  如果n=0，它是一棵空树，这是树的特例；  如果n>0  这n个节点中存在（有仅存在）一个节点作为树的根节点，简称为根节点（root）  其余节点可分为m（m>0）个互不相交的有限集T 1 ,T 2 ,…,T m ，其中每一棵子集本身又是一棵符合本定义的树，称为根root的子树。 树的遍历  按照一定次序访问树中所有节点，并且每个节点仅被访问一次的过程。  遍历是最基本的运算，是树中所有其他运算...
三叉链表
No Pain, No Gain .
11-11 4044
在二叉链表的基础上增加了一个指向双亲的指针域。 data、lchild和rchild三个域的含义同二叉链表的结点结构； parent域为指向该结点的双亲结点的指针。 结点数据类型声明： template<class T> struct Node { T data; Node<T> * lchild, *rchild,*parent; }; template &l...
树的概念
WWIandMC的博客
08-01 1398
树的定义 树形式化定义 T={D,R} T=\{D,R\} T={D,R} D是包含n个结点的有限集合（n ≥ 0）。当n=0时为空树，否则关系R满足以下条件： 有且仅有一个结点d0∈D，它对于关系R来说没有前趋结点，结点d0称作树的根结点； 除根检点外，每个结点有且仅有一个前趋结点； D中每个结点可以有0个或多个后继结点。 树的递归定义 树是由n（n ≥ 0）个结点组成的有限集合（记为T）。其中： 如果n = 0，它是一棵空树，这是树的特例； 如果n > 0，其中存在一个唯一结点作为树的根节点
数据结构-单支二叉树
0110_
09-21 5026
简介： 在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 而然单链二叉树是指仅最左侧节点存在孩子节点，如下图所示。结果会导致二叉树很不平衡，但是实现比较简单。 C语法实现： #include<bits/stdc++.h> using names...
二叉树简介
qq_40635938的博客
12-25 1211
二叉树 First. 二叉树和二次树不同，二次树至少有一个结点的度为2，二叉树没有这个要求。 二次树不区分左右子树，二叉树严格区分左右子树 满二叉树： 所有的分支结点都有左右孩子结点，叶子结点在最下面一层 非空满二叉树特点：1.叶子结点在最下面一层 2.只有度为0和2的点 完全二叉树：一层一层从左往右地排，刚好没排完.。所以若是存在度为1的结点，只有一个 二叉树的性质： 非空二叉树上的叶子结...
数据结构笔记：二叉树
01-20
分类目录——数据结构笔记 二叉树：每个节点最多含有两个子树的树称为二叉树 二叉树的性质 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 深度为k的二叉树至多有2^k-1个结点（k>0） 对于任意一棵二叉树，如果其叶...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与...查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
数据结构复习笔记-树和二叉树推荐.pdf
03-13
数据结构复习笔记-树和二叉树推荐.pdf
数据结构与算法-学习笔记 Java 版.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
Python—-数据结构—-树—–二叉树
12-22
二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree） 二叉树的性质 性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 性质2: 深度为k的二叉树至多...
数据结构初阶之二叉树——概念篇
Britney_dark的博客
05-08 2902
就算有一天，离别的时刻来临，但那也不一定意味着永别。
数据结构之二叉树
叫我蘑菇先生
06-04 1058
二叉树 二叉树的定义   在树的基础上加上两个限制条件即可得到二叉树。 （至于什么是度，什么是树等，可以预先了解下再开始下面关于二叉树的内容） 每个子结点最多有两棵子树，二叉树中结点的度只能为0、1、2。 子树有左右区别，不能颠倒。   关于二叉树的形态主要关注两个，一个是满二叉树，另一个是完全二叉树； 满二叉树：叶子结点（终端结点）都在二叉树的最下面一层。 完全二叉树：各个结点编号与深度相同的满二叉树中的结点编号均相同。 联系： 完全二叉树就是由满二叉树由右至左、由下至上依次删除结点所得，这里不能跳
数据结构基础（二）
weixin_33795093的博客
05-10 268
二叉树 二叉树的性质 1、非空二叉树上的叶节点数等于双分支节点数加1.2、非空二叉树上第i层上至多有2^(i-1)个节点，这里应有1>=1.3、高度为h的二叉树至多有2^h - 1 个节点 （h>=1）。4、在二叉树中，如果所有分支节点都有左孩子和右孩子节点，并且叶子节点都集中在二叉树的最下一层，这样的二叉树称为满二叉树。 只有度为0和度为2的节点 叶子节点都在最下一层 5、完全二...
二叉树的前序、中序、后序、层序遍历，递归和迭代两大类解题思路，每类细分不同解法【完整版】附PDF文档
CV前沿
04-03 4965
一、二叉树的前序遍历 二叉树的前序遍历的记忆法则是“根左右"，即先遍历根节点，再遍历左子树节点，再遍历右子树节点。 以上图为例，前序遍历的结果是【A, B, D, E, C, F, G】 1.1 解题思路：递归 递归是我们实现前中后序遍历最常用的方法。 什么问题可以采用递归求解呢？ 需要满足三个条件： 一个问题的解可以分解为若干个子问题的解； 这个问题与分解的子问题，除了数据规模不同外，求解思路相同 存在递归终止条件。 那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？ 关键在于能写出递归
二叉树
shijie
10-16 8435
树的定义：   树是一种数据结构，是由n个有限节点组成的有层次关系的集合（n >= 1）。 树的特点：    1. 每个节点有0个或多个子节点    2. 没有父节点的节点称作根节点    3. 每个非根节点有且只有一个父节点    4. 除了根节点外，每个子节点可以分为多个不相交的子树 什么是节点的度？    节点的度指的是节点所拥有子树的数目 什么是叶子节点？    叶子节点指的是度为0...
完全二叉树标准（详细图解）
热门推荐
@宝藏男孩
02-23 7万+
标准 完全二叉树是效率很高的数据结构。众所周知，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 特点： (1)所有的叶结点都出现在第k层或k-l层（层次最大的两层） (2)对任一结点，如果其右子树的最大层次为L，则其左子树的最大层次为L或L+l。 我想这个概念大部分人都能理解或者早已通...
遍历二叉树（三种遍历方式：左根右(中序)， 根左右(先序)， 左右根(后序)）
lquarius的博客
11-06 2万+
二叉树遍历： 　　顺着一条搜索路径访问二叉树中的节点，每个节点均被访问一次，且只被访问一次。 遍历目的： 　　得到树中所有节点的一个线性排列。 遍历用途： 　　是二叉树元素增删改查等操作的前提。 波兰式（先序）、逆波兰式（后序）等： //定义节点 typedef struct BiNode{ ElemType data;//数据域 struct BiNode *lchild, *rchild;...
二叉树的遍历-先序遍历、中序遍历、后序遍历
CODEING一场空的博客
02-26 2855
树的遍历-先序遍历、中序遍历、后序遍历 先序遍历 二叉树的先序遍历，就是先输出根结点，再遍历左子树，最后遍历右子树，遍历左子树和右子树的时候，同样遵循先序遍历的规则。 /** * 先序遍历 * @param treeNode */ public void preOrder(TreeNode treeNode){ if(treeNode == null){ return; } System.out.p
数据结构之完全二叉树
calm_encode的博客
06-21 1634
一 概述 完全二叉树是指除了最后一层之外，其他每一层的每个节点都是同时含有左右子树。当最后一层的每个节点也都含有左右子树的时候，则为满二叉树，同时也是完全二叉树。如果最后一层不满的时候，非满结点（即没有满足同时拥有左右子树的结点）的子树全部集中在左子树的时候，那也是一个完全二叉树。 二 二叉树的类型图示 满二叉树 完全二叉树 非完全二叉树 非完全二叉树 三 代码实现完全二叉树的判断 ...
数据结构 二叉树笔记
12-24
二叉树是一种常见的数据结构，它由节点和边组成。每个节点最多有两个子树，分别称为左子树和右子树。二叉树具有以下性质： 1. 在二叉树的第i层上，最多有2^(i-1)个节点（i>0）。 2. 深度为k的二叉树最多有2^k-1个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十只兔子OVO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值