排序二叉树--二叉树线索化

已于 2024-03-22 18:00:23 修改
阅读量399 收藏 7
点赞数 3
文章标签： 数据结构 算法
于 2024-03-08 21:38:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31041167/article/details/136568425
版权

参考

Binary Search Tree Visualization (usfca.edu)

一、构建排序二叉树

注意引用 tree

/**
 * 构造二叉排序树
 * @param tree
 * @param x
 */
void buildTree(BSTree &tree,ElementType &x){
    if (tree==NULL){
        tree=(BSTree) calloc(1, sizeof(BSTNode));
        tree->data=x;
        //注意
        return;
    }
    if (x>tree->data){
        buildTree(tree->rchild,x);
    }
    if (x<tree->data){
        buildTree(tree->lchild,x);
    }
    if (x==tree->data){
        return;
    }
}

二、查询排序二叉树的目标节点

注意引用 tree

//查找
int getPosition(BSTree &tree,int postion,ElementType x){
    if (tree!=NULL&&x==tree->data){
        return tree->data;
    }
    if (x>tree->data){
        return getPosition(tree->rchild,0,x);
    } else{
        return getPosition(tree->lchild,0,x);
    }
}

三、删除二叉排序树的节点

注意引用

注意左子树右子树都不为空的情况  删除的时候递归删除 因为我们不知道它的父亲节点

注意记得删除前改变被删除的位置的地址

//删除节点
void delTNode(BSTree &tree,ElementType x){
    if (tree==NULL){
        return;
    }
    BSTNode *temp=tree;
    if (x>temp->data){
        delTNode(tree->rchild,x);
    }
    if (x<temp->data){
        delTNode(tree->lchild,x);
    }
    if (x==temp->data){
        if (temp->lchild==NULL&&temp->rchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->rchild;
            free(temp);
        }
        if (temp->rchild==NULL&&temp->lchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->lchild;
            free(temp);
        }
        if (temp->lchild==NULL&&temp->rchild==NULL){
            //注意记得改变此时被删除的位置的地址
            tree=NULL;
            free(temp);
        }
        if (temp->lchild!=NULL&&temp->rchild!=NULL){
            //左右子树都不为空
            //找左子树的左右边
            //或者找右子树的最左边来代替
            temp=temp->lchild;
            while (temp->rchild!=NULL){
                temp=temp->rchild;
            }
            tree->data=temp->data;
            //因为这时候有俩个一样的值了 我们要确认我们要删除的是哪个值
            //因此这里应该删除这个节点的左子树上那个替死鬼
            delTNode(tree->lchild,temp->data);
        }
    }
}

 四、完整代码

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct BSTNode{
    ElementType data;
    BSTNode *rchild;
    BSTNode *lchild;
}BSTNode,*BSTree;

/**
 * 构造二叉排序树
 * @param tree
 * @param x
 */
void buildTree(BSTree &tree,ElementType &x){
    if (tree==NULL){
        tree=(BSTree) calloc(1, sizeof(BSTNode));
        tree->data=x;
        //注意
        return;
    }
    if (x>tree->data){
        buildTree(tree->rchild,x);
    }
    if (x<tree->data){
        buildTree(tree->lchild,x);
    }
    if (x==tree->data){
        return;
    }
}

//查找
int getPosition(BSTree &tree,int postion,ElementType x){
    if (tree!=NULL&&x==tree->data){
        return tree->data;
    }
    if (x>tree->data){
        return getPosition(tree->rchild,0,x);
    } else{
        return getPosition(tree->lchild,0,x);
    }
}

