二叉排序树——理解与实现

最新推荐文章于 2021-03-30 22:01:58 发布
最新推荐文章于 2021-03-30 22:01:58 发布
阅读量413 收藏
点赞数 1
分类专栏： 算法 文章标签： 二叉排序树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t1234xy4/article/details/51570916
版权

转载请注明t1234xy4 原创：http://blog.csdn.net/t1234xy4/article/details/51570916
二叉树的基本操作：
创建：二叉树的创建就是插入一个节点
查找
深度
遍历
删除节点

下面我们简单的来分析：
一、插入节点
有递归实现与非递归，个人建议用非递归。插入节点的数量很大，树的深度也很大的时候，使用递归可能导致函数调用的递归栈溢出。总的来说，非递归的健壮性要强于递归。

步骤分解：
1、查找插入节点处；
2、插入节点；
先给出递归的实现：

void InsertBST(BinaryTreeNode** root,int key)
{
    if(root == NULL)  return ;
    if(*root == NULL)
    {
        BinaryTreeNode* pNode = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
        if(pNode == NULL) return ;
        pNode->m_Value  = key;
        pNode->m_pLeft = NULL;
        pNode->m_pRight = NULL;
        *root = pNode;
        return ;
    }

    if( key < (*root)->m_Value)
        InsertBST( &((*root)->m_pLeft),key);
    else if(key > (*root)->m_Value)
        InsertBST( &((*root)->m_pRight),key);
    else
        return;
}

步骤1：当root为空的时候，则为root节点；当root不为空时，利用二叉排序树的性质：一个节点的左子树都小于节点值，右子树都大于节点值。直到找为NULL的节点位置
步骤2：在步骤1中，需要使用两个指针，pRootNext用于指向需要插入的位置，pRoot用于指向pRootNext的父节点。然后可以通过生成节点插入到root树中。
插入的非递归实现：

void InsertBinarySortTree(BinaryTreeNode** root,int value)
{
    if(root==NULL) return ;  
    if(*root == NULL)
    {
        BinaryTreeNode* pNode = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
        if(pNode == NULL) return ;
        pNode->m_Value  = value;
        pNode->m_pLeft = NULL;
        pNode->m_pRight = NULL;

        *root = pNode;
        return ;
    }else if(root == NULL || *root == NULL)
        return ;

    BinaryTreeNode* pRoot = *root;
    BinaryTreeNode* pRootNext = NULL;

    if(pRoot->m_Value <value)
        pRootNext = pRoot->m_pRight;
    else if(pRoot->m_Value > value)
        pRootNext = pRoot->m_pLeft;
    else
        return ;

    while(pRootNext!=NULL)
    {
        pRoot = pRootNext;
        if(pRootNext->m_Value > value)
            pRootNext = pRootNext->m_pLeft;
        else if(pRoot->m_Value < value)
            pRootNext = pRootNext->m_pRight;
        else
            return ;
    }

    BinaryTreeNode* pNode = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
    if(pNode == NULL) return ;
    pNode->m_Value  = value;
    pNode->m_pLeft = NULL;
    pNode->m_pRight = NULL;

    if(pRoot->m_Value > value)
        pRoot->m_pLeft = pNode;
    else
        pRoot->m_pRight = pNode;
}

二、遍历
树的遍历使用递归很简单，当前我也没有写非递归的遍历，等下完了继续贴在下面，这里给出递归实现的先序遍历BinaryTreeDLR 和 中序遍历BinaryTreeLDR，通过这两个遍历，可以画出树的结构图，来检验自己的实现是否正确。
代码如下：

void BinaryTreeDLR(BinaryTreeNode* root)
{
    if(root == NULL)    return ;
     printf("%4d",root->m_Value);
     BinaryTreeDLR(root->m_pLeft);
     BinaryTreeDLR(root->m_pRight);
}

void BinaryTreeLDR(BinaryTreeNode* root)
{
    if(root == NULL)    return ;
     BinaryTreeDLR(root->m_pLeft);
     printf("%4d",root->m_Value);
     BinaryTreeDLR(root->m_pRight);
}

三、深度
树的深度计算也很简单，使用递归的方法如下：

/*to be test:
1:完全二叉树
2：满二叉树
3；空树
4：只有根节点的二叉树
*/

int DeepOfBinaryTree(BinaryTreeNode *root)
{
    if(root == NULL)
        return 0;

    int leftdeepth = DeepOfBinaryTree(root->m_pLeft);
    int rightdeepth = DeepOfBinaryTree(root->m_pRight);

    return (leftdeepth>rightdeepth)? (leftdeepth+1) : (rightdeepth+1);
}

非递归的方法等实现了继续更新。

四、收索
利用二叉排序树的特性也十分容易得到代码：
递归与非递归代码如下：

