二叉树的构建

二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作:二叉树的构建,查找,删除,二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历),二叉搜索树的构造等。
1. 二叉树的构建


  二叉树的基本构建方式为:添加一个节点,如果这是一棵空树,则将该节点作为根节点;否则按照从左到右、先左子树后右子树的顺序逐个添加节点。比如依次添加节点:1,6,10,2,7,11,则得到的二叉树为:


在这里,我们需要借助一个链表来保存节点,以实现二叉树的顺序插入,具体做法如下:
1.0 初始化一个用来保存二叉树节点的空链表;
1.1 插入一个节点,
①如果该树是一棵空树,则将该节点作为根节点,并且将该节点添加到链表中;
②如果该树不为空,取得链表第一个节点的值(注意不是链表的头节点)。如果该节点左子树为空,则将待插入节点添加到左子树,并且将左子树添加到链表;否则将待插入节点添加到右子树,将右子树添加到链表。此时,父节点的左右子树都不为空,将该父节点(即链表第一个节点)
弹出。
按照这样的顺序,我们就可以完成二叉树节点的顺序插入。


2. 二叉搜索树的构建


   二叉搜索树是这样一棵树:对于任意一个节点,其左子树的值均小于父节点的值;右子树的值均大于父节点的值。从二叉树的根节点开始,对于其左右子树均按照这样的方式递归插入,即可以得到一棵二叉搜索树。二叉搜索树具有很好的性质,因为它的有序性,如果在二叉搜索树中查找一个元素可以按照类似二分查找的方式进行;对于二叉搜索树,如果采用中序遍历则可以得到按照值递增排列的节点。二叉搜索树的具体构建方式如下:
插入一个节点:
2.1如果当前节点本身值为空,则将插入节点直接作为当前节点;
2.2如果当前节点本身值不为空,
①比较插入节点的值与当前节点的值,如果插入节点值小于当前节点值,则将该节点递归插入左子树;
②比较插入节点的值与当前节点的值,如果插入节点值大于当前节点值,则将该节点递归插入右子树;
③ 如果插入节点的值等于当前节点的值,则直接返回(即二叉搜索树每个节点的值都是不同的)。


3.二叉搜索树的查找


  二叉搜索树的查找类似于二分查找。具体步骤如下:
3.1 从根节点开始,比较查找值与当前节点值的大小:
① 如果当前节点值为空,则说明无法查找到该值,直接返回;
②如果当前节点值等于查找值,则查找成功;
③如果查找值小于当前节点的值,则递归查找左子树;
④如果查找值大于当前节点的值,则递归查找右子树。


4. 二叉搜索树的删除


   二叉搜索树的删除与查找基本类似,不同之处在于如果查找到了待删除的节点,则将该节点直接删除之后,还要进行如下操作保证删除节点之后的二叉树仍是一棵二叉搜索树:
①如果该删除节点没有左右子树,则直接删除该节点;
②如果该删除节点只有左子树(右子树),则将删除节点的父节点直接指向其左子树(右子树);
③如果该删除节点既有左子树又有右子树,则有下面的三种处理方法:
4.3.1:找到按照中序遍历该删除节点的直接前驱节点,将该节点转移到删除节点,然后删除这个前驱节点;
4.3.2:找到按照中序遍历该删除节点的直接后续节点,将该节点转移到删除节点,然后删除这个后序节点;
4.3.3:找到按照中序遍历该删除节点的直接前驱节点,将删除节点的左子树接到父节点上,将删除节点的右子树接到该前序节点的右子树上,然后删除节点。


5. 二叉树的前序遍历


  由于二叉树是递归定义的,所以二叉树的遍历一般也是采用递归的形式。前序遍历即采用先访问根节点,再访问左子树,最后访问右子树的顺序。前序遍历也是按照类似的方式递归遍历,具体操作如下:
① 如果当前节点值为空,返回;
②如果当前节点值不为空,打印当前节点值;递归遍历左子树;递归遍历右子树。


6. 二叉树的中序遍历


①如果当前节点值为空,返回;
②递归遍历左子树;打印当前节点的值;递归遍历右子树。


