二叉树的学习

已于 2023-02-18 13:52:33 修改
阅读量1.3k 收藏 7
点赞数 3
分类专栏： 数据结构（王道） 文章标签： 学习 算法 数据结构
于 2022-11-11 15:13:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/127804395
版权

目录

一、二叉树的基本概念

二、二叉树的性质

（一）二叉树的性质

（二）完全二叉树的常考性质 

三、二叉树的存储结构 

（一）二叉树的顺序存储

（二）二叉树的链式存储结构

四、二叉树的遍历

五、基本操作 

（一）建立二叉链表的3种方法

（二）先序（递归）、中序（递归）、后序（递归）、层次遍历

（三）先序（非递归）、中序（非递归）、后序（非递归）

（三）完整代码

一、二叉树的基本概念

  • 二叉树是n（n>=0）个结点的有限集合

1.或者为空二叉树，即n=0。
2.或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一颗二叉树。
特点：1.每个结点至多只有两棵子树。2.左右子树不能颠倒（二叉树是有序树） 

  •  二叉树的五种状态：

 

  

  • 满二叉树：一棵高度为h，且含有2^h-1个结点的二叉树。
  • 特点：

 

1.只有最后一层有叶子结点。
2.不存在度为1的结点（结点的度要么为2，要么就是0）。
3.按层序从1开始编号，结点i的左孩子为2i，右孩子为2i+1；结点i的父结点为[i/2]（i/2然后舍去小数取整）（如果有的话） 

  • 完全二叉树：当且仅当其每个结点都与高度为h的满二叉树中编号为1到n的结点一一对应时，称为完全二叉树。
  • 特点：

1.只有最后两层可能有叶子结点。
2.最多只有一个度为1的结点。
3.按层序从1开始编号，结点i的左孩子为2i，右孩子为2i + 1；结点i的父结点为[i / 2]（i / 2然后舍去小数取整）（如果有的话）
完全二叉树：当且仅当其每个结点都与高度为h的满二叉树中编号为1到n的结点一一对应时，称为完全二叉树。
4.当i<=[n/2]（取n/2的整数部分）为分支结点，i>[n/2]为叶子结点。 

  • 二叉排序树：一棵二叉树或者空二叉树，或者是具有如下性质的二叉树

1.左子树上所有结点的关键字均小于根结点的关键字
2.右子树上所有结点的关键字均大于根结点的关键字
3.左子树和右子树又各是一棵二叉排序树
补充：二叉排序树可用于元素的排序、搜索 

  • 平衡二叉树：树上任一结点的左子树和右子树的深度之差不超过1 

二、二叉树的性质

（一）二叉树的性质

  • 考点1：设非空二叉树中度为0、1和2的结点个数分别为n0，n1和n2，则n0 = n2 + 1（叶子结点比二分支结点多一个）

分析：假设树中结点总数为n，则
1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；度为1的结点数有n1个，度数和为n1；度为2的结点数有n2个，度数和为2n2。所以总度数为n1 + 2n2）
由上面两式相等得到：n0 + n1 + n2 = n1 + 2n2 + 1，所以n0 = n2 + 1 

  • 考点2：二叉树第i层至多有2 ^ (i - 1)个结点（i >= 1）
  • 考点3：高度为h的二叉树至多有2 ^ h - 1个结点（满二叉树）

分析：第一层有1个结点；第二层有2个结点；第三层有2^2个结点.....第h层有2^(h-1)个结点
总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1 

（二）完全二叉树的常考性质 

  • 考点1：具有n个（n>0）结点的完全二叉树的高度为h为[log2(n+1)]（2的底）或[log2n]+1（2是底）

分析：

  • 考点2：对于完全二叉树，可以由结点数推出度为0、1和2的结点个数为n0、n1和n2

分析：
完全二叉树最多只有一个度为1的结点，即n1=0或1
由于n0=n2+1，所以n0+n2=2n2+1一定是奇数
又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1
若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1 

三、二叉树的存储结构 

