数据结构之树

简介: 数据结构之树

一、二叉树


二叉树是一棵树,其中每个节点都不能有多余两个儿子。


二叉树的一个性质是平均二叉树的深度要比N小的多,分析表明,这个平均深度为O(),对于特殊类型的二叉树,即二叉查找树,其深度的平均值O(logN)

二、二叉查找树


对于树中的每个节点X,它的左子树中所有的关键字值小于X的关键字,而它的右子树中所有的关键字值大于X的关键字值。


三、二叉树的遍历


前序遍历(DLR)


前序遍历也叫做先根遍历,可记做根左右。

前序遍历首先访问根结点然后遍历左子树,最后遍历右子树。在遍历左、右子树时,仍然先访问根结点,然后遍历左子树,最后遍历右子树。

若二叉树为空则结束返回,否则:

 (1)访问根结点

 (2)前序遍历左子树

 (3)前序遍历右子树

注意的是:遍历左右子树时仍然采用前序遍历方法。

中序遍历(LDR)


中序遍历也叫做中根遍历,可记做左根右。

中序遍历首先遍历左子树,然后访问根结点,最后遍历右子树。在遍历左、右子树时,仍然先遍历左子树,再访问根结点,最后遍历右子树。即:

若二叉树为空则结束返回,否则:


(1)中序遍历左子树

(2)访问根结点

(3)中序遍历右子树。

注意的是:遍历左右子树时仍然采用中序遍历方法。


后序遍历(LRD)


后序遍历也叫做后根遍历,可记做左右根。

后序遍历首先遍历左子树,然后遍历右子树,最后访问根结点。在遍历左、右子树时,仍然先遍历左子树,再遍历右子树,最后访问根结点。即:

若二叉树为空则结束返回,否则:

(1)后序遍历左子树。

(2)后序遍历右子树。

(3)访问根结点。

注意的是:遍历左右子树时仍然采用后序遍历方法。

层次遍历


按照从上至下,从左至右的顺序遍历二叉树。