//删除节点
void delTNode(BSTree &tree,ElementType x){
    if (tree==NULL){
        return;
    }
    BSTNode *temp=tree;
    if (x>temp->data){
        delTNode(tree->rchild,x);
    }
    if (x<temp->data){
        delTNode(tree->lchild,x);
    }
    if (x==temp->data){
        if (temp->lchild==NULL&&temp->rchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->rchild;
            free(temp);
        }
        if (temp->rchild==NULL&&temp->lchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->lchild;
            free(temp);
        }
        if (temp->lchild==NULL&&temp->rchild==NULL){
            //注意记得改变此时被删除的位置的地址
            tree=NULL;
            free(temp);
        }
        if (temp->lchild!=NULL&&temp->rchild!=NULL){
            //左右子树都不为空
            //找左子树的左右边
            //或者找右子树的最左边来代替
            temp=temp->lchild;
            while (temp->rchild!=NULL){
                temp=temp->rchild;
            }
            tree->data=temp->data;
            //因为这时候有俩个一样的值了 我们要确认我们要删除的是哪个值
            //因此这里应该删除这个节点的左子树上那个替死鬼
            delTNode(tree->lchild,temp->data);
        }
    }
}

//中序遍历 对于二叉排序树来说中序遍历就是从小到大依次排序
void inOrder(BSTree tree){
    if (tree==NULL){
        return;
    }
    inOrder(tree->lchild);
    printf("%3d",tree->data);
    inOrder(tree->rchild);
}

int main() {
    BSTree tree;
    ElementType str[7]={56,20,30,1,3,78,9};
    //注意
    tree=(BSTree) calloc(1, sizeof(BSTNode));
    tree->data=56;
    for (int i = 1; i < 7; ++i) {
        buildTree(tree,str[i]);
    }
    ElementType x;
    x=getPosition(tree,0,1);
    printf("%d\n",x);
    delTNode(tree,1);
    inOrder(tree);
    return 0;
}

 五、折半查找OJ练习

读取10个元素 87  7 60 80 59 34 86 99 21  3，然后建立二叉查找树，
中序遍历输出3  7 21 34 59 60 80 86 87 99，
针对有序后的元素，存入一个长度为10的数组中，通过折半查找找到21的下标（下标为2），
然后输出2

//折半查找
int getPosition(ElementType A[],ElementType x,int low,int high){
    if (low>=high){
        return -1;
    }
    int mid=(low+high)/2;
    if (A[mid]==x){
        return mid;
    }
    if (x>A[mid]){
        return getPosition(A,x,mid+1,high);
    } else{
        return getPosition(A,x,low,mid-1);
    }
}

完整代码 

#include <stdio.h>
#include <stdlib.h>

/**
 * 读取10个元素 87  7 60 80 59 34 86 99 21  3，然后建立二叉查找树，
 * 中序遍历输出3  7 21 34 59 60 80 86 87 99，
 * 针对有序后的元素，存入一个长度为10的数组中，通过折半查找找到21的下标（下标为2），然后输出2
 */

typedef int ElementType;

typedef struct BSTNode{
    ElementType data;
    BSTNode *rchild;
    BSTNode *lchild;
}BSTNode,*BSTree;

/**
 * 构造二叉排序树
 * @param tree
 * @param x
 */
void buildTree(BSTree &tree,ElementType &x){
    if (tree==NULL){
        tree=(BSTree) calloc(1, sizeof(BSTNode));
        tree->data=x;
        //注意
        return;
    }
    if (x>tree->data){
        buildTree(tree->rchild,x);
    }
    if (x<tree->data){
        buildTree(tree->lchild,x);
    }
    if (x==tree->data){
        return;
    }
}

//查找
int getPosition(BSTree &tree,int postion,ElementType x){
    if (tree!=NULL&&x==tree->data){
        return tree->data;
    }
    if (x>tree->data){
        return getPosition(tree->rchild,0,x);
    } else{
        return getPosition(tree->lchild,0,x);
    }
}