（一）二叉树的顺序存储

  • 存储完全二叉树：

按照一组地址连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素 

完全二叉树结点i的的左孩子是2i，右孩子是2i+1，父结点是[i/2]（i/2后取整），所在层次是[log2(n+1)]（2为底） 

  • 不是完全二叉树的顺序存储需要增加空结点

 

  • 顺序存储结构 
//第一种
typedef struct wqbtree
{
    ElemType SBTree[MaxSize];//结点中的数据元素
    int n;//记录结点个数
}Fbitree;

//第二种
typedef ElemType SBTree[MaxSize];

（二）二叉树的链式存储结构

二叉树中每一个结点用链表中的一个结点来存储，结构结点如上图。 

其中data表示值域，用于存储对应的数据元素；lchild和rchild分别表示左指针域和右指针域 ，分别用于存储左孩子结点和右孩子结点的地址。

  • 链式存储结构
typedef struct BTNode
{
    ElemType data;//数据域
    struct BTNode* lchild, * rchild;//左右孩子指针
}BTNode,*BTree;

四、二叉树的遍历

  • 二叉树的递归特性：

      1.要么是个空二叉树
      2.要么就是由“根结点+左子树+右子树”组成的二叉树 

  • 二叉树的遍历是指按照一定的次序访问树中的所有结点，并且每个结点仅被访问一次的过程。
  • 常见的4中递归遍历方法：

    1.先序遍历（DLR）
    第一步：访问根结点；第二步先序遍历左子树；第三步：先序遍历右子树。
    2.中序遍历（LDR）
    第一步：中序遍历左子树；第二步：访问根节点；第三步：中序遍历右子树。
    3.后序遍历（LRD）
    第一步：后序遍历左子树；第二步：后序遍历右子树；第三步：访问根结点。
    4.层序遍历
    第一步：访问根结点（第一层）
    第二步：从左到右访问第2层所有结点。
    第三步：从左到右访问第3层所有结点、....、第h层所有结点。 

五、基本操作 

（一）建立二叉链表的3种方法

BTree Creat(char str[])//先序序列建立二叉链表（方法1）
{
    BTree T;
    static int i = 0;
    ElemType c = str[i++];
    if (c == '#')//输入#表示此结点下不存在分支
    {
        T = NULL;
    }
    else
    {
        T = (BTree)malloc(sizeof(BTree));
        if (T == NULL)
        {
            exit(0);
        }
        T->data = c;
        T->lchild = Creat(str);//递归创建左子树
        T->rchild = Creat(str);//到上一个结点的右边递归创建左右子树
    }
    return T;
}

void CreateBT(BTree& T) // 先序遍历建立二叉链表 （方法2）
{
    ElemType ch;
    cin >> ch;
    if (ch == '^')
        T = NULL;
    else
    {
        T = (BTNode*)malloc(sizeof(BTNode));
        T->data = ch;
        cout << "请输入" << ch << "的左子树：";
        CreateBT(T->lchild);
        cout << "请输入" << ch << "的右子树：";
        CreateBT(T->rchild);
    }
}

void CreatBTNode(BTree& T, char* str)//（方法3）
{
    BTNode* st[MAXSIZE];
    BTNode* p = NULL;
    int top = -1, k, j = 0;
    ElemType ch;
    ch = str[j];
    while (ch != '\0')//str未扫描完的时候循环
    {
        switch (ch)
        {
        case '('://为左孩子结点
            top++;
            st[top] = p;
            k = 1;
            break;
        case ')':
            top--;
            break;
        case ','://为右孩子结点
            k = 2;
            break;
        default:
            p = (BTree)malloc(sizeof(BTree));
            p->data = ch;
            p->lchild = p->rchild = NULL;
            if (T == NULL)//p结点第一次创建
            {
                T = p;
            }
            else
            {
                switch (k)
                {
                case 1:
                    st[top]->lchild = p;//p结点为栈顶结点的左孩子
                    break;
                case 2:
                    st[top]->rchild = p;//p结点为栈顶结点的右孩子
                    break;

                }
            }

        }
        ch = str[++j];//继续扫描下一个字符
    }
}