#include<stdio.h>  
#include<stdlib.h>  
#define N 9 
int a[]={3,2,5,8,4,7,6,9,10};  
//二叉树的结点类型;  
typedef struct tree  
{  
    int data;  
    struct tree *lchild;  
    struct tree *rchild;  
}BitTree;  
//在二叉排序树中插入查找关键字可以;  
void Inserter(BitTree *bt,int key)    
{  
    BitTree *parent;   //表示双亲结点;  
    BitTree *head = bt;  
    BitTree *p=(BitTree *)malloc(sizeof(BitTree));  
    p->data=key;   //保存结点数据;  
    p->lchild=p->rchild=NULL;  //左右子树置空;  
    //查找需要添加的父结点,这个父结点是度为0的结点;  
    while(head)   
    {  
        parent=head;  
        if(key<head->data)   //若关键字小于结点的数据;  
            head=head->lchild; //在左子树上查找;   
        else   //若关键字大于结点的数据;  
            head=head->rchild;  //在右子树上查找;  
    }  
    //判断添加到左子树还是右子树;  
    if(key<parent->data)   //小于父结点;  
        parent->lchild=p;    //添加到左子树;  
    else    //大于父结点;  
        parent->rchild=p;   //添加到右子树;  
}  
//n个数据在数组data[]中;  
BitTree *Createer(BitTree *bt,int data[],int n)    
{  
int i=0;
    bt=(BitTree *)malloc(sizeof(BitTree));  
    bt->data=data[0];  
    bt->lchild=bt->rchild=NULL;  
    for( i=1;i<n;i++)  
        Inserter(bt,data[i]);  
    return bt;  
}  
//前序遍历;  
void PreOrder(BitTree *bt)  
{  
    if(bt)  
    {  
       printf("%d ",bt->data);    
    PreOrder(bt->lchild);  
        PreOrder(bt->rchild);  
    }  
}
//中序遍历;  
void InOrder(BitTree *bt)  
{  
    if(bt)  
    {       
    InOrder(bt->lchild);  
    printf("%d ",bt->data);   
       InOrder(bt->rchild);  
    }  
} 
void PostOrder(BitTree *bt){    //后序遍历  
  if(bt){ 
    PostOrder(bt->lchild); 
    PostOrder(bt->rchild); 
    printf("%d ",bt->data);  
  } 
}    
//删除结点;  
void Deleteer(BitTree *bt,int key)  
{  
    BitTree *L,*LL;    //在删除左右子树都有的结点时使用;  
    BitTree *p=bt;  
    BitTree *parent=bt;  
    int child=0;  //0表示左子树,1表示右子树;  
    if(!bt)    //如果排序树为空,则退出;  
        return ;  
    while(p)  //二叉排序树有效;  
    {  
        if(p->data==key)  
        {  
            if(!p->lchild&&!p->rchild)  //叶结点(左右子树都为空);  
            {  
                if(p==bt)  //被删除的结点只有根结点;  
                    free(p);  
                else if(child==0)  
                {  
                    parent->lchild=NULL;  //设置父结点左子树为空;  
                    free(p);   //释放结点空间;  
                }  
                else   //父结点为右子树;  
                {  
                    parent->rchild=NULL;  //设置父结点右子树为空;  
                    free(p);  //释放结点空间;  
                }  
            }  
            else if(!p->lchild)  //左子树为空,右子树不为空;  
            {  
                if(child==0)    //是父结点的左子树;  
                    parent->lchild=p->rchild;  
                else      //是父结点的右子树;  
                    parent->rchild=p->rchild;  
                free(p);  //释放被删除的结点;  
            }  
            else if(!p->rchild)  //右子树为空,左子树不为空;  
            {  
                if(child==0)  //是父结点的左子树;  
                    parent->lchild=p->lchild;  
                else      //是父结点的右子树;  
                    parent->rchild=p->lchild;  
                free(p);  //释放被删除的结点;  
            }  
            else 
            {  
                LL=p;  //保存左子树的结点;  
                L=p->rchild;  //从当前结点的右子树进行查找;  
                if(L->lchild)  //左子树不为空;  
                {  
                    LL=L;  
                    L=L->lchild;   //查找左子树;  
                    p->data=L->data;  //将左子树的数据保存到被删除结点;  
                    LL->lchild=L->lchild;  //设置父结点的左子树指针为空;  
                    for(;L->lchild;L=L->lchild);  
                    L->lchild=p->lchild;  
                    p->lchild=NULL;  
                }  
                else 
                {  
                    p->data=L->data;  
                    LL->rchild=L->rchild;  
                }  
            }  
            p=NULL;  
        }  
        else if(key<p->data)  //需删除记录的关键字小于结点的数据;  
        {  
            //要删除的结点p是parent的左子树;  
            child=0;  //标记在当前结点左子树;  
            parent=p;//保存当前结点作为父结点;  
            p=p->lchild;  //查找左子树;  
        }  
        else  //需删除记录的关键字大于结点的数据;  
        {  
            //要删除的结点p是parent的右子树;  
            child=1;  //标记在当前结点右子树查找;  
            parent=p;  //保存当前结点作为父结点;  
            p=p->rchild;  //查找右子树;  
        }  
    }  
}  
int maxDepth(BitTree* root) {
  if (root == NULL) {
  return 0;
  }
  else {
  int maxLeft = maxDepth(root->lchild), maxRight = maxDepth(root->rchild);
  if (maxLeft > maxRight) {
    return 1 + maxLeft;
  }
  else {
    return 1 + maxRight;
  }
  }
}
int main(void)  
{  
    BitTree *bt;  //保存二叉排序树根结点;  
  int i=0;
  int maxdepth=0;
    printf("数组数据为:\n");  
    for(i=0;i<N;i++)  
        printf("%d ",a[i]);  
    printf("\n\n");  
    bt=Createer(bt,a,N); 
  printf("遍历后的二叉排序树为(前序遍历输出):\n");  
    PreOrder(bt);  
  printf("\n\n"); 
    printf("遍历后的二叉排序树为(中序遍历输出):\n");  
    InOrder(bt);  
    printf("\n\n"); 
    printf("遍历后的二叉排序树为(后序遍历输出):\n");  
    PostOrder(bt);  
    printf("\n\n\n");
  maxdepth=maxDepth(bt);
  printf("二叉树的深度 %d\n",maxdepth); 
    printf("     **将数据8插入到二叉树中**\n\n");  
    printf("插入后的二叉树为(中序遍历输出):\n");  
    Inserter(bt,8);  
    PreOrder(bt);  
    printf("\n\n\n");  
    printf("     **将数据5从二叉树中删除**\n\n");  
    printf("删除后的二叉树为(中序遍历输出):\n");  
    Deleteer(bt,5);   //删除拥有左右子树的结点有问题;  
    PreOrder(bt);  
    printf("\n");  
    return 0;  
}


