数据结构-树

最新推荐文章于 2024-03-22 15:46:02 发布

迷途君

最新推荐文章于 2024-03-22 15:46:02 发布

阅读量1k

点赞数 10

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/m0_70983574/article/details/125450861

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

树

知识框架

一.树的基本概念

1.树的定义

树是n(n>=0)个结点的有限集。当n=0时，称为空树。任意一颗非空树应满足：

1.有且仅有一个特定的称为根的结点。

2.当n>1时，其余节点可分为m个互不相交的有限集，其中每个集又是一颗新的树，称为根的子树。

很显然，对于树的定义是递归的，树是一种递归的数据结构，在往后我们对树的各种操作都要利用到递归这个重要的性质！树作为一种逻辑结构，同时也是一种分层结构，具有一下特征：

1.树的根节点没有前驱，除根节点外的所有结点有且只有一个前驱。

2.树中所有结点可以有零个或多个后继。

2.基本术语

1.度：树中一个结点的孩子个数称为该结点的度，树中结点的最大度数称为树的度。

2.高度：从根节点开始，从1开始依次往下计数，到最后一层的总层数。

3.层数：从根节点开始，从1开始依次往下计数。

3.树的性质

树具有下面一些基本性质：

1.树中的结点数等于所有结点的度加1.

2.度为m的树中第i层至多有m^(i-1)个结点（i>=1）.

3.高度为h的m叉树至多有（m^h -1）/(m-1)个结点

4.具有n个结点的m叉树的最小高度为 logm (n(m-1)+1).

二叉树

一.二叉树的概念

1.二叉树的定义

二叉树是另一种树形结构，其特点是每个结点至多只有两颗子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。与树的定义相似，二叉树也以递归的形式定义。二叉树是n（n>=0）个节点的集合：

1.空二叉树，n为0；

2.或由一个根节点和两个互不相交的被称为根的左子树和右子树组成，他们分别又是一颗二叉树

一般为以下几种形式

2.特殊的二叉树

（1）满二叉树

一棵高度为h，且含有2^h -1个结点的二叉树称为满二叉树，若根节点从1开始编号，左孩子为2i,右孩子为2i+1

（2）完全二叉树

只有最下面两层有度数小于2的节点，且最下面一层的叶节点集中在最左边的若干位置上的二叉树我们称为完全二叉树

（3）二叉排序树

左子树上所有结点的关键字均小于根结点的关键字，右子树上的所有结点的关键字都大于根节点的关键字，左右子树分别又是一颗二叉排序树。

（4）平衡二叉树

首先平衡二叉树是一棵合理的二叉排序树，做上任意结点的左子树和右子树的深度之差不超过1，在构建平衡二叉树过程中，一但发现不符合特性，需要进行调整，这个我们之后再细聊。

3.二叉树的一些性质

1.任意一棵二叉树，若节点数量为n,则边的数量为n-1;

2.非空二叉树上叶子结点树总是等于度为2的结点数量加1：n0=n2+1

3.非空二叉树上第i层最多有2^(i-1)个结点。

4.高度为h的二叉树至多有（2^h）-1个结点

4.二叉树的存储结构

（1）顺序存储

二叉树的顺序存储如何实现呢？我们用一组地址连续的存储单元从上到下，从左到右存储完全二叉树的结点元素，即将完全二叉树上编号为i的结点元素存在一维数组下标为i-1的分量中，这样我们查找起来会很方便，但是也有一个巨大的问题哦!那就是为了让数组的下标和结点编号对应上，我们必须要将二叉树变成完全二叉树，不存在的结点也要补上，不然编号对应不上，这就会造成空间的巨大浪费。如下图所示

（2）链式存储

通过观察我们不难发现，二叉树的左孩子右孩子我们完全可以通过两个左右指针来指向他们。

看看我们如何定义结点的结构类型

typedef struct linkTree{
    int data;//数据
    struct linkTree* lchild;//左孩指针
    struct linkTree* rchild;//右孩指针
}linkTree;

二.二叉树的创建和遍历

从根节点出发，按照某种顺序依次访问所有结点，每个结点有且只能被访问一次。

1.先序遍历

先访问根节点，先序遍历左子树，先序遍历右子树

代码如下：