方法3解释：例如A（B（D（，G）），C（E，F）） 

（二）先序（递归）、中序（递归）、后序（递归）、层次遍历

  • 层次遍历算法思想：遍历从二叉树的根结点开始，首先将根结点入队列，然后进行下面的操作

1.取出队头元素
2.访问该元素所指结点
3.若该元素所指结点的左、右孩子结点非空，则将该元素所指结点的左孩子和右孩子指针入队
4.若队列非空，重复1-3；当队列为空的时候，二叉树的层次遍历结束。 

void PreOrder(BTree T)//先序遍历
{
    if (T != NULL)
    {
        cout << T->data << " ";//访问根结点
        PreOrder(T->lchild);//先序遍历左子树
        PreOrder(T->rchild);//先序遍历右子树
    }
}

void InOrder(BTree T)//中序遍历
{
    if (T != NULL)
    {
        InOrder(T->lchild);
        cout << T->data << " ";
        InOrder(T->rchild);
    }

}
void PostOrder(BTree T)//后序遍历
{
    if (T != NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout << T->data << " ";
    }
}


void LevelOrder(BTree T)//层序遍历
{
    BTNode* p;
    BTNode* qu[MAXSIZE];//定义循环队列，存放结点指针
    int front, rear;//定义头指针和尾指针
    front = rear=0;//置队列为空队列
    rear++;//根结点指针进队
    qu[rear] = T;
    while (front != rear)//队列不为空
    {
        front = (front + 1) % MAXSIZE;//队头指针加1取模
        p = qu[front];//队头结点出队
        cout << p->data << " ";
        if (p->lchild != NULL)
        {
            rear = (rear + 1) % MAXSIZE;//队尾指针加1取模
            qu[rear] = p->lchild;//p结点的左孩子进栈
        }
        if (p->rchild != NULL)
        {
            rear = (rear + 1) % MAXSIZE;
            qu[rear] = p->rchild;//p结点的右孩子进栈
        }
    }
}

（三）先序（非递归）、中序（非递归）、后序（非递归）

  • 先序遍历的关键：在先序遍历某个结点的整个左子树后，如何找到该结点的右子树的根指针？解决方法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。

  • 中序遍历：采用一个栈保存需要回溯的结点地址，先扫描（并非访问根结点）的所有左下结点并将它们一一进栈，然后出栈一个结点，该结点一定没有左孩子结点或者左子树已遍历过，则访问它；然后转向该结点的右孩子结点（如果有），将其进栈，再遍历该右孩子结点的所有左下结点并一一进栈；如此循环，直到栈空并且遍历指针p空为空。

  • 后序遍历：采用一个栈保存需要回溯的结点地址，先扫描根结点的所有左下结点并且一一进栈。将栈顶结点T作为当前结点，如果结点T可以访问，则访问它；否则转向结点T的右子树遍历其右子树。 
bool FirstOrder(BTree T)//先序遍历非递归算法
{
    BTNode* st[MAXSIZE];//st数组存放栈元素
    // BTNode* st[MAXSIZE]因为[]的优先级比*高，所以st先与[]结合，形成数组，再与*结合，
    //所以这个数组的类型BTNode*，就是指向BTNode的指针，就是“元素是指向BTNode型数据的指针的数组”。
    // 每个元素都是一个指针，一共有MAXSIZE个元素
    int top = -1;//top为栈顶指针
    BTNode* p = T;
    while (p != NULL || top != -1)//当前结点不为空或者栈不为空
    {
        while (p != NULL)//当前结点不为空
        {
            cout << p->data << " ";
            top++;
            st[top] = p;//当前结点入栈
            p = p->lchild;//左孩子作为当前结点
        }
        if (top != -1)//当栈不为空
        {
            p = st[top];//将栈顶元素赋值给p
            top--;//栈顶元素出栈
            p = p->rchild;//指向栈顶元素的右孩子
        }
    }
    return true;
}