7. 二叉树的后序遍历


①如果当前节点值为空,返回;
②递归遍历左子树;递归遍历右子树;打印当前节点的值。


8. 二叉树的层次遍历


  二叉树的层次遍历,即从根节点开始,逐层按照从左到右的顺序遍历。层次遍历比前中后序遍历要麻烦一点,它需要借助一个额外的链表来保存节点进行遍历。具体做法如下:
①初始化一个用来保存二叉树节点的空链表;
②如果这是一棵空二叉树,直接返回;否则将根节点添加到链表;
③while(当链表不为空时)
  弹出链表第一个二叉树节点,打印该二叉树节点的值;
  如果该二叉树节点的左子树不为空,则将该左子树添加到链表;
  如果该二叉树节点的右子树不为空,则将该右子树添加到链表;


  以上就是关于二叉树的基本操作,下面是C语言具体实现的代码,供大家参考:


/*
二叉树的基本操作:插入,删除,查找,前序遍历,中序遍历,后序遍历,层次遍历
*/
#include<stdio.h>
#include<stdlib.h>
#define BLANK -1 
#define LEFT -2
#define RIGHT -3
typedef struct BINARY_TREE
{
    // 左子树
    struct BINARY_TREE *left;
    // 右子树
    struct BINARY_TREE *right;
    int value;
} Binary_tree;
typedef struct NODE
{
    struct NODE *link;
    Binary_tree *value;
} Node;


// 二叉树插入
int insert(Binary_tree *root,int value,Node *node_root);
// 二叉搜索树插入
int search_insert(Binary_tree *root,int value);
// 二叉树删除 
int erase(Binary_tree *roote,int value);
// 二叉搜索树查找
int search_find(Binary_tree *root,int value);
// 二叉树前序遍历
void pre_print(Binary_tree *root);
// 二叉树中序遍历
void mid_print(Binary_tree *root);
// 二叉树后序遍历
void back_print(Binary_tree *root);
// 层次遍历
void level_print(Binary_tree *root);
// 弹出链表第一个元素
Binary_tree* top(Node *root);
// 将元素添加到链表末尾
int append(Node *current,Binary_tree* value);




int main(void)
{
    Binary_tree *root = (Binary_tree*)malloc(sizeof(Binary_tree));
    if(root == NULL)
    {
        printf("Malloc memory failed!\n");
        exit(-1);
    }
    root->left = NULL;
    root->right = NULL;
    root->value = BLANK;
    Node *node_root = (Node*)malloc(sizeof(Node));
    if(node_root == NULL)
    {
        printf("Malloc memory failed!\n");
        exit(-1);
    }
    node_root->link = NULL;
    search_insert(root,10);
    search_insert(root,2);
    search_insert(root,2);
    search_insert(root,3);
    search_insert(root,4);
    search_insert(root,15);
    search_insert(root,6);
    search_find(root,15);
        /*
    insert(root,10,node_root);
    insert(root,2,node_root);
    insert(root,2,node_root);
    insert(root,3,node_root);
    insert(root,4,node_root);
    insert(root,15,node_root);
    insert(root,6,node_root);
    */
    printf("前序遍历: ");
    pre_print(root);
    puts("");
    printf("中序遍历: ");
    mid_print(root);
    puts("");
    printf("后序遍历: ");
    back_print(root);
    puts("");
    printf("层次遍历: ");
    level_print(root);
    puts("");
    free(root);
    return 0;
}
// 二叉树插入
int insert(Binary_tree *root,int value,Node *node_root)
{
    // 如果是空树
    if(root->left == NULL && root->right == NULL && root->value == BLANK)
    {
        root->value = value;
        append(node_root,root);
        printf("Insert %d into an empty link list!\n",value);
    }
    else
    {
        // 构造一个新节点
        Binary_tree *new_tree_node = (Binary_tree*)malloc(sizeof(Binary_tree));
        new_tree_node->value = value;
        new_tree_node->left = new_tree_node->right = NULL;
        // 得到链表第一个节点的值
        Binary_tree *current = node_root->link->value;
        // 如果左子树为空
        if(current->left == NULL)
        {
            current->left = new_tree_node;
            append(node_root,current->left);
            printf("Insert %d in parent's left node!\n",value);
        }   
        // 左子树不为空
        else
        {
            current->right = new_tree_node;
            append(node_root,current->right);
            printf("Insert %d in parent's right node!\n",value);
            top(node_root);
        }
    }
    return 0;
}
// 二叉搜索树插入
int search_insert(Binary_tree *root,int value)
{
    // 如果左右子树都为空且根节点值为小于0(BLANK 或者 LEFT 或者 RIGHT)
    if(root->left == NULL && root->right == NULL && root->value < 0)
    {
        if(root->value == BLANK)
            printf("Insert %d into an empty binary tree succeed!\n",value);
        else if(root->value == LEFT)
            printf("Insert %d into parent's left node succeed!\n",value);
        else
            printf("Insert %d into parent's right node succeed!\n",value);
        root->value = value;
        return value;
    }
    if(value < root->value)
    {
        if(root->left == NULL)
        {
            root->left = (Binary_tree*)malloc(sizeof(Binary_tree));
            if(root->left == NULL)
            {
                printf("Malloc memory failed!\n");
                exit(-1);
            }
            root->left->value = LEFT;
            root->left->left = root->left->right = NULL;
        }
        search_insert(root->left,value);
    }
    else if(value > root->value)
    {
        if(root->right == NULL)
        {
            root->right = (Binary_tree*)malloc(sizeof(Binary_tree));
            if(root->right == NULL)
            {
                printf("Malloc memory failed!\n");
                exit(-1);
            }
            root->right->value = RIGHT;
            root->right->left = root->right->right = NULL;
        }
        search_insert(root->right,value);
    }
    else
    {
        printf("%d already exits in binary tree!\n");
        return value;
    }
}


