二叉树遍历，统计

最新推荐文章于 2024-07-07 16:59:36 发布
最新推荐文章于 2024-07-07 16:59:36 发布
阅读量716 收藏
点赞数
分类专栏： 优秀文章 收集 文章标签： 二叉树 遍历

一、基本概念

每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。

性质：

1、非空二叉树的第n层上至多有2^(n-1)个元素。

2、深度为h的二叉树至多有2^h-1个结点。

满二叉树：所有终端都在同一层次，且非终端结点的度数为2。

在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。

完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结点均向左靠齐，即集中在左面的位置上，不能有空位置。

对于完全二叉树，设一个结点为i则其父节点为i/2，2i为左子节点，2i+1为右子节点。

二、存储结构

顺序存储：

将数据结构存在一块固定的数组中。

[cpp] view plain copy
print ?
  1. #define LENGTH 100  
  2. typedef char datatype;  
  3. typedef struct node{  
  4.     datatype data;  
  5.     int lchild,rchild;  
  6.     int parent;  
  7. }Node;  
  8.   
  9. Node tree[LENGTH];  
  10. int length;  
  11. int root;  
#define LENGTH 100
typedef char datatype;
typedef struct node{
    datatype data;
    int lchild,rchild;
    int parent;
}Node;

Node tree[LENGTH];
int length;
int root;

   虽然在遍历速度上有一定的优势，但因所占空间比较大，是非主流二叉树。二叉树通常以链式存储。

链式存储：

[cpp] view plain copy
print ?
  1. typedef char datatype;  
  2.   
  3. typedef struct BinNode{  
  4.     datatype data;  
  5.     struct BinNode* lchild;  
  6.     struct BinNode* rchild;  
  7. }BinNode;  
  8.   
  9. typedef BinNode* bintree;          //bintree本身是个指向结点的指针  
typedef char datatype;

typedef struct BinNode{
    datatype data;
    struct BinNode* lchild;
    struct BinNode* rchild;
}BinNode;

typedef BinNode* bintree;          //bintree本身是个指向结点的指针


 三、二叉树的遍历

遍历即将树的所有结点访问且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历。

前序遍历：根节点->左子树->右子树

中序遍历：左子树->根节点->右子树

后序遍历：左子树->右子树->根节点

例如：求下面树的三种遍历

 

前序遍历：abdefgc

中序遍历：debgfac

后序遍历：edgfbca

四、遍历的实现

递归实现(以前序遍历为例，其他的只是输出的位置稍有不同)

[cpp] view plain copy
print ?
  1. void preorder(bintree t){  
  2.     if(t){  
  3.         printf(”%c ”,t->data);  
  4.         preorder(t->lchild);  
  5.         preorder(t->rchild);  
  6.     }  
  7. }  
void preorder(bintree t){
    if(t){
        printf("%c ",t->data);
        preorder(t->lchild);
        preorder(t->rchild);
    }
}


非递归的实现

因为当遍历过根节点之后还要回来，所以必须将其存起来。考虑到后进先出的特点，选用栈存储。数量确定，以顺序栈存储。

[cpp] view plain copy
print ?
  1. #define SIZE 100  
  2. typedef struct seqstack{  
  3.     bintree data[SIZE];  
  4.     int tag[SIZE];   //为后续遍历准备的  
  5.     int top;     //top为数组的下标  
  6. }seqstack;  
  7.   
  8. void push(seqstack *s,bintree t){  
  9.   
  10.     if(s->top == SIZE){  
  11.         printf(”the stack is full\n”);  
  12.     }else{  
  13.         s->top++;  
  14.         s->data[s->top]=t;  
  15.     }  
  16. }  
  17.   
  18. bintree pop(seqstack *s){  
  19.     if(s->top == -1){  
  20.         return NULL;  
  21.     }else{  
  22.         s->top–;  
  23.         return s->data[s->top+1];  
  24.     }  
  25. }  
#define SIZE 100
typedef struct seqstack{
    bintree data[SIZE];
    int tag[SIZE];   //为后续遍历准备的
    int top;     //top为数组的下标
}seqstack;