bool InOrder2(BTree T)//中序遍历非递归算法
{
    BTNode* st[MAXSIZE];//st数组存放栈元素
    int top = -1;
    BTNode* p = T;
    while (p != NULL || top != -1)
    {
        while (p != NULL)
        {
            top++;
            st[top] = p;
            p = p->lchild;
        }
        if (top != -1)
        {
            p = st[top];//获取栈顶结点
            cout << p->data << " ";
            top--;//栈顶结点出栈
            p = p->rchild;//指向栈顶结点的右孩子
        }
    }
    return true;
}

void PostOrder2(BTree T)//后序遍历非递归算法
{
    BTNode* st[MAXSIZE];
    BTNode* p ;
    int flag = -1;
    int top = -1;

    do{
        while (T != NULL)
        {
            top++;
            st[top] = T;
            T = T->lchild;
        }
        p = NULL;
        flag = 1;//表示栈顶的结点的左孩子被处理过
        while (top != -1 && flag == 1)//对栈顶结点进行连续判断
        {
            T = st[top];
            if (T->rchild == p)
            {
                cout << T->data << " ";
                top--;
                p = T;
            }
            else
            {
                T = T->rchild;
                flag = 0;//表示当前结点的左孩子没有被处理过
            }

        }

     }while (top != -1);
    cout << endl;
}

（三）完整代码

#include<iostream>
#include<stdbool.h>
#include<cstdlib>
using namespace std;
#define MAXSIZE 100
typedef char ElemType;
typedef struct BTNode
{
    ElemType data;//数据域
    struct BTNode* lchild, * rchild;//左右孩子指针
}BTNode, * BTree; 
BTree Creat(char str[]);//先序序列建立二叉链表（方法1）
void CreateBT(BTree& T); // 先序遍历建立二叉链表（方法2）
void CreatBTNode(BTree& T, char* str);//利用ch扫描，采用括号表示法表示的二叉树字符串（方法3）

void PreOrder(BTree T);//先序遍历
void InOrder(BTree T);//中序遍历
void PostOrder(BTree T);//后序遍历
void LevelOrder(BTree T);//层序遍历

//非递归算法
bool FirstOrder(BTree T);//先序遍历非递归算法
bool InOrder2(BTree T);//中序遍历非递归算法
void PostOrder2(BTree T);//后序遍历非递归算法
//#include"TreeNode.h"

BTree Creat(char str[])//先序序列建立二叉链表（方法1）
{
    BTree T;
    static int i = 0;
    ElemType c = str[i++];
    if (c == '#')//输入#表示此结点下不存在分支
    {
        T = NULL;
    }
    else
    {
        T = (BTree)malloc(sizeof(BTree));
        if (T == NULL)
        {
            exit(0);
        }
        T->data = c;
        T->lchild = Creat(str);//递归创建左子树
        T->rchild = Creat(str);//到上一个结点的右边递归创建左右子树
    }
    return T;
}

void CreateBT(BTree& T) // 先序遍历建立二叉链表 （方法2）
{
    ElemType ch;
    cin >> ch;
    if (ch == '^')
        T = NULL;
    else
    {
        T = (BTNode*)malloc(sizeof(BTNode));
        T->data = ch;
        cout << "请输入" << ch << "的左子树：";
        CreateBT(T->lchild);
        cout << "请输入" << ch << "的右子树：";
        CreateBT(T->rchild);
    }
}