// 二叉搜索树查找
int search_find(Binary_tree *root,int value)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
    {
        printf("Can't find %d in binary tree!\n",value);
        return -1;
    }
    if(root->value == value)
    {
        printf("Find %d in binary tree!\n",value);
        return 0;
    }
    else if(value < root->value)
    {
        if(root->left == NULL)
        {
            printf("Can't find %d in binary tree!\n",value);
            return -1;
        }
        search_find(root->left,value);
    }
        
    else
    {
        if(root->right == NULL)
        {
            printf("Can't find %d in binary tree!\n",value);
            return -1;
        }
        search_find(root->right,value);
    }   
}
// 二叉树前序遍历
void pre_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    printf("%d ",root->value);
    if(root->left != NULL)
        pre_print(root->left);
    if(root->right != NULL)
        pre_print(root->right);
}


// 二叉树中序遍历
void mid_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    if(root->left != NULL)
        pre_print(root->left);
    printf("%d ",root->value);
    if(root->right != NULL)
        pre_print(root->right);
}


// 二叉树后序遍历
void back_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == www.yibaoyule1.com NULL && root->value < 0)
        return;
    if(root->left != NULL)
        pre_print(root->left);
    if(root->right != NULL)
        pre_print(root->right);
    printf("%d ",root->value);
}


// 弹出链表第一个元素
Binary_tree* top(Node *root)
{
    if(root->link == NULL)
    {
        printf("Can't get top value from empty link list!\n");
        exit(-1);
    }
    Node *current = root->link;
    root->link = current->link;
    return current->value;
}
// 将元素添加到链表末尾
int append(Node *current,Binary_tree* value)
{
    Node *new_node = www.wangcai157.com (Node*)malloc(sizeof(Node));
    new_node->value = value;
    while(current->link www.jpg157.com != NULL)
    {
        current = current->link;
    }
    current->link = new_node;
    new_node->link = NULL;
    return 0;
}