目录
相关文章
|
10月前
|
算法
数据结构之博弈树搜索(深度优先搜索)
本文介绍了使用深度优先搜索(DFS)算法在二叉树中执行遍历及构建链表的过程。首先定义了二叉树节点`TreeNode`和链表节点`ListNode`的结构体。通过递归函数`dfs`实现了二叉树的深度优先遍历,按预序(根、左、右)输出节点值。接着,通过`buildLinkedList`函数根据DFS遍历的顺序构建了一个单链表,展示了如何将树结构转换为线性结构。最后,讨论了此算法的优点,如实现简单和内存效率高,同时也指出了潜在的内存管理问题,并分析了算法的时间复杂度。
264 0
|
6月前
|
算法 Java
算法系列之数据结构-Huffman树
Huffman树(哈夫曼树)又称最优二叉树,是一种带权路径长度最短的二叉树,常用于信息传输、数据压缩等方面。它的构造基于字符出现的频率,通过将频率较低的字符组合在一起,最终形成一棵树。在Huffman树中,每个叶节点代表一个字符,而每个字符的编码则是从根节点到叶节点的路径所对应的二进制序列。
154 3
 算法系列之数据结构-Huffman树
|
6月前
|
存储 自然语言处理 数据库
【数据结构进阶】AVL树深度剖析 + 实现(附源码)
在深入探讨了AVL树的原理和实现后,我们不难发现,这种数据结构不仅优雅地解决了传统二叉搜索树可能面临的性能退化问题,还通过其独特的平衡机制,确保了在任何情况下都能提供稳定且高效的查找、插入和删除操作。
493 19
|
8月前
|
存储 C++
【C++数据结构——树】哈夫曼树(头歌实践教学平台习题) 【合集】
【数据结构——树】哈夫曼树(头歌实践教学平台习题)【合集】目录 任务描述 相关知识 测试说明 我的通关代码: 测试结果:任务描述 本关任务:编写一个程序构建哈夫曼树和生成哈夫曼编码。 相关知识 为了完成本关任务,你需要掌握: 1.如何构建哈夫曼树, 2.如何生成哈夫曼编码。 测试说明 平台会对你编写的代码进行测试: 测试输入: 1192677541518462450242195190181174157138124123 (用户分别输入所列单词的频度) 预
191 14
【C++数据结构——树】哈夫曼树(头歌实践教学平台习题) 【合集】
|
8月前
|
Java C++
【C++数据结构——树】二叉树的基本运算(头歌实践教学平台习题)【合集】
本关任务:编写一个程序实现二叉树的基本运算。​ 相关知识 创建二叉树 销毁二叉树 查找结点 求二叉树的高度 输出二叉树 //二叉树节点结构体定义 structTreeNode{ intval; TreeNode*left; TreeNode*right; TreeNode(intx):val(x),left(NULL),right(NULL){} }; 创建二叉树 //创建二叉树函数(简单示例,手动构建) TreeNode*create
182 12
|
8月前
|
C++
【C++数据结构——树】二叉树的性质(头歌实践教学平台习题)【合集】
本文档介绍了如何根据二叉树的括号表示串创建二叉树,并计算其结点个数、叶子结点个数、某结点的层次和二叉树的宽度。主要内容包括: 1. **定义二叉树节点结构体**:定义了包含节点值、左子节点指针和右子节点指针的结构体。 2. **实现构建二叉树的函数**:通过解析括号表示串,递归地构建二叉树的各个节点及其子树。 3. **使用示例**:展示了如何调用 `buildTree` 函数构建二叉树并进行简单验证。 4. **计算二叉树属性**: - 计算二叉树节点个数。 - 计算二叉树叶子节点个数。 - 计算某节点的层次。 - 计算二叉树的宽度。 最后,提供了测试说明及通关代
162 10
|
11月前
|
存储 算法 搜索推荐
探索常见数据结构:数组、链表、栈、队列、树和图
探索常见数据结构:数组、链表、栈、队列、树和图
339 64
|
8月前
|
存储 算法 测试技术
【C++数据结构——树】二叉树的遍历算法(头歌教学实验平台习题) 【合集】
本任务旨在实现二叉树的遍历,包括先序、中序、后序和层次遍历。首先介绍了二叉树的基本概念与结构定义,并通过C++代码示例展示了如何定义二叉树节点及构建二叉树。接着详细讲解了四种遍历方法的递归实现逻辑,以及层次遍历中队列的应用。最后提供了测试用例和预期输出,确保代码正确性。通过这些内容,帮助读者理解并掌握二叉树遍历的核心思想与实现技巧。
259 3
|
10月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
276 5
|
10月前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现(c语言)(附源码)
本文介绍了树和二叉树的基本概念及结构,重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树,常用于实现优先队列和高效的排序算法(如堆排序)。文章详细描述了堆的性质、存储方式及其实现方法,包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容,读者可以全面了解堆的原理和应用。
389 16