//前序遍历
void preOrder(TreeNode* T)
{
    if(T==NULL)
        return ;
    else
    {
        printf("%c ",T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }
}

2.中序遍历

中序访问左子树，访问根节点，中序访问右子树

//中序遍历
void inOrder(TreeNode* T)
{
    if(T==NULL)
        return ;
    else
    {
        inOrder(T->lchild);
        printf("%c ",T->data);
        inOrder(T->rchild);
    }
}

3.后序遍历

后序访问左子树，后序访问右子树，访问根节点

代码如下：

//后序遍历
void postOrder(TreeNode* T)
{
    if(T==NULL)
        return ;
    else
    {
        preOrder(T->lchild);
        preOrder(T->rchild);
        printf("%c ",T->data);
    }
    return ;
}

三种遍历我们都用到了递归的方法，且无论是哪种遍历算法，我们每个结点都只访问了一次，所以时间复杂度为O（n），在使用递归时一定要注意退出递归的条件！不然可能会陷入死循环无法退出，那么如果不使用递归如何遍历呢？

4.层次遍历

层次遍历顾名思义就是从上往下从左到右每一层遍历完成后再往下一层开始遍历，如下图所示

那么要如何实现层次遍历呢，这里就要用到我们之前的队列了，我们先将二叉树根结点入队，然后出队，访问出队结点，若有左子树，则将左子树根节点入队，如果有右子树，将右子树根节点入队。然后出队，访问出队结点。。。如此循环，直到队列为空。

思路如下图：

//层次遍历
void levelTraverse(QueueNode* Q,TreeNode* T)
{
    enQueue(T,Q);//根节点入队
    while(!isEmpty(Q))//队列不为空则循环
    {
        QueueNode* node=deQueue(Q);接收出队结点
        printf("%c ",node->T->data);访问出队结点
        if(node->T->lchild)
        {
            enQueue(node->T->lchild,Q);//左子树不空，则左子树根结点入队
        }
        if(node->T->rchild)
        {
            enQueue(node->T->rchild,Q);//右子树不空，则右子树根节点入队
        }
    }

}

5.递归算法和非递归算法的转换

之前我们三种遍历都用了递归的思想，那么如果不用递归能否实现呢？我们以下图为例子来分析三种遍历的非递归算法吧：

（1）中序遍历的非递归算法

这里我们要借用栈先进后出的性质来帮助我们达成中序遍历的非递归算法：

1.先沿着根的左孩子依次入栈，直到左孩子为空为止，这时说明找到可以输出的结点，如果按照我们上图所示，此时我们栈内元素为ABD。

2.将栈顶元素出栈并访问他的右孩子，如果右孩子为空则继续访问，如果不为空，则入栈右孩子进行第一步操作

如图所示，你可能会更清楚：

void inOrder(TreeNode* T)
{
    initStack(S);//初始化栈
    TreeNode* p=T;
    while(p || !isempty(s))//栈不空或p不空时循环
    {
        if(p)
        {
            push(S,p);//当前节点入栈
            p=p->lchild;//左孩子不空，则一直向左走
        }
        else
        {
            pop(S,p);//栈顶元素出栈
            visit(p);
            p=p->rchild;//向右子树走
        }
    }
}

（2）先序遍历的非递归算法

先序遍历和中序遍历的思路是类似的，不过由于先序先访问的是根，所以我们要将访问操作结点放在入栈操作的前面。

（3）后序遍历的非递归算法

后序遍历的话和先序中序有一点差别，我们需要在结点中增加一个标志域，来记录是否被访问，以免成为死循环，算法思路如下图，我将思路总结成下面两句话

1.从根结点开始，寻找最左边的节点，并依次入栈

2.出栈前，判断栈顶元素是否有右子树，还要判断右子树是否被访问过，如果有且未被访问则将右子树入栈，重复1的操作。

typedef struct TreeNode{
    char data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
    int flag;//判断是否被访问的标志域元素
}TreeNode;
//链栈类型定义
typedef struct StackNode{
    TreeNode* data;//指向对应结点元素的指针
    struct StackNode* next;//指向下一个栈元素的指针
}StackNode;
//栈的初始化
StackNode* initStack()
{
    StackNode* S=(StackNode*)malloc(sizeof(StackNode));
    S->data=NULL;
    S->next=NULL;
    return S;
}
//入栈操作
void push(TreeNode* data,StackNode* S)
{
    StackNode* node=(StackNode*)malloc(sizeof(StackNode));
    node->data=data;
    node->next=S->next;
    S->next=node;
}
//判空
int isEmpty(StackNode* S)
{
    if(S->next==NULL)
        return 1;
    else
        return 0;
}
//出栈
StackNode* pop(StackNode* S)
{
    if(isEmpty(S))
    {
        return NULL;
    }
    else
    {
        StackNode* node=S->next;
        S->next=node->next;
        return node;
    }
}
//获取栈顶
StackNode* getTop(StackNode* S)
{
    if(isEmpty(S))
    {
        return NULL;
    }
    else
    {
        StackNode* node=S->next;
        return node;
    }
}
//后序的非递归遍历
void postOrder(TreeNode* T)
{
    TreeNode* node=T;
    StackNode* S=initStack();//初始化链栈
    while(node || !isEmpty(S))
    {
        if(node)
        {
            push(node,S);//入栈操作
            node=node->lchild;//将左孩子依次入栈
        }
        else
        {
            TreeNode* top=getTop(S)->data;//指向栈顶元素
            if(top->rchild&&top->flag==0)//如果有右孩子且未被访问
            {
                top=top->rchild;//将指针指向右孩子
                push(top,S);//将右孩子入栈
                node=top->lchild;//指向左孩子重复上述判断
            }
            else
            {
                top=pop(S)->data;
                printf("%c ",top->data);
                top->flag=1;//将标志域置1表示被访问过
            }
        }
        
    }
}

6.由遍历序列构造出二叉树

1.由二叉树的先序序列和中序序列可以唯一确定一棵二叉树

先序序列，第一个结点一定是二叉树的根结点，而在中序遍历，根结点必然将中序序列分割成两个子序列，前一个子序列是根节点的左子树的中序序列，后一个子序列是根节点的右子树的中序序列。再根据这两个子序列，在先序序列中找到对应的子序列，左子序列的第一个结点时左子树的根节点，右子序列的第一个结点是右子树的根节点，递归即可得到这个二叉树。

2.由二叉树的后序序列和中序序列也可以唯一确定一棵二叉树

后序序列的最后一个结点为根节点，和上面一样根据这个将中序序列分割成两个子序列

3.由二叉树的层次序列和中序序列也可以唯一确定一棵二叉树

4.先序和后序不能唯一确定一棵二叉树

来看个例子吧：

已知先序为：ABCDEFG，中序为CDBAEFG，画出二叉树

二叉树的应用

一.二叉排序树

1.定义

二叉排序树，左子树上的结点值均小于根节点的值，右子树上的结点值均大于根结点的值。

可以发现如果我们将一棵二叉排序树按中序遍历，可以得到一个递增的有序序列，因此如果用来查找效率会快很多，但是也会出现一个问题，由于没有其余限制条件，可能会导致某一侧子树长度过长如下图所示，那么这样查找起来效率会慢很多，所以后面会我们引入二叉平衡树！

2.插入

二叉排序树的插入操作很简单，放到比较大小放在合适位置即可

TreeNode* bstInsert(TreeNode** T,int data)
{
    if(*T==NULL)//如果是空树则直接为根节点
    {
        *T=(TreeNode*)malloc(sizeof(TreeNode));//开辟空间
        (*T)->data=data;//赋值
        (*T)->lchild=NULL;//初始化
        (*T)->rchild=NULL;//初始化
    }
    else if(data<(*T)->data)//如果比根节点小则继续递归和左孩子比较
    {
        bstInsert(&((*T)->lchild),data);
    }
    else if(data==(*T)->data)//如果相等则不进行操作，因为不能有相同的数存在
        return ;
    else 
        bstInsert(&((*T)->rchild),data);//如果比根节点大则继续递归和右孩子比较
}

3.查找

//查找
TreeNode* bstSearch(TreeNode* T,int data)
{
    if(T)
    {
        if(T->data==data)
        {
            return T;
        }
        else if(data<T->data)
        {
            return bstSearch(T->lchild,data);
        }
        else
        {
            return bstSearch(T->rchild,data);
        }
    }
    else
        return NULL;
}

二.二叉平衡树

1.定义

平衡二叉树其实就是一棵合理的二叉排序树，每个节点的左子树和他的右子树的高度差至多等于1.

我们将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子，平衡二叉树上所有结点的平衡因子只会是-1，0，1，如果大于1则不是平衡二叉树，此时我们需要调整它成为平衡二叉树。

注：由于平衡二叉树是高度平衡的，所以我们在进行查找时效率很快，但是如果进行插入等操作由于要考虑平衡，效率则会很慢。平衡二叉树的查找算法时间复杂度为O(log2n)

2.平衡二叉树的插入

在进行插入删除等操作时，我们要考虑到是否会导致不平衡来进行调整。

注：每次调整的对象都是最小不平衡子树。

调整规律有以下四种情况：我会分别用一个例子来进行说明，但首先我们需要判断该子树的调整类型，这里我总结了一些规律让我们来判断：

1.首先我们要找到失衡树的根结点root.

2.找到导致树失衡的结点node,先判断node在root哪一侧，左侧为L，右侧为R

3.再判断node在root孩子child的哪一侧，左侧为L，右侧为R（比他小在左，比他大在右边）

4.通过2，3即可判断调整类型。

1.RR旋转

例：1 2 3 4 5

如果按照我们平时二叉排序树来进行插入那么会先出现下面这种情况：