void push(seqstack *s,bintree t){

    if(s->top == SIZE){
        printf("the stack is full\n");
    }else{
        s->top++;
        s->data[s->top]=t;
    }
}

bintree pop(seqstack *s){
    if(s->top == -1){
        return NULL;
    }else{
        s->top--;
        return s->data[s->top+1];
    }
}

1、前序遍历 

[cpp] view plain copy
print ?
  1. void preorder_dev(bintree t){  
  2.     seqstack s;  
  3.     s.top = -1;     //因为top在这里表示了数组中的位置，所以空为-1  
  4.     if(!t){  
  5.         printf(”the tree is empty\n”);  
  6.     }else{  
  7.         while(t || s.stop != -1){  
  8.             while(t){    //只要结点不为空就应该入栈保存，与其左右结点无关      
  9.                   printf(”%c ”,t->data);  
  10.                 push(&s,t);  
  11.                 t= t->lchild;  
  12.             }  
  13.             t=pop(&s);  
  14.             t=t->rchild;  
  15.         }  
  16.     }  
  17. }  
void preorder_dev(bintree t){
    seqstack s;
    s.top = -1;     //因为top在这里表示了数组中的位置，所以空为-1
    if(!t){
        printf("the tree is empty\n");
    }else{
        while(t || s.stop != -1){
            while(t){    //只要结点不为空就应该入栈保存，与其左右结点无关    
                  printf("%c ",t->data);
                push(&s,t);
                t= t->lchild;
            }
            t=pop(&s);
            t=t->rchild;
        }
    }
}


 2、中序遍历

 

[cpp] view plain copy
print ?
  1. void midorder(bintree t){  
  2.     seqstack s;  
  3.     s.top = -1;  
  4.     if(!t){  
  5.         printf(”the tree is empty!\n”);  
  6.     }else{  
  7.         while(t ||s.top != -1){  
  8.             while(t){  
  9.                 push(&s,t);  
  10.                 t= t->lchild;  
  11.             }  
  12.             t=pop(&s);  
  13.             printf(”%c ”,t->data);  
  14.             t=t->rchild;  
  15.         }  
  16.     }  
  17. }  
void midorder(bintree t){
    seqstack s;
    s.top = -1;
    if(!t){
        printf("the tree is empty!\n");
    }else{
        while(t ||s.top != -1){
            while(t){
                push(&s,t);
                t= t->lchild;
            }
            t=pop(&s);
            printf("%c ",t->data);
            t=t->rchild;
        }
    }
}

 

3、后序遍历

因为后序遍历最后还要要访问根结点一次，所以要访问根结点两次。采取夹标志位的方法解决这个问题。

这段代码非常纠结，对自己有信心的朋友可以尝试独立写一下。反正我是写了很长时间。逻辑不难，我画了一张逻辑图：

 代码：

 

[cpp] view plain copy
print ?
  1. void postorder_dev(bintree t){  
  2.     seqstack s;  
  3.     s.top = -1;  
  4.     if(!t){  
  5.         printf(”the tree is empty!\n”);  
  6.     }else{  
  7.         while(t || s.top != -1){    //栈空了的同时t也为空。  
  8.             while(t){  
  9.                 push(&s,t);  
  10.                 s.tag[s.top] = 0;   //设置访问标记，0为第一次访问，1为第二次访问  
  11.                 t= t->lchild;  
  12.             }  
  13.             if(s.tag[s.top] == 0){  //第一次访问时，转向同层右结点  
  14.                 t= s.data[s.top];   //左走到底时t是为空的，必须有这步！  
  15.                 s.tag[s.top]=1;       
  16.                 t=t->rchild;  
  17.             }else {  
  18.                 while (s.tag[s.top] == 1){ //找到栈中下一个第一次访问的结点，退出循环时并没有pop所以为其左子结点  
  19.                     t = pop(&s);  
  20.                     printf(”%c ”,t->data);  
  21.                 }  
  22.                 t = NULL; //必须将t置空。跳过向左走，直接向右走  
  23.             }  
  24.         }  
  25.     }  
  26. }  