//删除节点
void delTNode(BSTree &tree,ElementType x){
    if (tree==NULL){
        return;
    }
    BSTNode *temp=tree;
    if (x>temp->data){
        delTNode(tree->rchild,x);
    }
    if (x<temp->data){
        delTNode(tree->lchild,x);
    }
    if (x==temp->data){
        if (temp->lchild==NULL&&temp->rchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->rchild;
            free(temp);
        }
        if (temp->rchild==NULL&&temp->lchild!=NULL){
            //注意记得改变此时被删除的位置的地址
            tree=temp->lchild;
            free(temp);
        }
        if (temp->lchild==NULL&&temp->rchild==NULL){
            //注意记得改变此时被删除的位置的地址
            tree=NULL;
            free(temp);
        }
        if (temp->lchild!=NULL&&temp->rchild!=NULL){
            //左右子树都不为空
            //找左子树的左右边
            //或者找右子树的最左边来代替
            temp=temp->lchild;
            while (temp->rchild!=NULL){
                temp=temp->rchild;
            }
            tree->data=temp->data;
            //因为这时候有俩个一样的值了 我们要确认我们要删除的是哪个值
            //因此这里应该删除这个节点的左子树上那个替死鬼
            delTNode(tree->lchild,temp->data);
        }
    }
}

//中序遍历 对于二叉排序树来说中序遍历就是从小到大依次排序
void inOrder(BSTree tree){
    if (tree==NULL){
        return;
    }
    inOrder(tree->lchild);
    printf("%3d",tree->data);
    inOrder(tree->rchild);
}

int i=0;

//中序遍历 对于二叉排序树来说中序遍历就是从小到大依次排序
void inOrderI(BSTree tree,ElementType A[]){
    if (tree==NULL){
        return;
    }
    inOrderI(tree->lchild,A);
    A[i++]=tree->data;
    printf("%3d",tree->data);
    inOrderI(tree->rchild,A);
}

//折半查找
int getPosition(ElementType A[],ElementType x,int low,int high){
    if (low>=high){
        return -1;
    }
    int mid=(low+high)/2;
    if (A[mid]==x){
        return mid;
    }
    if (x>A[mid]){
        return getPosition(A,x,mid+1,high);
    } else{
        return getPosition(A,x,low,mid-1);
    }
}

int main() {
    BSTree tree;
    //注意
    tree=(BSTree) calloc(1, sizeof(BSTNode));
    ElementType x;
    scanf("%d",&x);
    tree->data=x;
    for (int i = 1; i <= 9; ++i) {
        scanf("%d",&x);
        buildTree(tree,x);
    }
    ElementType A[10];
    inOrderI(tree,A);
    printf("\n");
    int position=getPosition(A,21,0,9);
    printf("%d\n", position);
    return 0;
}

六、折半查找 （真题）中位数应用

注意最后是s / d  的位置的值

注意移动的时候数组长度是变化的 

1. 判断哪个中位数小  

保证消掉的元素个数是相等的

奇数个长度  消掉小的前面的所有元素  大的后面的所有元素

偶数个长度  消掉小的前面的所有元素及其它本身  大的后面的所有元素

2.退出循环的条件是 s1！=d1|| s2！=d2 --直到俩个数组中就s1d1都指向一个元素  s2d2同理

#include <stdio.h>

void NarrowScope(int n, int m1, int m2, int &s2, int &d1);

//不合并查找中位数--去掉数  --就是移动下标
int getMidA_B(int A[],int B[],int n){
    //分别为 A B的 首尾 中位数  所在下标位置
    int s1,s2,d1,d2,m1,m2;
    s1=s2=0;d1=d2=n-1;
    m1=(s1+d1)/2;
    m2=(s2+d2)/2;
    if (A[m1]==B[m2]){
        return A[m1];
    }
    //去掉小哪个中位数之前的数    注意分奇偶
    //去掉大的那个中位数之后的数  注意分奇偶
    //循环判断哪个中位数大--缩小范围--直到俩个数组中都只剩下一个数s1=d1 s2=d2时 小的那个即为中位数
    while (s1!=d1||s2!=d2){
        m1=(s1+d1)/2;
        m2=(s2+d2)/2;
        if (A[m1]==B[m2]){
            return A[m1];
        }
        if (A[m1]>B[m2]){
            if ((s1+d1)%2==0){
                //奇数个
                //去掉大的之后的所有数
                d1=m1;
                //去掉小的之前的所有数
                s2=m2;
            } else{
                //偶数个
                //去掉大的 之后的所有数
                d1=m1;
                //去掉小的 中位数及之前的所有数
                s2=m2+1;
            }
        }
        if (A[m1]<B[m2]){
            if ((s1+d1)%2==0){
                //奇数个
                //去掉大的之后的所有数
                d2=m2;
                //去掉小的之前的所有数
                s1=m1;
            } else{
                //偶数个
                //去掉大的 之后的所有数
                d2=m2;
                //去掉小的 中位数及之前的所有数
                s1=m1+1;
            }
        }
    }
    //注意这里 要的是s /  d  而不是m  因为最终s 与d会重合
    return A[s1]>B[s2]?B[s2]:A[s1];
}



