34.二叉链树的C语言实现

已于 2023-10-05 22:07:51 修改
阅读量156 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 开发语言
于 2023-10-05 22:03:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54708219/article/details/133581706
版权

目录

（1）二叉树的数据结构

（2）以前序序列建立二叉树

（3）求树的结点数

（4）求树的层数

（5）结点查找

（6）前序遍历（递归算法和非递归算法）

（7）中序遍历（递归算法和非递归算法）

（8）后序遍历（递归算法和非递归算法）

（9）层次遍历算法

（10）遍历过程中借助的栈和队列算法

全部代码

包含二叉链树的建立，计数，查找，各种遍历。

（1）二叉树的数据结构

//二叉链树的结构体定义
typedef struct BiTNode{
    ElemType data;  //数据域
    BiTNode *lchild;  //指向左子树根节点的指针
	BiTNode *rchild;  //指向右子树根节点的指针
}BiTNode, *BiTree;

（2）以前序序列建立二叉树

//前序序列建立二叉树
void CreateBiTree(BiTree &T){
    ElemType ch;
    scanf("%c", &ch);
    if (ch == '#')
        T = NULL;  //保证是叶结点
    else{
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;  //生成结点
        CreateBiTree(T->lchild);  //构造左子树
        CreateBiTree(T->rchild);  //构造右子树    
    }
}

（3）求树的结点数

//求树的结点数（递归）
int Number_Node(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return Number_Node(T->lchild) + Number_Node(T->rchild) + 1;
    }
}

（4）求树的层数

//求树的层数（递归）
int Depth(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return (Depth(T->lchild) >= Depth(T->rchild)) ? Depth(T->lchild) + 1 : Depth(T->rchild) + 1;
    }
}

（5）结点查找

//查找结点，并说明它在第几层
BiTree Search(BiTree T, char a, int level){
    if(T == NULL)
        return NULL;
    else if(T->data == a){
        printf("查找成功！元素在第%d层\n",level);
        return T;
    }
    else{
        Search(T->lchild, a, level + 1);
        Search(T->rchild, a, level + 1);
    }
}

（6）前序遍历（递归算法和非递归算法）

//前序遍历（递归算法）
void PreOrderTraverse(BiTree T){
	if (T!=NULL){
		printf("%c", T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

//前序遍历（非递归算法）
void PreOrderTraverse2(BiTree T){
    BiTree p = T; //p是遍历指针
    Sqstack S;
    InitStack(S);
    while(p != NULL|| !IsStackEmpty(S)){
        if(p){
            printf("%c", p->data);
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = DeleteSqstack(S, p);
            p = p->rchild;
        }
    }
}

（7）中序遍历（递归算法和非递归算法）

//中序遍历（递归算法）
void InOrderTraverse(BiTree T){
	if (T!=NULL){
		InOrderTraverse(T->lchild);
        printf("%c", T->data);
		InOrderTraverse(T->rchild);
	}
}

//中序遍历（非递归算法）
void InOrderTraverse2(BiTree T){
    BiTree p = T; //p是遍历指针
    Sqstack S;
    InitStack(S);
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = DeleteSqstack(S, p);
            printf("%c", p->data);
            p = p->rchild;
        }
    }
}

（8）后序遍历（递归算法和非递归算法）

//后序遍历（递归算法）
void PostOrderTraverse(BiTree T){
	if (T!=NULL){
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
        printf("%c", T->data);
	}
}

//后序遍历（非递归算法）
void PostOrderTraverse2(BiTree T){
    Sqstack S;
    InitStack(S);
    BiTree p = T;
    BiTree r = NULL;
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = S.data[S.top];  //读栈顶元素（但不出栈）
            if(p->rchild&&p->rchild!=r){
                p = p->rchild;
            }
            else{
                p = DeleteSqstack(S, p);
                printf("%c", p->data);
                r = p;
                p = NULL;
            }
        }
    }
}

（9）层次遍历算法

//层次遍历
void LevelOrder(BiTree T){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        printf("%c", p->data);
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
}