void CreatBTNode(BTree& T, char* str)//（方法3）
{
    BTNode* st[MAXSIZE];
    BTNode* p = NULL;
    int top = -1, k, j = 0;
    ElemType ch;
    ch = str[j];
    while (ch != '\0')//str未扫描完的时候循环
    {
        switch (ch)
        {
        case '('://为左孩子结点
            top++;
            st[top] = p;
            k = 1;
            break;
        case ')':
            top--;
            break;
        case ','://为右孩子结点
            k = 2;
            break;
        default:
            p = (BTree)malloc(sizeof(BTree));
            p->data = ch;
            p->lchild = p->rchild = NULL;
            if (T == NULL)//p结点第一次创建
            {
                T = p;
            }
            else
            {
                switch (k)
                {
                case 1:
                    st[top]->lchild = p;//p结点为栈顶结点的左孩子
                    break;
                case 2:
                    st[top]->rchild = p;//p结点为栈顶结点的右孩子
                    break;

                }
            }

        }
        ch = str[++j];//继续扫描下一个字符
    }
}



void PreOrder(BTree T)//先序遍历
{
    if (T != NULL)
    {
        cout << T->data << " ";//访问根结点
        PreOrder(T->lchild);//先序遍历左子树
        PreOrder(T->rchild);//先序遍历右子树
    }
}

void InOrder(BTree T)//中序遍历
{
    if (T != NULL)
    {
        InOrder(T->lchild);
        cout << T->data << " ";
        InOrder(T->rchild);
    }

}
void PostOrder(BTree T)//后序遍历
{
    if (T != NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout << T->data << " ";
    }
}


void LevelOrder(BTree T)//层序遍历
{
    BTNode* p;
    BTNode* qu[MAXSIZE];//定义循环队列，存放结点指针
    int front, rear;//定义头指针和尾指针
    front = rear = 0;//置队列为空队列
    rear++;
    qu[rear] = T;//根结点指针进队
    rear++;//队尾指针指向队尾元素的后一个位置
    front = (front + 1) % MAXSIZE;//队头指针加1取模
    while (front != rear)//队列不为空
    {
        p = qu[front];//取队头元素
        front = (front + 1) % MAXSIZE;//队头元素出队，队头指针后移
        cout << p->data << " ";
        if (p->lchild != NULL)
        {
            qu[rear] = p->lchild;//p结点的左孩子进栈
            rear = (rear + 1) % MAXSIZE;//队尾指针加1取模
        }
        if (p->rchild != NULL)
        {
            qu[rear] = p->rchild;//p结点的右孩子进栈
            rear = (rear + 1) % MAXSIZE;
        }
    }
}





bool FirstOrder(BTree T)//先序遍历非递归算法
{
    BTNode* st[MAXSIZE];//st数组存放栈元素
    // BTNode* st[MAXSIZE]因为[]的优先级比*高，所以st先与[]结合，形成数组，再与*结合，
    //所以这个数组的类型BTNode*，就是指向BTNode的指针，就是“元素是指向BTNode型数据的指针的数组”。
    // 每个元素都是一个指针，一共有MAXSIZE个元素
    int top = -1;//top为栈顶指针
    BTNode* p = T;
    while (p != NULL || top != -1)//当前结点不为空或者栈不为空
    {
        while (p != NULL)//当前结点不为空
        {
            cout << p->data << " ";
            top++;
            st[top] = p;//当前结点入栈
            p = p->lchild;//左孩子作为当前结点
        }
        if (top != -1)//当栈不为空
        {
            p = st[top];//将栈顶元素赋值给p
            top--;//栈顶元素出栈
            p = p->rchild;//指向栈顶元素的右孩子
        }
    }
    return true;
}


bool InOrder2(BTree T)//中序遍历非递归算法
{
    BTNode* st[MAXSIZE];//st数组存放栈元素
    int top = -1;
    BTNode* p = T;
    while (p != NULL || top != -1)
    {
        while (p != NULL)
        {
            top++;
            st[top] = p;
            p = p->lchild;
        }
        if (top != -1)
        {
            p = st[top];//获取栈顶结点
            cout << p->data << " ";
            top--;//栈顶结点出栈
            p = p->rchild;//指向栈顶结点的右孩子
        }
    }
    return true;
}