/*to be test:
1: 5 3 2 1 4 9 8 7      4
2: 5 3 2 1 4 9 8 7      6
3: 5 3 2 1 4 9 8 7      9
5: 5                    5
6: null                 4
*/
BinaryTreeNode* SearchBinaryTree(BinaryTreeNode* root,int key)
{
    if(root==NULL)  return NULL;
    if(key < root->m_Value) 
        SearchBinaryTree(root->m_pLeft,key);
    else if(key > root->m_Value)
        SearchBinaryTree(root->m_pRight,key);
    else
        return root;
    return NULL;
}

/*to be test:
1: 5 3 2 1 4 9 8 7      4
2: 5 3 2 1 4 9 8 7      6
3: 5 3 2 1 4 9 8 7      9
5: 5                    5
6: NULL                 4
*/
BinaryTreeNode* SearchBinaryTreeNoRecursion(BinaryTreeNode* root,int key)
{
    if(root == NULL) return NULL;
    BinaryTreeNode* pRoot;
    pRoot = root;
    while(pRoot!=NULL)
    {
        if(key < pRoot->m_Value)
            pRoot->m_pLeft;
        else if(key > pRoot->m_Value)
            pRoot = pRoot->m_pRight;
        else
            return pRoot;

    }
    return NULL;
}

五、删除
二叉排序树节点的删除比较复杂，是所有操作中最难与掌握的部分。步骤分解：
1、查找删除节点
2、判定待删除节点的类型
3、分类型删除节点
删除节点的类型分为：
1. 叶子节点
2. 只有左子树或者右子树的节点
3. 同时有左右子树的节点

三种情况：
叶子节点处理需要考虑：
1. 是根节点，且无叶子节点；
2. 不是根节点；
只有左或右子树的节点；
1. 是根节点，有一叶子节点；
2. 不是根节点；
同时有左右子树的节点：
查找后继节点，将后继节点与当前节点交换；然后转化为1、2情况。

/*to be test:
1: 5 3 2 1 4 9 8 7      4
2: 5 3 2 1 4 9 8 7      6
3: 5 3 2 1 4 9 8 7      9
4: 5 3 2 1 4 9 8 7      3
5: 5 3 2 1 4 9 8 7      1
5: 5                    5
6: 5 6 7 8  7           5
7: NULL                 4
*/
void DeleteKeyOfBinaryTree(BinaryTreeNode** root,int key)
{
    if(root==NULL || ((*root) == NULL) )
        return ;

    BinaryTreeNode* pRoot = *root;
    BinaryTreeNode* pRootNext = pRoot;

    while( pRootNext!=NULL )
    {
        if(key == pRootNext->m_Value)   break;
        pRoot = pRootNext;
        if(key > pRootNext->m_Value)
            pRootNext = pRootNext->m_pRight;
        else 
            pRootNext = pRootNext->m_pLeft;
    }

    if(pRootNext == NULL) return; //no key in Tree

    //convert Node with Two children to Node with one or none 
    if(pRootNext->m_pLeft != NULL && pRootNext->m_pRight != NULL)
    {
        BinaryTreeNode* pPNext = pRootNext;
        BinaryTreeNode* pNext = pRootNext->m_pRight;
        while(pNext->m_pLeft!=NULL)
        {
            pPNext = pNext;
            pNext = pNext->m_pLeft;
        }
        pRootNext->m_Value = pNext->m_Value;
        pRootNext = pNext;
        pRoot = pPNext;
    }

    //delete the node with zero child
    if(pRootNext->m_pLeft == NULL && pRootNext->m_pRight == NULL)
    {
        if(pRootNext == (*root))
            *root = NULL;
        else
            (pRootNext == pRoot->m_pLeft)? (pRoot->m_pLeft = NULL):(pRoot->m_pRight = NULL);
        free(pRootNext);
        return;
    }

    //delete the node with a child
    if(pRootNext->m_pLeft == NULL || pRootNext->m_pRight == NULL)
    {
        if(pRoot == pRootNext) //key is the root value
            (pRootNext->m_pLeft != NULL)?( (*root) = pRootNext->m_pLeft):((*root) = pRootNext->m_pRight);
        else if(pRootNext == pRoot->m_pLeft) //only with the left child
            (pRootNext->m_pLeft != NULL)?(pRoot->m_pLeft = pRootNext->m_pLeft):(pRoot->m_pLeft = pRootNext->m_pRight);
        else //only with the right child
            (pRootNext->m_pLeft != NULL)?(pRoot->m_pRight = pRootNext->m_pLeft):(pRoot->m_pRight = pRootNext->m_pRight);
        free(pRootNext);
        return;
    }
}

源码下载点：http://download.csdn.net/detail/t1234xy4/9539861