// 二叉树层次遍历
void level_print(Binary_tree* root)
{
    if(root->left == NULL && www.xucaizxyl.com root->right == NULL && root->value < 0)
        return;
    Node *node_root = (Node*)(malloc(sizeof(Node)));
    node_root->link = NULL;
    append(node_root,root);
    Binary_tree* current;
    while(node_root->link != NULL)
    {
        current = top(node_root);
        printf("%d ",current->value);
        if(current->left != NULL)
            append(node_root,current-www.wanhengyl157.com>left);
        if(current->right != NULL)
            append(node_root,current->right);
    }
  • 1
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
完整版:https://download.csdn.net/download/qq_27595745/89522468 【课程大纲】 1-1 什么是java 1-2 认识java语言 1-3 java平台的体系结构 1-4 java SE环境安装和配置 2-1 java程序简介 2-2 计算机中的程序 2-3 java程序 2-4 java类库组织结构和文档 2-5 java虚拟机简介 2-6 java的垃圾回收器 2-7 java上机练习 3-1 java语言基础入门 3-2 数据的分类 3-3 标识符、关键字和常量 3-4 运算符 3-5 表达式 3-6 顺序结构和选择结构 3-7 循环语句 3-8 跳转语句 3-9 MyEclipse工具介绍 3-10 java基础知识章节练习 4-1 一维数组 4-2 数组应用 4-3 多维数组 4-4 排序算法 4-5 增强for循环 4-6 数组和排序算法章节练习 5-0 抽象和封装 5-1 面向过程的设计思想 5-2 面向对象的设计思想 5-3 抽象 5-4 封装 5-5 属性 5-6 方法的定义 5-7 this关键字 5-8 javaBean 5-9 包 package 5-10 抽象和封装章节练习 6-0 继承和多态 6-1 继承 6-2 object类 6-3 多态 6-4 访问修饰符 6-5 static修饰符 6-6 final修饰符 6-7 abstract修饰符 6-8 接口 6-9 继承和多态 章节练习 7-1 面向对象的分析与设计简介 7-2 对象模型建立 7-3 类之间的关系 7-4 软件的可维护与复用设计原则 7-5 面向对象的设计与分析 章节练习 8-1 内部类与包装器 8-2 对象包装器 8-3 装箱和拆箱 8-4 练习题 9-1 常用类介绍 9-2 StringBuffer和String Builder类 9-3 Rintime类的使用 9-4 日期类简介 9-5 java程序国际化的实现 9-6 Random类和Math类 9-7 枚举 9-8 练习题 10-1 java异常处理 10-2 认识异常 10-3 使用try和catch捕获异常 10-4 使用throw和throws引发异常 10-5 finally关键字 10-6 getMessage和printStackTrace方法 10-7 异常分类 10-8 自定义异常类 10-9 练习题 11-1 Java集合框架和泛型机制 11-2 Collection接口 11-3 Set接口实现类 11-4 List接口实现类 11-5 Map接口 11-6 Collections类 11-7 泛型概述 11-8 练习题 12-1 多线程 12-2 线程的生命周期 12-3 线程的调度和优先级 12-4 线程的同步 12-5 集合类的同步问题 12-6 用Timer类调度任务 12-7 练习题 13-1 Java IO 13-2 Java IO原理 13-3 流类的结构 13-4 文件流 13-5 缓冲流 13-6 转换流 13-7 数据流 13-8 打印流 13-9 对象流 13-10 随机存取文件流 13-11 zip文件流 13-12 练习题 14-1 图形用户界面设计 14-2 事件处理机制 14-3 AWT常用组件 14-4 swing简介 14-5 可视化开发swing组件 14-6 声音的播放和处理 14-7 2D图形的绘制 14-8 练习题 15-1 反射 15-2 使用Java反射机制 15-3 反射与动态代理 15-4 练习题 16-1 Java标注 16-2 JDK内置的基本标注类型 16-3 自定义标注类型 16-4 对标注进行标注 16-5 利用反射获取标注信息 16-6 练习题 17-1 顶目实战1-单机版五子棋游戏 17-2 总体设计 17-3 代码实现 17-4 程序的运行与发布 17-5 手动生成可执行JAR文件 17-6 练习题 18-1 Java数据库编程 18-2 JDBC类和接口 18-3 JDBC操作SQL 18-4 JDBC基本示例 18-5 JDBC应用示例 18-6 练习题 19-1 。。。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值