void PostOrder2(BTree T)//后序遍历非递归算法
{
    BTNode* st[MAXSIZE];
    BTNode* p ;
    int flag = -1;
    int top = -1;

    do{
        while (T != NULL)
        {
            top++;
            st[top] = T;
            T = T->lchild;
        }
        p = NULL;
        flag = 1;//表示栈顶的结点的左孩子被处理过
        while (top != -1 && flag == 1)//对栈顶结点进行连续判断
        {
            T = st[top];
            if (T->rchild == p)
            {
                cout << T->data << " ";
                top--;
                p = T;
            }
            else
            {
                T = T->rchild;
                flag = 0;//表示当前结点的左孩子没有被处理过
            }

        }

     }while (top != -1);
    cout << endl;
}
//#include"TreeNode.h"
int main()
{
	cout << "二叉树建立的第一种方法" << endl;
	BTree T;//T为指向根结点的指针
	T=(BTree)malloc(sizeof(BTree));
	char str[] = { 'a','b','d','#','#','e','#','#','c','f','#','#','g','#','#' };
	T = Creat(str);
	cout << "先序遍历结果：";
	PreOrder(T);//先序遍历
	cout << endl;
	cout << "中序遍历结果：";
	InOrder(T);//中序遍历
	cout << endl;
	cout << "后序遍历结果：";
	PostOrder(T);//后序遍历
	cout << endl ;
	cout << "层次遍历的结果：";
	LevelOrder(T);
	cout << endl<<endl;

	cout << "（非递归）先序遍历结果：";
	FirstOrder(T);//先序遍历非递归算法
	cout << endl;
	cout << "（非递归）中序遍历结果：";
	InOrder2(T);//中序遍历非递归算法
	cout << endl;
	cout << "（非递归）后序遍历结果：";
	PostOrder2(T);
	cout << endl;

	cout << "二叉树建立的第二种方法" << endl;
	BTree T2;
	cout << "请输入第一个数据：";
	CreateBT(T2);
	cout << "先序遍历结果：";
	PreOrder(T2);
	cout << endl << endl;


	cout << "二叉树建立的第三种方法" << endl;
	BTree T3 = NULL;
	char s[] = "A(B(D(,G)),C(E,F))";
	CreatBTNode(T3, s);
	cout << "先序遍历结果是：";
	PreOrder(T3);//先序遍历
	cout << endl;
	cout << "（非递归）先序遍历结果是：";
	FirstOrder(T3);
	cout << endl;
	return 0;
}