完全理解二叉树(下)——平衡二叉树、二叉排序树、哈夫曼树
Nikki_o3o的博客
06-11 958
二叉树的应用 1. 平衡二叉树 二叉树可以用于查找元素，对于如下这颗二叉树： 对其的遍历相当于对链表的遍历，因此找到元素5需要从头开始，查找5次，但是如果树的形状是这样： 从根结点出发只需要查找3次即可找到元素5。 1.1 定义 左右子树高度差不超过1的二叉树称为平衡二叉树(AVL树)，注意是对于树中的任意结点。 例如： 都不是平衡二叉树。 结点的平衡因子 = 左子树高 - 右子树高，平衡因子的绝对值不超过1，如下图所示： 1.2 存储结构 typedef struct AVLTreeNode*
【数据结构】-二叉树的应用(二叉排序树)
RunningSnail的博客
08-12 3280
二叉排序树BST1.头文件及类型定义2.二叉排序树结点类型定义3.函数声明4.基本操作4.1 查找操作4.1.1 非递归查找4.1.2 递归查找4.2 插入操作4.2.1 非递归插入4.2.2 递归插入4.3 构造二叉排序树4.4 删除操作4.4.1 寻找最左下结点4.4.2 寻找最右下结点4.4.3 删除操作-用右子树中最左下结点填充4.4.4 删除操作-用左子树中最右下结点填充4.5 中序遍历4.6 main函数4.7 测试结果5.小结 1.头文件及类型定义 #include<stdio.h&gt
二叉排序树理解
weixin_45362971的博客
12-26 507
什么是二叉树 二叉树（Binary tree）是树型结构中一个非常重要的类型，许多问题抽象出来都是树的形式，二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点。 什么是二叉排序树 二叉排序树，是普通二叉树的有序形式 特点: 1.如果左子树不为空，左子树的所有节点都比根节点要小 2.如果右子树不为空，右子树的所有节点都比根节点要大 3.左右子树也分别为二叉排序
二叉排序树的理解
qq_28528625的博客
12-14 177
转载至http://blog.csdn.net/jialeheyeshu/article/details/52343791 二叉树遍历的理解 如果对于上述遍历仍然不清楚可以看看下面对于二叉树的遍历理解 要想彻底的理解递归就必须对程序调用子程序的过程有所了解，也就是系统对程序点的压栈和出栈操作，在主程序调用子程序的时候，系统是将子程序的入口点做压栈操作，在调用完子程序后，系统执
二叉排序树的添加、遍历、删除（看图写删除代码比较清晰）
大哥的叔的博客
08-17 1万+
package com.binarysortree; /** * @Auther: 大哥的叔 * @Date: 2019/8/17 06:15 * @Description: */ public class BinarySortTreeDemo { public static void main(String[] args) { int[] arr...
二叉排序树详解
热门推荐
William
03-26 3万+
前言博客编写人：Willam 博客编写时间：2017/3/25 博主邮箱：2930526477@qq.com（有志同道合之人，可以加qq交流交流编程心得）1、二叉排序树的介绍二叉排序树又称二叉查找树。二叉排序树有如下性质： 如果它的左子树不为空，那么左子树上的所有结点的值均小于它的根结点的值 如果它的右子树不为空，那么右子树上的左右结点的值均大于它的根结点的值 根结点的左子树和右子树又是二叉排序树。
二叉排序树
小秋的博客
03-30 176
二叉排序树 1、二叉排序树的介绍 二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 2、二叉排序树添加节点 思路： 根据插入节点的值来寻找其应该插入的位置 新插入的节点都是叶子节点 3、添加节点代码实现 public void add(Node node){ //节点为空时，结束递归
数据结构平衡二叉排序树
02-13
在本实验中，我们主要探讨的是数据结构中的一个关键概念——平衡二叉排序树（Balanced Binary Sort Tree），也称为AVL树。AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左...
数据结构课设—二叉排序树的判别
02-03
《数据结构》课程设计说明书——二叉排序树的判别 1. 问题描述与分析 二叉排序树（Binary Sort Tree，BST）是一种特殊的二叉树，其中每个节点的值都大于其左子树中的任何节点的值，且小于其右子树中的任何节点的值...
二叉排序树构造与查找实验解析
在厦门大学信息科学与技术学院软件技术基础实验中，二叉排序树的构造与查找是一个重要的教学内容和实践环节，通过该实验，学生可以更深入地理解二叉树的性质以及二叉排序树的应用。 二叉排序树的构造过程是这样的：...
完全二叉树、平衡二叉树、二叉查找树（二叉排序树）
bob的博客
08-03 3034
完全二叉树 完全二叉树是一种特殊的二叉树，满足以下要求： 所有叶子节点都出现在 k 或者 k-1 层，而且从 1 到 k-1 层必须达到最大节点数； 第 k 层可以不是满的，但是第 k 层的所有节点必须集中在最左边。需要注意的是不要把完全二叉树和“满二叉树”搞混了，完全二叉树不要求所有树都有左右子树，但它要求： 任何一个节点不能只有左子树没有右子树 叶子节点出现在最后一层或者倒数第二层，不能再往上 用一张图对比下“完全二叉树”和“满二叉树”： 当我们用数组实现一个完全二叉树时，叶子节点可以按从上
【数据结构基础整理】树--08：二叉排序树
ATFWUS的博客
02-20 665
二叉排序树的多种操作 0x01.二叉排序树概念 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。它可以是一棵空树。 二叉排序树必须满足以下条件： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结构的值。 若它的右子树不为空，则右子树上所有结点的值均大于它的根结构的值。 它的左右子树也分别为二叉排序树。 0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值