int main() {
    int A[]={11,13,15,17,19};
    int B[]={2,4,6,8,20};
    int n=5;
    int mid=getMidA_B(A,B,n);
    printf("%d\n",mid);
    return 0;
}

七、二叉树的线索化 

中序线索化 

先序线索化--因为访问D的时候还是回到跟B因此爱的魔力转圈圈 

注意处理它不是前驱线索 

八、二叉树的WPL计算 

答案一 

 

 

答案二 

 

 

 

九、并查集注意路径压缩优化 

 

谢景行^顾
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树----顺序二叉树、线索二叉树
小秋的博客
03-25 359
二叉树----顺序二叉树、线索二叉树 1、顺序二叉树 1.1、 顺序二叉树的特点 特点 顺序二叉树通常只考虑完全二叉树 第 n个元素的左子节点为 2 × n + 1 第 n个元素的右子节点为 2 × n + 2 第 n个元素的父节点为(n-1) ÷2 其中n 表示二叉树中的第几个元素(从0开始编号) 2.2、 顺序二叉树代码实现 注意点：和遍历二叉树类似、不同的地方，是递归的条件变成了2n + 1等，还要注意判断，防止在2n+1的时候，数组越界，所以要加上判断语句 class ArrB
二叉树线索化示意图_树结构入门教程-线索化二叉树
weixin_39781452的博客
12-21 623
上节我们学习了数组和树之间相互转化储存过程,我们可以将树中的节点按照前中后序的遍历结果存储在数组中,同样也可以将我们数组的中元素转化成一棵树,本节我们来看树的另外一个特点--------->线索化,首先我们来了解下线索化二叉树的概念.引出我们先看一个问题,假如我有一组数列{1,3,6,8,10,14},我们准备将它构建成如下图所示的这样一棵二叉树:二叉树.png当我们对上述图中的二叉树进行中...
线索化二叉树及其遍历
qq_44300280的博客
05-07 782
线索化二叉树及其遍历
二叉树线索化示意图_103-线索化二叉树思路图解
weixin_36050894的博客
12-30 173
2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。 本课程针对上述问题，有针对性的进行了升级3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解4)系统多面的讲解了数据结构和算法, 除常用数...
java线索二叉树_103-线索化二叉树思路图解
weixin_39832829的博客
02-20 73
2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。 本课程针对上述问题，有针对性的进行了升级3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解4)系统多面的讲解了数据结构和算法, 除常用数...
线索化二叉树的作用
学Java，找哪吒
08-16 1万+
一、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树。 问题分析： 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}。 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上。 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，要怎么办？ 解决方案 --> 线索化二叉树 二、线索化二叉树 1、n个节点的二叉树链表总含有n+1（公式2n-(n-1)=n+1）个空指针域。...
线索二叉树（详解）
热门推荐
~
01-09 6万+
线索二叉树原理 遍历二叉树的其实就是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。这些线性序列中的每一个元素都有且仅有一个前驱结点和后继结点。 但是当我们希望得到二叉树中某一个结点的前驱或者后继结点时，普通的二叉树是无法直接得到的，只能通过遍历一次二叉树得到。每当涉及到求解前驱或者后继就需要将二叉树遍历一次，非常不方便。 于是是否能够改变原有的...
线索二叉树简述
刘伟佳的博客
03-12 2716
线索二叉树 首先我们回忆一下二叉树的前中后序遍历方式： 先序遍历序列：1 2 4 5 3 6 中序遍历序列：4 2 5 1 6 3 后序遍历序列：4 5 2 6 3 1 我们通过这样的遍历，由一个树形结构得到了一个线性的结构（遍历序列）。在这个线性序列中，除了第一个结点和最后一个结点，每个结点都拥有一个前驱和后继。 那么在二叉树中，我们能不能不只体现结点的父子关系，也引入结点的前驱后继关系呢？ 由此，我们引入了线索二叉树。 我们之前说过二叉链表，我们知道在一个二叉链表中，n个结点会有n+1个空指针。 接
深入学习二叉树-- 二叉树基础
cinling123的专栏
01-09 376
二叉查找树--前序遍历、中序遍历、后序遍历、层次遍历、查找、删除、更新--JAVA实现：https://blog.csdn.net/cinling123/article/details/103911476 前言 树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。在学习与总结的同时更加深入的了解掌握二叉树。本...
【数据结构】：二叉树，线索二叉树，排序二叉树，AVL树
呋喃吖的博客
06-15 1205
文章目录前言一 二叉树0）二叉树较为重要的种类1. 满二叉树2.完全二叉树1） 二叉树的存储结构2） 初始化二叉树3）创建二叉树1.创建二叉树的方式 12.创建二叉树 23.创建二叉树 34）遍历二叉树1.前序递归遍历2.中序递归遍历3.后序递归遍历4.层次遍历5）前序非递归遍历 前言 二叉树分好多种: 我在这里分享四种二叉树的基本操作集合。 普通的二叉树(二叉树) 线索二叉树 搜索二叉树 平衡（AVL）二叉树 一 二叉树 0）二叉树较为重要的种类 满二叉树和完全二叉树。 1. 满二叉树 一棵二叉树，除
数据结构--二叉树--线索化二叉树
04-19
线索化二叉树是一种特殊的二叉树，它通过在二叉链表的空指针位置附加线索，帮助我们在非递归方式下实现二叉树的遍历。中序遍历是二叉树遍历的一种，按照“左子树-根节点-右子树”的顺序访问节点。 中序线索化二叉树...
算法-理论基础- 二叉树- 线索链表（包含源程序）.rar
09-16
二叉树常用于实现搜索、排序和表达式解析等任务。 二叉树有三种基本遍历方式：前序遍历、中序遍历和后序遍历。在前序遍历中，我们首先访问根节点，然后遍历左子树，最后遍历右子树；中序遍历则是先遍历左子树，再...
数据结构之二叉树-思路清晰纯C
09-12
线索二叉树的实现 二叉排序树的实现 平衡二叉树的实现 哈夫曼树的实现 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
二叉树的线索化实现
11-21
线索化的过程是将非空二叉树转换为线索二叉树，以便在不使用栈或队列的情况下，能够前后遍历节点。在二叉树的每个节点中，通常包含两个指针：一个指向其左子节点，另一个指向其右子节点。线索二叉树会在这些指针可能...
中序线索化二叉树.zip
12-04
线索化二叉树的主要优点在于其对中序遍历的优化，尤其在需要反复进行中序遍历的场景下，如查找、排序等操作。然而，线索化增加了额外的存储开销，且插入和删除操作的复杂度稍有增加，因此，在实际应用中，需要根据...
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 246
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
插入和选择排序
c23856的博客
07-20 488
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 344
1%29%5D1。
数据结构（二叉树-1）
最新发布
2401_83968713的博客
07-20 1017
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
树和二叉树详解：线索化与遍历
"这篇教学资料主要讲解了树和二叉树相关的知识，包括它们的定义、基本术语、遍历方法以及特殊类型的树如线索化二叉树和赫夫曼树。教学重点在于理解树的不同类型定义，二叉树的性质，特别是遍历和线索化，以及赫夫曼...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值