（10）遍历过程中借助的栈和队列算法

//（循环）队列和栈的数据结构
typedef struct Queue{
	BiTree data[MAXSIZE];
    int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    int tag;
}Queue;
typedef struct Sqstack{
    BiTree data[MAXSIZE];
    int top;  //栈顶指针指向栈顶元素
}Sqstack;

//初始化
int InitQueue(Queue &a){
    a.front = 0;
    a.rear = 0;
    a.tag = 0;  //初始队列是空
    return 1;
}
int InitStack(Sqstack &a){
    a.top = -1;  //初始栈顶指针是-1
    return 1;
}

//判断栈和队列是否为空
bool IsStackEmpty(Sqstack S){
    if(S.top ==-1)
        return true;
    else
        return false;
}
bool IsQueueEmpty(Queue q){
    if(q.tag == 0 && q.front==q.rear)
        return true;
    else
        return false;
}

//插入
int InsertQueue(Queue &a, BiTree x){
    if(a.front == a.rear && a.tag == 1){
        printf("当前队列已满！");
        return 0;
    }
    else{
        a.data[a.rear] = x;
        a.tag = 1;  //插入队列tag置1
        a.rear = (a.rear + 1) % MAXSIZE;
        return 1;
    }  
}
int InsertSqstack(Sqstack &a, BiTree x){
    if(a.top == MAXSIZE-1){
        printf("当前栈已满！");
        return 0;
    }
    else{
        a.top = a.top + 1;
        a.data[a.top] = x;
        return 1;
    } 
}

//删除
BiTree DeleteQueue(Queue &a,BiTree x){
    if(a.front == a.rear && a.tag == 0){
        printf("当前队列已空！");
    }
    else{
        x = a.data[a.front];
        a.tag = 0;  //删除队列tag置0
        a.front = (a.front + 1) % MAXSIZE;  //front指针+1
        return x;
    }  
}
BiTree DeleteSqstack(Sqstack &a, BiTree x){
    if(a.top == -1){
        printf("当前栈已空！");
    }
    else{
        x = a.data[a.top];
        a.top = a.top - 1;
        return x;
    }  
}

全部代码

本次验证的二叉树如下图：

注意：输入的是扩展二叉树，也就是要告诉计算机什么是叶结点，否则将一直递归，当输入“#”时，指针指向NULL，说明是叶结点。例如对于上图，输入的是ABD##E##C##。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 100
#define ElemType char

//二叉链树的结构体定义
typedef struct BiTNode{
    ElemType data;  //数据域
    BiTNode *lchild;  //指向左子树根节点的指针
	BiTNode *rchild;  //指向右子树根节点的指针
}BiTNode, *BiTree;

//（循环）队列和栈的数据结构
typedef struct Queue{
	BiTree data[MAXSIZE];
    int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    int tag;
}Queue;
typedef struct Sqstack{
    BiTree data[MAXSIZE];
    int top;  //栈顶指针指向栈顶元素
}Sqstack;

//初始化
int InitQueue(Queue &a){
    a.front = 0;
    a.rear = 0;
    a.tag = 0;  //初始队列是空
    return 1;
}
int InitStack(Sqstack &a){
    a.top = -1;  //初始栈顶指针是-1
    return 1;
}

//判断栈和队列是否为空
bool IsStackEmpty(Sqstack S){
    if(S.top ==-1)
        return true;
    else
        return false;
}
bool IsQueueEmpty(Queue q){
    if(q.tag == 0 && q.front==q.rear)
        return true;
    else
        return false;
}

//插入
int InsertQueue(Queue &a, BiTree x){
    if(a.front == a.rear && a.tag == 1){
        printf("当前队列已满！");
        return 0;
    }
    else{
        a.data[a.rear] = x;
        a.tag = 1;  //插入队列tag置1
        a.rear = (a.rear + 1) % MAXSIZE;
        return 1;
    }  
}
int InsertSqstack(Sqstack &a, BiTree x){
    if(a.top == MAXSIZE-1){
        printf("当前栈已满！");
        return 0;
    }
    else{
        a.top = a.top + 1;
        a.data[a.top] = x;
        return 1;
    } 
}