莫忘、莫念
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树和二叉树学习资料
12-01
树和二叉树的学习资料，希望对大家有好处，希望和大家共同学习共同进步
二叉树学习-VC6
04-10
一个VC6写成的生成二叉树的小程序。 输入二叉树序列后，可以显示出二叉树的形状和遍历顺序。
二叉树学习资料
12-14
二叉树的相关学习资料，其中介绍了二叉树的定义，各种操作
leetcode卡-leetcode_practices_learncard_binarytree:我的leetcode练习二叉树学习卡
07-06
leetcode卡leetcode_practices_learncard_binarytree 我的 leetcode 练习二叉树学习卡在 100% 完成 :) 我的 Java8 备忘单：
数据结构树和二叉树学习资料
06-05
关于数据结构的课程资料 包含树与二叉树的相关内容 树在计算机领域中也得到广泛应用，如在编译源程序如下时，可用树表示源源程序如下的语法结构。又如在数据库系统中，树型结构也是信息的重要组织形式之一。一切具有层次关系的问题都可用树来描述。
【考研】常考的二叉树相关算法总结（详细全面）
qq_34438969的博客
09-28 3123
本文内容主要针对考研常考的二叉树相关算法，包括但不限于对普通二叉树的构造、查找、插入元素、（先序、中序、后序、层序）遍历，并含递归和非递归方式等的算法、二叉排序树的构造、查找和插入等等算法。因为考研中用二叉链表的存储结构较多，所以二叉树用的存储结构都是二叉链表。如果有错误的地方，请留言一起探讨。（后期会继续补充有关二叉树的算法）【考研】数据结构——线索二叉树_住在阳光的心里的博客-CSDN博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-CSDN下载。
二叉树的初步学习
weixin_61023150的博客
05-23 234
1.二叉树概念的引入 "" 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分 "" 2.树结构与线性结构的区别 3.树的分类 共5钟，如图示 4.树的遍历算法 1) 先序算法 2).中序算法 3).后序算法 5)....
当初我要是这么学习二叉树就好了「附图文解析」
开心的博客
11-22 1299
java二叉树代码实现和图文解析
树的性质总结
御坂御坂001的博客
11-06 287
数据结构——树
二叉树 Python学习
01-04
完全二叉树
二叉树学习啊
12-04
二叉树 相关
二叉树学习PPT
11-07
看完次文档 所有关于二叉树 树 二叉查找树的知识全会了，独家资料 如果好 请分享给大家。
二叉树的详解(你值得拥有)
weixin_49830664的博客
10-24 5329
二叉树 文章目录二叉树二叉树的定义什么是二叉树什么是完全二叉树二叉树的遍历实现前序遍历递归实现非递归实现中序遍历递归实现非递归实现后序遍历递归遍历非递归遍历二叉树的基础面试题 二叉树的定义 什么是二叉树 什么是完全二叉树 二叉树的遍历实现 前序遍历 递归实现 非递归实现 中序遍历 递归实现 非递归实现 后序遍历 递归遍历 非递归遍历 二叉树的基础面试题 ...
数据结构基础学习——二叉树的知识总结
m0_60502858的博客
11-19 2921
目录 二叉树的概念和性质 二叉树顺序结构及实现 二叉树链式结构及实现 二叉树的前 、中、后序遍历 二叉树基础题练习 1.二叉树的概念 二叉树是树的结构中最常用的一种结构，它的形式是一个结点最多可以有两个子节点，即左结点和右结点。用图表示如下 可以看出二叉树中不存在度超过2的结点，而且二叉树的子树有左右之分，次序不能颠倒，二叉树是一颗有序树，对于任意一颗二叉树都是由以下几种结构复合而成的。 二叉树中又分有两种特殊的树，即满二叉树和完全二叉树 满二叉树就是该树的每一层的结点数都到达了最大，就是除了最后
数据结构：二叉树基础入门
xufei5789651的博客
03-07 1455
定义 二叉树由一个根节点和两个互不相交的、分别称为根节点的左子树和右子树的二叉树组成。 二叉树种类 满二叉树 对于一棵二叉树，如果每一个非叶子节点都存在左右子树，并且二叉树中所有的叶子节点都在同一层中，这样的二叉树称为满二叉树。 完全二叉树 除了叶子节点外每一个节点都有左右子叶且叶子节点都处在最底层的二叉树。 对于完全二叉树，若某个节点数为i，左子节点位2i+1，右子节点为2i+2。 二叉搜索树 又称二叉查找树或者二叉排序树。二叉搜索树具有下列性质： 若左子树不空，则左子树上所有节点的值均小于它的根节点的
数据结构之二叉树（详细版）
xk972414831的博客
09-20 1793
二叉树作为数据结构的一种，尤为重要，下面是对二叉树的详细讲解。想要了解二叉树，首先要了解二叉树的基本概念，以及创建二叉树的结构，再深层点，遍历二叉树的前序中序和后续，其次是层序，后面将会讲解如何计算二叉树的高和叶结点等等。 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)
数据结构入门系列——树和二叉树（基础知识）
weixin_45561357的博客
05-13 987
树和二叉树（基础知识）
JAVA 学习·泛型（二）——通配泛型
最新发布
wr114514的博客
05-02 1056
介绍了Java泛型中的重要知识点——通配泛型及其应用。
镜像二叉树
05-30
在机器学习中可以用来对称化数据集、增强模型的泛化能力等等。 在二叉树的实现中，镜像二叉树可以通过递归算法实现。具体来说，从根节点开始，递归地交换每个节点的左右子树，直到所有节点都被交换。以下是一个示例...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值