void postorder_dev(bintree t){
    seqstack s;
    s.top = -1;
    if(!t){
        printf("the tree is empty!\n");
    }else{
        while(t || s.top != -1){    //栈空了的同时t也为空。
            while(t){
                push(&s,t);
                s.tag[s.top] = 0;   //设置访问标记，0为第一次访问，1为第二次访问
                t= t->lchild;
            }
            if(s.tag[s.top] == 0){  //第一次访问时，转向同层右结点
                t= s.data[s.top];   //左走到底时t是为空的，必须有这步！
                s.tag[s.top]=1;     
                t=t->rchild;
            }else {
                while (s.tag[s.top] == 1){ //找到栈中下一个第一次访问的结点，退出循环时并没有pop所以为其左子结点
                    t = pop(&s);
                    printf("%c ",t->data);
                }
                t = NULL; //必须将t置空。跳过向左走，直接向右走
            }
        }
    }
}


 4、层次遍历：即每一层从左向右输出

元素需要储存有先进先出的特性，所以选用队列存储。

队列的定义：

[cpp] view plain copy
print ?
  1. #define MAX 1000  
  2.   
  3. typedef struct seqqueue{  
  4.     bintree data[MAX];  
  5.     int front;  
  6.     int rear;  
  7. }seqqueue;  
  8.   
  9.   
  10. void enter(seqqueue *q,bintree t){  
  11.     if(q->rear == MAX){  
  12.         printf(”the queue is full!\n”);  
  13.     }else{  
  14.         q->data[q->rear] = t;  
  15.         q->rear++;  
  16.     }  
  17. }  
  18.   
  19. bintree del(seqqueue *q){  
  20.     if(q->front == q->rear){  
  21.         return NULL;  
  22.     }else{  
  23.         q->front++;  
  24.         return q->data[q->front-1];  
  25.     }  
  26. }  
#define MAX 1000

typedef struct seqqueue{
    bintree data[MAX];
    int front;
    int rear;
}seqqueue;


void enter(seqqueue *q,bintree t){
    if(q->rear == MAX){
        printf("the queue is full!\n");
    }else{
        q->data[q->rear] = t;
        q->rear++;
    }
}

bintree del(seqqueue *q){
    if(q->front == q->rear){
        return NULL;
    }else{
        q->front++;
        return q->data[q->front-1];
    }
}


遍历实现 

[cpp] view plain copy
print ?
  1. void level_tree(bintree t){  
  2.     seqqueue q;  
  3.     bintree temp;  
  4.     q.front = q.rear = 0;  
  5.     if(!t){  
  6.         printf(”the tree is empty\n”);  
  7.         return ;  
  8.     }  
  9.     enter(&q,t);  
  10.     while(q.front != q.rear){  
  11.         t=del(&q);  
  12.         printf(”%c ”,t->data);  
  13.         if(t->lchild){  
  14.             enter(&q,t->lchild);  
  15.         }  
  16.         if(t->rchild){  
  17.             enter(&q,t->rchild);  
  18.         }  
  19.     }  
  20. }  
void level_tree(bintree t){
    seqqueue q;
    bintree temp;
    q.front = q.rear = 0;
    if(!t){
        printf("the tree is empty\n");
        return ;
    }
    enter(&q,t);
    while(q.front != q.rear){
        t=del(&q);
        printf("%c ",t->data);
        if(t->lchild){
            enter(&q,t->lchild);
        }
        if(t->rchild){
            enter(&q,t->rchild);
        }
    }
}


 

5、利用前序遍历的结果生成二叉树