//删除
BiTree DeleteQueue(Queue &a,BiTree x){
    if(a.front == a.rear && a.tag == 0){
        printf("当前队列已空！");
    }
    else{
        x = a.data[a.front];
        a.tag = 0;  //删除队列tag置0
        a.front = (a.front + 1) % MAXSIZE;  //front指针+1
        return x;
    }  
}
BiTree DeleteSqstack(Sqstack &a, BiTree x){
    if(a.top == -1){
        printf("当前栈已空！");
    }
    else{
        x = a.data[a.top];
        a.top = a.top - 1;
        return x;
    }  
}

//前序序列建立二叉树
void CreateBiTree(BiTree &T){
    ElemType ch;
    scanf("%c", &ch);
    if (ch == '#')
        T = NULL;  //保证是叶结点
    else{
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;  //生成结点
        CreateBiTree(T->lchild);  //构造左子树
        CreateBiTree(T->rchild);  //构造右子树    
    }
}

//求树的结点数（递归）
int Number_Node(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return Number_Node(T->lchild) + Number_Node(T->rchild) + 1;
    }
}

//求树的层数（递归）
int Depth(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return (Depth(T->lchild) >= Depth(T->rchild)) ? Depth(T->lchild) + 1 : Depth(T->rchild) + 1;
    }
}

//查找结点，并说明它在第几层
BiTree Search(BiTree T, char a, int level){
    if(T == NULL)
        return NULL;
    else if(T->data == a){
        printf("查找成功！元素在第%d层\n",level);
        return T;
    }
    else{
        Search(T->lchild, a, level + 1);
        Search(T->rchild, a, level + 1);
    }
}

//前序遍历（递归算法）
void PreOrderTraverse(BiTree T){
	if (T!=NULL){
		printf("%c", T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
//前序遍历（非递归算法）
void PreOrderTraverse2(BiTree T){
    BiTree p = T; //p是遍历指针
    Sqstack S;
    InitStack(S);
    while(p != NULL|| !IsStackEmpty(S)){
        if(p){
            printf("%c", p->data);
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = DeleteSqstack(S, p);
            p = p->rchild;
        }
    }
}

//中序遍历（递归算法）
void InOrderTraverse(BiTree T){
	if (T!=NULL){
		InOrderTraverse(T->lchild);
        printf("%c", T->data);
		InOrderTraverse(T->rchild);
	}
}
//中序遍历（非递归算法）
void InOrderTraverse2(BiTree T){
    BiTree p = T; //p是遍历指针
    Sqstack S;
    InitStack(S);
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = DeleteSqstack(S, p);
            printf("%c", p->data);
            p = p->rchild;
        }
    }
}

//后序遍历（递归算法）
void PostOrderTraverse(BiTree T){
	if (T!=NULL){
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
        printf("%c", T->data);
	}
}
//后序遍历（非递归算法）
void PostOrderTraverse2(BiTree T){
    Sqstack S;
    InitStack(S);
    BiTree p = T;
    BiTree r = NULL;
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = S.data[S.top];  //读栈顶元素（但不出栈）
            if(p->rchild&&p->rchild!=r){
                p = p->rchild;
            }
            else{
                p = DeleteSqstack(S, p);
                printf("%c", p->data);
                r = p;
                p = NULL;
            }
        }
    }
}

//层次遍历
void LevelOrder(BiTree T){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        printf("%c", p->data);
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("二叉树的前序遍历序列是：");
    PreOrderTraverse(T);
    printf("\n");
    printf("二叉树的中序遍历序列是：");
    InOrderTraverse(T);
    printf("\n");
    printf("二叉树的后序遍历序列是：");
    PostOrderTraverse(T);
    printf("\n");
    printf("二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    Search(T, 'D', 1);  //第1个结点在第1层
    printf("二叉树的元素个数是：%d\n", Number_Node(T));
    printf("二叉树的深度是：%d\n", Depth(T));

    printf("二叉树的前序遍历序列（非递归）是：");
    PreOrderTraverse2(T);
    printf("\n");
    printf("二叉树的中序遍历序列（非递归）是：");
    InOrderTraverse2(T);
    printf("\n");
    printf("二叉树的后序遍历序列（非递归）是：");
    PostOrderTraverse2(T);
    printf("\n");
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
二叉树的前序遍历序列是：ABDEC
二叉树的中序遍历序列是：DBEAC
二叉树的后序遍历序列是：DEBCA
二叉树的层次遍历序列是：ABCDE
查找成功！元素在第3层
二叉树的元素个数是：5
二叉树的深度是：3
二叉树的前序遍历序列（非递归）是：ABDEC
二叉树的中序遍历序列（非递归）是：DBEAC
二叉树的后序遍历序列（非递归）是：DEBCA
北京地铁1号线
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言程序构造二叉排序树,C语言实现二叉排序树的相关操作
weixin_35569158的博客
05-24 1301
本文链接：二叉排序树(Binary Sort Tree)c语言 二叉排序树，又称为二叉查找树。它或则是一颗空树，或者是带有以下性质的二叉树：构造二叉排序树的目的，并不是为了顺序，而是为了提升查找和插入删除关键字的速度。以下程序在DEV C++中安装运行通过。#include#include/*二叉树的二叉链表结点结构定义*/typedef struct BiTNode{int data;struc...
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出，它的设计目标是在保持查询效率的同时，通过特定的规则...理解并熟练掌握红黑树的原理和C语言实现，对于提升编程技能和解决复杂问题的能力具有重要意义。
二叉搜索树的实现(C语言)
2301_76269963的博客
05-27 3209
二叉搜索树的实现(C语言)
c语言二叉搜索树程序,二叉搜索树 C语言实现
weixin_39851977的博客
05-19 359
1、二叉搜索树基本概念二叉搜索树又称二叉排序树，它或者是一棵空树，或者是一棵具有如下特性的非空二叉树：(1)若它的左子树非空，则左子树上所有结点的关键字均小于根结点的关键字；(2)若它的右子树非空，则右子树上所有结点的关键字均大于(允许的话，也可大于等于)根结点的关键字；(3)左右子树本身又各是一个二叉搜索树。根据二叉搜索树的特点知：对二叉搜索树进行中序遍历得到的结点序列必然是一个有序序列。2、二...
二叉查找树的编程与实现 C语言
热门推荐
timerring的博客
07-10 5万+
输入数据的第一行为一个正整数T，表示测试数据的组数，即共 T 组测试数据。每组测试数据的第一行输入正整数 n(5 ≤n ≤20)，第二行输入n个整数，要求依次完成以下工作：1）以这n个整数生成一棵用链式存储结构存储的二叉排序树2）按递增顺序输出该二叉排序树中所有数3）输入一个整数key ，对该二叉排序树进行查找，若在该二叉排序树中存在这个整数key ，则输出find ，否则输出not find；4）输入一个整数key，若该二叉排序树中不存在这个整数key，则将key 插入到该二叉排序树中，使插入后仍为原性质
【零基础算法】C语言实现二叉搜索树
C_Ryson的博客
10-25 1589
本文为c语言实现二叉搜索树
【数据结构】树（五）—— 二叉排序树（C语言版）
haoweixl的博客
09-05 1万+
【数据结构】二叉排序树（C语言版）前言一、二叉排序树的定义二、二叉排序树的性质三、二叉排序树的操作二叉排序树常用存储结构二叉排序树的查找(递归实现)查找"二叉树T"中键值为 key 的节点(非递归实现)查找"二叉树T"中键值为 key 的节点二叉排序树的插入二叉排序树的创建二叉排序树的删除四、二叉树的查找性能分析应用区分：（与二分查找的应用区分）二叉排序树的构造树结构分析完整可运行代码 前言 二叉排序树(Binary Sort Tree,BST)又称为二叉查找树、二叉搜索树。与树型查找有关的结构有二叉排序树
09.二叉排序树和平衡二叉树
gudongkun1121的博客
01-21 1785
一、二叉排序树 1.什么是二叉排序树 二叉排序树要么是空二叉树 ，要么具有如下特点： 二叉排序树中，如果其根结点有左子树，那么左子树上所有结点的值都小于根结点的值； 二叉排序树中，如果其根结点有右子树，那么右子树上所有结点的值都大于根结点的值； 二叉排序树的左右子树也要求都是二叉排序树； 如下图就是一个二叉排序树： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsGloKcV-1642763317481)(C:\Users\86186\AppData\Roaming\T
c语言取根,二叉查找树C语言实现
weixin_39701861的博客
05-20 133
今天练习一下二叉查找树的东东，感觉这个东西，找前驱和后继结点有些绕，再通过后继结点实现删除，更需要好好想一想流程。参照算法导论经典，经过自己的思考，将其中提到的一些基本操作实现了。说明都在注释里呢，这边迷糊的童鞋可以看看，好好想一下。 (我写的都是naive版本的代码，仅供理解算法本身)/*一个关键字元素不重复的二叉查找树及其典型操作的实现，记录关键字出现次数*/#include #include...
基于C语言实现的二叉排序树
demongwc的博客
07-23 359
一、使用说明 1.1 操作手册 运行程序后，进入欢迎界面 选择相应操作 点击此处下载文档和源码
动态规划最优二叉搜索树C语言,【算法导论】动态规划之“最优二叉搜索树”...
weixin_42505032的博客
05-23 1213
详解动态规划之“最优二叉搜索树”之前两篇分别讲了动态规划的“钢管切割”和“矩阵链乘法”，感觉到了这一篇，也可以算是收官之作了。其实根据前两篇，到这里，也可以进行一些总结的，我们可以找到一些规律性的东西。所谓动态规划，其实就是解决递归调用中，可能出现重复计算子问题，从而导致耗费大量时间，去做重复劳动的问题。解决思路就是，将重复做过的子问题的结果，先存起来，等之后再需要用到的时候，直接拿过来用，而不需...
C语言二叉排序（搜索）树实例
08-29
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且满足以下性质：对于任意节点，其左子树中的所有节点的键值都小于该节点的键值，而右子树中的...
二叉排序树
11-03
二叉排序树，又称二叉查找树或二叉有序树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
二叉排序树及其C代码
07-29
二叉排序树的实现代码可以使用C语言编写，如下所示： bi_search_tree.h： ```c #ifndef __BI_SEARCH_TREE_H__ #define __BI_SEARCH_TREE_H__ typedef int datatype; typedef struct bi_search_tree { datatype ...
常用数据结构 - C语言实现
06-18
树链剖分.cpp ---- NOTONLLY的SBT模板.cpp NOTONLLY的划分树模板.cpp NOTONLLY的后缀数组模板.cpp RMQ-ST算法.cpp RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维...
嵌入式学习Day12---C语言提升
m0_65301172的博客
07-24 702
指针数组是数组 ，而数组中的每个元素是指针数组指针是指针,指针指向一个数组（二级指针）2024年7月24日，已经学习了12天啦！C语言的学习也接近尾声了。今天主要学习了指针数组、数组指针、二级指针，时指针中算是难的部分也是C语言中算是的难的部分了。努努力，争取今天消化了。加油！
【C语言】数组
2401_86272648的博客
07-23 1227
数组就是一个同一类型数据的集合。数组里面的数据叫元素，元素可以只有1个也可以有很多个，但是不能没有。
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 386
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 232
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
c语言二叉链实现二叉树先序中序后序遍历操作
11-23
以下是C语言二叉链实现二叉树先序、中序、后序遍历的操作方法： 1. 定义二叉树结构体 ```c typedef struct BiTNode { char data; // 数据域 struct BiTNode *lchild, *rchild; // 左右子树指针 } BiTNode, *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北京地铁1号线

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

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

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

打赏作者

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

抵扣说明：

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

余额充值