[cpp] view plain copy
print ?
  1. //递归调用，不存点，想的时候只关注于一个点，因为还会回来的，不要跟踪程序运行，否则容易多加循环  
  2.   
  3. void createtree(bintree *t){        
  4.     datatype c;  
  5.     if((c=getchar()) == ‘#’)  
  6.         *t = NULL;  
  7.     else{  
  8.         *t = (bintree)malloc(sizeof(BinNode));  
  9.         (*t)->data = c;  
  10.         createtree(&(*t)->lchild);  
  11.         createtree(&(*t)->rchild);  
  12.     }  
  13. }  
//递归调用，不存点，想的时候只关注于一个点，因为还会回来的，不要跟踪程序运行，否则容易多加循环

void createtree(bintree *t){      
    datatype c;
    if((c=getchar()) == '#')
        *t = NULL;
    else{
        *t = (bintree)malloc(sizeof(BinNode));
        (*t)->data = c;
        createtree(&(*t)->lchild);
        createtree(&(*t)->rchild);
    }
}


6、二叉树的查找

[cpp] view plain copy
print ?
  1. bintree search_tree(bintree t,datatype x){  
  2.     if(!t){  
  3.         return NULL;  
  4.     }  
  5.     if(t->data == x){  
  6.         return t;  
  7.     }else{  
  8.         if(!search_tree(t->lchild,x)){  
  9.             return search_tree(t->rchild,x);  
  10.         }  
  11.         return t;  
  12.     }  
  13. }  
bintree search_tree(bintree t,datatype x){
    if(!t){
        return NULL;
    }
    if(t->data == x){
        return t;
    }else{
        if(!search_tree(t->lchild,x)){
            return search_tree(t->rchild,x);
        }
        return t;
    }
}


7、统计结点个数

[cpp] view plain copy
print ?
  1. int count_tree(bintree t){  
  2.     if(t){  
  3.         return (count_tree(t->lchild)+count_tree(t->rchild)+1);  
  4.     }  
  5.     return 0;  
  6. }  
int count_tree(bintree t){
    if(t){
        return (count_tree(t->lchild)+count_tree(t->rchild)+1);
    }
    return 0;
}


8、比较两个树是否相同

[cpp] view plain copy
print ?
  1. int is_equal(bintree t1,bintree t2){  
  2.     if(!t1 && !t2){      //都为空就相等  
  3.         return 1;  
  4.     }  
  5.     if(t1 && t2 && t1->data == t2->data){      //有一个为空或数据不同就不判断了  
  6.         if(is_equal(t1->lchild,t2->lchild))  
  7.             if(is_equal(t1->rchild,t2->rchild)){  
  8.                 return 1;  
  9.             }  
  10.     }  
  11.     return 0;  
  12. }  
int is_equal(bintree t1,bintree t2){
    if(!t1 && !t2){      //都为空就相等
        return 1;
    }
    if(t1 && t2 && t1->data == t2->data){      //有一个为空或数据不同就不判断了
        if(is_equal(t1->lchild,t2->lchild))
            if(is_equal(t1->rchild,t2->rchild)){
                return 1;
            }
    }
    return 0;
}


9、求二叉树的深度

[cpp] view plain copy
print ?
  1. int hight_tree(bintree t){  
  2.     int h,left,right;  
  3.     if(!t){  
  4.         return 0;  
  5.     }  
  6.     left = hight_tree(t->lchild);  
  7.     right = hight_tree(t->rchild);  
  8.     h = (left>right?left:right)+1;  
  9.     return h;  
  10. }  
int hight_tree(bintree t){
    int h,left,right;
    if(!t){
        return 0;
    }
    left = hight_tree(t->lchild);
    right = hight_tree(t->rchild);
    h = (left>right?left:right)+1;
    return h;
}

关注我的微信公众号,获取更多优质内容

巴比伦神话
关注
专栏目录
数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现
阿修罗道
09-22 33万+
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若
二叉树遍历及基本操作
s_liang666的博客
07-29 311
一、二叉树遍历 1、前序遍历（根左右----DLR） /* 递归 */ void PreOrder(BiTNode *root) { if(root == nullptr) return; cout<<root->data<<" "; //先输出当前结点 PreOrder(root->lchild); //输出左孩子 PreOrder(root->rchild); //输出右孩子 } /* 非递归 */ void Pre
关于二叉树结构的一个应用小实例
04-25
假设以如下说明的三元组 (F、C、L/R) 序列输入一棵二叉树的诸边(其中 F 表示双亲结点的标识，C 表示孩子结点标识，L/R 表示 C 为 F 的左孩子或右孩子)，且在输入的三元组序列中，C 是按层次顺序出现的。设结点的标识是字符类型。F=‘＾’时 C 为根结点标识，若 C 亦为‘＾’，则表示输入结束。试编写算法，由输入的三元组序列建立二叉树的二叉链表,并以中序序列输出。 ^AL ABL ACR BDL CEL CFR DGR FHL ^^L
二叉树的遍历
虫师
04-18 237
二叉树的遍历有三种方式，如下： （1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。 （2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。 （3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。 例1：如上图所示的二叉树，若按前序遍历，则其输出...
二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现...
weixin_30588907的博客
09-28 350
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结...
二叉树的应用
Xym's Blog
03-14 233
二叉树的应用 给出二叉树自下而上，自右到左的层次遍历算法，算法思想：在一般的层次遍历的同时出队，并将结点放入栈中，最后从栈顶开始出栈即是逆序的层次遍历 void ReverseLevel(BiTree T) { stack<BiTree> s; queue<BiTree> q; BiTree p; if (T) { q.p...
java 二叉树遍历
11-14
Java 二叉树遍历 二叉树是一种重要的数据结构，在计算机科学中有广泛的应用。在 Java 语言中，二叉树的遍历是指从根结点开始，按照一定的顺序访问二叉树中的每个结点。下面将详细介绍 Java 二叉树遍历的知识点。 ...
数据结构二叉树遍历.doc
10-02
二叉树遍历的应用非常广泛，如在数据库系统中，二叉树遍历可以用于查询和统计数据；在编译器中，二叉树遍历可以用于语法分析和语义分析等。 下面是前序遍历算法的实现代码： ``` 算法 6.1 void Preorder(Bitree T,...
数据结构二叉树的应用实例
02-25
c++ 数据结构 二叉树的应用实例 详细的介绍了二叉树的应用
二叉树的实际应用（应用场景）
心向暖的博客
03-20 3万+
哈夫曼编码，来源于哈夫曼树（给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman tree)。即带权路径长度最短的树），在数据压缩上有重要应用，提高了传输的有效性，详见《信息论与编码》。 海量数据并发查询，二叉树复杂度是O(K+LgN)。二叉排序树就既有链表的好处，也有数组的好处，在处理大批量的动态的数据是比较有用。 ...
二叉树的应用举例——哈夫顿树及哈夫曼编码
m0_65503491的博客
02-01 508
数据结构之二叉树的应用 哈夫曼树 哈夫曼算法及哈夫曼编码
（接上一篇）二叉树的基本应用举例
razorEdge的博客
11-10 1334
后序遍历和层序遍历 上一篇博文中已经通过该死的递归把二叉树通过前序和中序序列给重建出来了，当然我们应该来应用这可二叉树，以便验证我们建立的效果。 当然，善于实践的你可能已经知道了上篇博文中的代码不能直接运行，因为里面还有其他的一些函数没有定义而只是给出了声明。如： 这两个函数是实现了后序遍历打印和层序遍历打印的功能，下面给出简要的阐述： 后序打印二叉树函数定义： 我们不禁感叹递归真
遍历二叉树
weixin_52555350的博客
03-25 5271
二叉树遍历
二叉树遍历
最新发布
qq_55078860的博客
07-07 882
例如，“DBACEGF ABCDEFG”，通过先序遍历知道根节点为D，根据中序遍历可知，左子树中序遍历为ABC，右子树中序遍历为EFG，然后通过先序遍历得到左右子树的先序遍历（BAC、EGF）和根节点D的左右节点（B、E），继续对左右子树（“BAC ABC”、“EGF EFG”）进行上述操作，直至结束。基于先序序列和中序序列的节点数目相同，得到k-il=x-pl，所以x=k-il+pl，那么左子树先序序列[pl+1,k-il+pl]；注意：访问根，先序遍历左子树，左子树为空或已遍历才可以遍历右子树。
二叉树遍历（前序、中序、后序、层次遍历、深度优先、广度优先）
热门推荐
My_Jobs的专栏
02-03 39万+
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值