为了立项——二叉树

最新推荐文章于 2024-10-04 18:59:43 发布
最新推荐文章于 2024-10-04 18:59:43 发布
阅读量1.2k 收藏 44
点赞数 20
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73499016/article/details/127949594
版权

一、知识点

1.树形结构  :  结构定义+结构操作

根节点是全集（必须先从根开始解决）        节点是集合（事件）        边是关系（指向关系）

       （链表是树的特例，指针域的元素个数）

树的（深度：从上向下）        （高度：从下向上）

节点的深度和高度          节点的度（带了几个子孩子）         节点数量=变数+1

节点的度：一个节点含有的子树的个数，叫做该节点的度


叶节点和终端节点：度为零的节点


双亲结点或父节点：C为G的父节点


孩子节点或子节点：G为C的子节点


兄弟节点：拥有相同父节点的节点称为兄弟节点


树的度：一棵树中最大的节点的度称为树的度


节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推


树的高度或深度：树中节点的最大层次


祖先：从根到该节点所经分支上的所有节点（根是所有节点的祖先）


森林：由m（m>0）棵互不相交的树的集合称为森林

2.二叉树：

节点的最多为二        

a.度为0的节点比度为二的节点多一个       

一个度为二的结点等价于一次合并

度为0的节点视为独立的集合，n个集合的合并需要n-1次操作        

故 n1=n2 - 1

任何其他树都可以转化为二叉树

b.左孩子右兄弟表示法

左边放子节点，右边放兄弟节点

2e34bb9e98a0140b2ec590933fca4656.gif

n叉树===二叉树（未确定性问题转化为确定性问题，无需管n）

c.遍历方式

前序遍历 ：根->左->右

中序遍历 ：左->根->右

后序遍历 ：左->右->根 

d.完全二叉树（comple binary tree）

只有右节点的右节点的。。。是缺的

1.一层一层编号（左孩子为偶数 2*i ，右孩子为奇数 2*i+1 ）

2.连续编号===》可以用连续空间存储（ 数 组 ）

3.完全二叉树不是基于记录的（记录所有的数据）

           而是基于计算的（记住一个运算规则即可）

***算法/思维优化手段：记录方式转计算方式！!

e.满二叉树（full binary tree）

没有度为1的节点，要么就是度为0要么就是度为2的节点

f.完美二叉树（perfect binary tree）

Tips

二叉树的广义表：【“（）”和递归以及树形结构的关系，真实包含关系】

（）：空树

A/A（）： A 

A（B，）/A(B)：（逗号前左子树，逗号后右子树）

A(B,C)：

A(B(,D),C(E))

g.排序二叉树

如果它的左子树不为空，那么左子树上所有节点的值均小于它的根节点的值

如果它的右子树不为空，那么右子树上所有节点的值均大于它的根节点的值

根节点的左子树和右子树均是二叉排序树

（可能退化为链表，所以有平衡二叉树的概念；二叉排序树的中序遍历是从小到大有序的）

二、结构操作：

1.创建新的树

2.创建新的节点

3.插入节点（按照二叉排序树）

4.清空节点

5.清空树

6.前序遍历

7.中序遍历

8.后序遍历

9.输出节点

10.输出树

11.寻找节点（按照二叉排序树）

  • 若等于根节点则成功返回
  • 如果小于根节点，则查找其左子树
  • 否则的话查找其右子树

12.删除节点

删除却可以分为三种不同的情况；
（1）删除的节点刚好是叶子结点（没有子结点）——直接删除

把删除节点置为NULL即可(删除节点的父节点指向NULL)

特例：如果删除节点是root节点，则root置为NULL即可

在这里插入图片描述  

(2)删除的节点只有左孩子或者只有右孩子，把删除节点的父节点指向删除节点的子结点即可

特例：如果删除节点是root节点，即可认为删除链表的头节点，把第二个节点当作表头即可

M6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx,size_16,color_FFFFFF,t_70)

Tips:如果24只有右孩子：不用担心24的右孩子会不会比24的父母还大

因为如果24右孩子比24父母（45）还大，那么在建树的时候就会放到45的右孩子上

所以，根的左子树上的所有节点都要比它小

（3）删除的节点既有左孩子又有右孩子，两种删除方法

如果删除的节点有两个子结点，为保证二叉排序树的有序性

需要找到与删除节点键值最接近的两个节点

由排序二叉树的特性知，这两个节点位于删除节点左子树的最右节点，右子树的最左节点

然后将删除节点的父节点指向其中任意一个（例如左子树最右节点，简称替代节点）

让替代节点的右指针指向删除节点的右子树

当替代节点的父节点不是删除节点时，替代节点的左指针指向删除节点的左子树，替代节点的父节点指向替代节点的左子树（替代节点处于最右时没有左子树） 

特例1：删除的节点为root

特例2：替代节点的父节点是删除节点

①左子树“上位”，右子树合并到左子树，因为右子树上节点肯定都比左子树上的大，所以把右子树的根接到左子树的最右下角。

在这里插入图片描述

②左子树最右下角作为最接近被删节点的节点之一，可以直接替代子树的父母

在这里插入图片描述

以上的两种方法都可以作镜像变换，比如左子树最大对应右子树最小
 

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


typedef struct Node
{
    int val;
    struct Node *lchild,*rchild;
} Node; //树的节点

typedef struct Tree
{
    int n;//节点个数
    Node * root;
} Tree;


Node *getNewNode(int val);
Tree *getNewTree(void);

void clearNode(Node *node);
void clearTree(Tree*tree);

void outputNode(Node *root);
void outputTree(Tree *tree);

Node *insertNode(Node *root,int val,int* ret);
int  insert(Tree *tree,int val);

void preorder(Tree *tree);
void preorderNode(Node *root);

void inorderNode(Node *root);
void inorder(Tree *tree);

void postorderNode(Node *root);
void postorder(Tree *tree);



Node *getNewNode(int val)
{
    Node *p=(Node*)malloc(sizeof(Node));
    p->val = val;
    p->lchild = p->rchild = NULL;
    return p;
}

Tree *getNewTree(void)
{
    Tree *tree = (Tree*)malloc(sizeof(Tree));
    tree->n = 0;
    tree->root = NULL;
    return tree;
}


void clearNode(Node *node)
{
    if(node == NULL) return ;
    clearNode(node->lchild);
    clearNode(node->rchild);
    free(node);
    return ;
}//用递归去遍历并清除树

void clearTree(Tree*tree)
{
    clearNode(tree->root);
    free(tree);
    return ;
}//


void outputNode(Node *root)
{
    if(root == NULL) return ;
    printf("%d",root->val);
    if(root->lchild == NULL && root->rchild == NULL) return ;
    printf("(");
    outputNode(root->lchild);
    printf(",");
    outputNode(root->rchild);
    printf(")");
    return ;
}

void outputTree(Tree *tree)
{
    printf("tree(%d)=",tree->n);
    outputNode(tree->root);
    return ;

}//转换为广义表


Node *insertNode(Node *root,int val,int* ret)
//二叉排序树，左子树小于根节点小于右节点，中序遍历！！！
{
    if(root == NULL)
    {
        *ret = 1;
        return getNewNode(val);//关键点！！！
    }
    if(root->val == val) return root;//什么都不干
    if(root->val > val) root->lchild = insertNode(root->lchild,val,ret);//比当前根节点小插入左侧
    else root->rchild = insertNode(root->rchild,val,ret);
    return root;
}//用递归方法插入

int insert(Tree *tree,int val)
{
    int flag = 0;
    tree->root = insertNode(tree->root,val,&flag);
    tree->n += flag;//flag为1插入成功，flag为0插入失败
    return 1;
}


void preorderNode(Node *root)
{
    if(root == NULL) return ;
    printf("%d->",root->val);
    preorderNode(root->lchild);
    preorderNode(root->rchild);
    return ;
}

void preorder(Tree *tree)
{
    printf("preorder:");
    preorderNode(tree->root);
    printf("NULL");
    printf("\n");
}


void inorderNode(Node *root)
{
    if(root==NULL) return ;
    inorderNode(root->lchild);
    printf("%d->",root->val);
    inorderNode(root->rchild);
}

void inorder(Tree *tree)
{
    printf("inorder:");
    inorderNode(tree->root);
    printf("NULL");
    printf("\n");
    return ;
}


void postorderNode(Node *root)
{
    if(root==NULL) return ;
    postorderNode(root->lchild);
    postorderNode(root->rchild);
    printf("%d->",root->val);
}

void postorder(Tree *tree)
{
    printf("postorder:");
    postorderNode(tree->root);
    printf("NULL");
    printf("\n");
    return ;
}



int main(void)
{
    srand(time(NULL));
    Tree* tree = getNewTree();
    for(int i=0; i<20; i++)
    {
        int val=rand()%100+1;
        insert(tree,val);
        outputTree(tree);
        printf("\n");
    }
    printf("\n");
    preorder(tree);
    inorder(tree);
    postorder(tree);
    return 0;
}

头晕版本：

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


typedef struct Node
{
    int val;
    struct Node *lchild,*rchild;
} Node; //树的节点

typedef struct Tree
{
    int n;//节点个数
    Node * root;
} Tree;


Node *getNewNode(int val);
Tree *getNewTree(void);

void clearNode(Node *node);
void clearTree(Tree*tree);

void outputNode(Node *root);
void outputTree(Tree *tree);

Node *insertNode(Node *root,int val,int* ret);
int  insert(Tree *tree,int val);

void preorder(Tree *tree);
void preorderNode(Node *root);

void inorderNode(Node *root);
void inorder(Tree *tree);

void postorderNode(Node *root);
void postorder(Tree *tree);

Node *searchNode1(Tree* tree,int val);
Node *searchNode_Tree(Node* p,int val);
Node *searchTree(Tree* tree,int val);

Node *maxNode(Tree *tree);
Node *minNode(Tree *tree);

Node *parentNode(Node *Node, Tree *tree);





Node *getNewNode(int val)
{
    Node *p=(Node*)malloc(sizeof(Node));
    p->val = val;
    p->lchild = p->rchild = NULL;
    return p;
}

Tree *getNewTree(void)
{
    Tree *tree = (Tree*)malloc(sizeof(Tree));
    tree->n = 0;
    tree->root = NULL;
    return tree;
}


void clearNode(Node *node)
{
    if(node == NULL) return ;
    clearNode(node->lchild);
    clearNode(node->rchild);
    free(node);
    return ;
}//用递归去遍历并清除树

void clearTree(Tree*tree)
{
    clearNode(tree->root);
    free(tree);
    return ;
}//


void outputNode(Node *root)
{
    if(root == NULL) return ;
    printf("%d",root->val);
    if(root->lchild == NULL && root->rchild == NULL) return ;
    printf("(");
    outputNode(root->lchild);
    printf(",");
    outputNode(root->rchild);
    printf(")");
    return ;
}

void outputTree(Tree *tree)
{
    printf("tree(%d)=",tree->n);
    outputNode(tree->root);
    return ;

}//转换为广义表


Node *insertNode(Node *root,int val,int* ret)
//二叉排序树，左子树小于根节点小于右节点，中序遍历！！！
{
    if(root == NULL)
    {
        *ret = 1;
        return getNewNode(val);//关键点！！！
    }
    if(root->val == val) return root;//什么都不干
    if(root->val > val) root->lchild = insertNode(root->lchild,val,ret);//比当前根节点小插入左侧
    else root->rchild = insertNode(root->rchild,val,ret);
    return root;
}//用递归方法插入

int insert(Tree *tree,int val)
{
    int flag = 0;
    tree->root = insertNode(tree->root,val,&flag);
    tree->n += flag;//flag为1插入成功，flag为0插入失败
    return 1;
}


void preorderNode(Node *root)
{
    if(root == NULL) return ;
    printf("%d->",root->val);
    preorderNode(root->lchild);
    preorderNode(root->rchild);
    return ;
}

void preorder(Tree *tree)
{
    printf("preorder:");
    preorderNode(tree->root);
    printf("NULL");
    printf("\n");
}


void inorderNode(Node *root)
{
    if(root==NULL) return ;
    inorderNode(root->lchild);
    printf("%d->",root->val);
    inorderNode(root->rchild);
}

void inorder(Tree *tree)
{
    printf("inorder:");
    inorderNode(tree->root);
    printf("NULL");
    printf("\n");
    return ;
}


void postorderNode(Node *root)
{
    if(root==NULL) return ;
    postorderNode(root->lchild);
    postorderNode(root->rchild);
    printf("%d->",root->val);
}

void postorder(Tree *tree)
{
    printf("postorder:");
    postorderNode(tree->root);
    printf("NULL");
    printf("\n");
    return ;
}


Node *searchNode1(Tree* tree,int val)
{
    if(tree->root == NULL)
    {
        printf("The tree is empty!\n");
        return NULL;
    }
    Node* p = tree->root;
    while (p != NULL)
    {
        //找到了
        if(val == p->val)   return p;
        else if(val < p->val)   p = p->lchild;//在根的左子树
        else   p = p->rchild;   //在根的右子树
    }
    printf("Not Found!\n");
    return NULL;
}                           //  此处运用迭代进行遍历也可以用递归


Node *searchNode_Tree(Node* p,int val)
{
    if(p == NULL)           printf("Not Found!\n");
    else if(val < p->val)  return searchNode_Tree(p->lchild,val);   //在根的左子树
    else if(val > p->val)  return searchNode_Tree(p->rchild,val);   //在根的右子树
    else  return p;
    return NULL;
}

Node *searchTree(Tree* tree,int val)
{
    Node* p = tree->root;
    if(p == NULL)
    {
        printf("The tree is empty!\n");
        return NULL;
    }
    return searchNode_Tree(p,val);
}


Node *maxNode(Tree *tree)
{
    if(tree->root == NULL)  return NULL;
    Node *p = tree->root;
    while(p->rchild) p = p->rchild;  //跳出循环后，p指向最后一个右子节点
    return p;
}

Node *minNode(Tree *tree)
{
    if(tree->root == NULL)  return NULL;
    Node *p = tree->root;
    while(p->lchild) p = p->lchild;  //跳出循环后，p指向最后一个右子节点
    return p;
}


Node *parentNode(Node *Node, Tree *tree) //获取Node节点的父节点
{
    Node *p = tree->root;
    Node *parent = p;
    if (Node == NULL || tree->root == NULL || tree->root == Node) return NULL;

    while (p != NULL && p->val != Node->val)
    {
        parent = p;
        if (Node->val > p->val) p = p->rchild;   //每一次循环后parent总是p的父节点
        else   p = p->lchild;
    }
    if (p == NULL)
    {
        printf("节点Node不存在\n");
        return NULL;
    }
    return parent;
}


int main(void)
{
    srand(time(NULL));
    Tree* tree = getNewTree();
    for(int i=0; i<20; i++)
    {
        int val=rand()%100+1;
        insert(tree,val);
        outputTree(tree);
        printf("\n");
    }
    printf("\n");
    preorder(tree);
    inorder(tree);
    postorder(tree);
    int val;
    while(1)
    {
        scanf("%d",&val);
        printf("%p\n",searchNode1(tree,val));
        printf("%p\n",searchTree(tree,val));
    }
    return 0;
}

@GSH1111
关注
秋招笔试准备——客观题
陈小q的博客
08-29 784
软件测试 按照瀑布模型的阶段划分，软件测试可以分为单元测试，集成测试，系统测试。 系统测试是对整个系统的测试，包括相关的软硬件平台、网络以及相关外设的测试。包括安全性测试、可靠性测试（容错性和易恢复性）、界面测试、文档测试、性能测试（负载、压力、强度）、容量测试、稳定性测试、兼容性测试（硬件：整机和外设，软件（操作系统、应用软件、浏览器、数据库），软硬件，数据，网络）、安装测试、替换性测试http...
软件项目管理复习题库（学生自制非官方）
qq_43104872的博客
12-29 1万+
软件项目管理复习题库（三选一） 每章课后选择题和填空题要做，考试的单选大部分都是里面的原题！ 课后选择填空题 第一章 第二章 一、填空题 1、项目立项之后，项目负责人会进行（自造-购买）决策，确定待开发产品的哪些部分应该采购、外包开发、自主研发等。 2、PMI人才三角重点关注（技术项目管理）、（领导力）、（战略和商务管理）3个关键技能。 3、在（立项）阶段，应该明确项目的目标、时间表、使用的资源和经费，而且得到项目发起人的认可。 三、选择题 1、下列不是项目立项过程内容的是（B） A.项目的目标
毕业后就是程序员——我的阿里、金山、中华、腾讯、360、网易面试总结
强叔
11-17 1287
再开始我的博客之旅。东奔西跑的忙了一个多月，找工作的事算是告一段落；这段时间有兴奋，有失落，有迷惘，也有开心，是一个让自己得到锻炼，得到提升的好机会，是一段难忘的时光，记录下留作纪念，也希望能给同样要走这一段路的人一点提醒，免得像我一样，当碰得头破血流之时才不得不去承认。先写总的感受，后面针对具体的笔试面试续写。 （1）凡事预则立，不预则废     事前有准备有计划毋庸置疑，但是也应该相信从前
【Leetcode】刷题题单记录
zcw1234515的博客
12-26 2205
Leetcode 算法题刷刷刷！！！
天地一体化信息网络发展与拟态技术应用构想
Anne033的博客
01-07 2856
天地一体化信息网络发展与拟态技术应用构想 2019-07-20 08:00 作者: 梁浩, 陈福才, 季新生, 吕平, 高彦钊 国家数字交换系统工程技术研究中心 摘要: 天地一体化信息网络是国家面向2030的重大科技工程, 现有的基础架构及由此构建的技术体系在其节点高性能处理、网络高效互联、一体化安全防护等方面面临诸多挑战. 该文从拟态技术应用的角度出发, 在分析天地一体化信息网络面临的技术挑战和现有技术思路的基础上, 提出将拟态计算、拟态防御和软件定义互连技术应用到天地网络架构、关键信息系统中的设计思路与
软件项目管理1~11章期末复习题
计忆芳华的博客
11-15 2万+
题型为填空（10分，每空一分），判断（10分，每题一分），选择（20分，每题2分），问答题（60分） 范围：1~11章，第三章不考。涉及到敏捷项目的不考。 问答题：5，6，7，9章等等。 第一章软件项目管理概述 一、填空题 1、敏捷模型包括 4个核心价值，对应 12个敏捷原则。 2、项目管理包括（启动过程组）、（计划过程组）、（执行过程组）、（控制过程组）、（收尾过程组）5个过程组。 二、判断题 1、搬家属于项目。（对） 2、项目是为了创造一个唯一的产品或提供一个唯一的服务而进行的永久性的努力。（错.
2018年春季学期《软件工程》班级讨论群中开放性问题群聊记录
weixin_30258901的博客
08-19 1357
2018年春季学期《软件工程》班级讨论群中开放性问题群聊记录 火车票抢票软件与软件工程师职业道德的讨论 —————2018-03-30————— 周筠 07:44 东北师大的胡益峰同学在阅读作业里提出疑问：我想到了市场上的各种火车票抢票软件，这些软件照顾了使用该软件用户的利益，但损害了其他老老实实抢票人的利益。公众的利益很难兼顾，所以这种行为是不是有违软件...
软件项目管理案例复习题
iamliujk的博客
03-27 3万+
敏捷模型包括（4）个核心价值，对应（12）个敏捷原则。 项目管理包括（启动过程组）、（计划过程组）、（执行过程组）、（控制过程组）、（收尾过程 5个过程组。 、搬家属于项目。（√） 、项目是为了创造一个唯一的产品或提供一个唯一的服务而进行的永久性的努力。（×） 、过程管理就是对过程进行管理，目的是要让过程能够被共享、复用，并得到持续的改进。 √） 、项目具有临时性的特征。（√）...
20172327 2018-2019-1《程序设计与数据结构》课程总结
weixin_30526593的博客
12-25 184
20172327 2018-2019-1《程序设计与数据结构》课程总结 每周作业链接汇总 第一周作业：课本的第一章和第二章，分别讲了什么是软件，软件质量特征，数据结构，时间复杂度等。 第二周作业：对课本第三章和第四章的学习，学习了栈，集合结构的栈和链式结构的栈。 第三周作业：对课本第五章的学习，学习了队列，Java API中的队列，链表实现队列，数组实现队列等。 第四周作业：对课本第六章学习，学习...
基于C++、文件操作和Huffman算法实现图片压缩源码+使用说明+详细注释+sln解决方案.zip
10-27
——使用C++、文件操作和Huffman算法实现“图片压缩程序”。 ## 1. 核心知识 （1） 树的存储结构 （2） 二叉树的三种遍历方法 （3） Huffman树、Huffman编码算法 ## 2. 功能要求 1. 针对一幅BMP格式的图片文件，...
Java基础：UML类图
foureyes
04-15 5213
文章目录1. 可见性符号2. 类之间的关系2.1 泛化（Generalization）2.2 实现（Realization）2.3 关联（Association）2.5 聚合（Aggregation）2.6 组合（Composition） 本文介绍Java开发中的软技能之一，UML图。UML 即统一建模语言，它是一种开放的方法，用于说明、可视化、构建和编写一个正在开发的、面向对象的、软件密集系统的...
项目管理复习题
热门推荐
weixin_42139734的博客
09-18 13万+
蓝字位注释，红字为错误原因，紫字为重点 本复习题链接：https://pan.baidu.com/s/1ZJ4l6mKxAt9dqhw0Qa58xA 提取码：j4jz 第一章 一、填空题 1.敏捷模型包括（4）个核心价值，对应（12）个敏捷原则。 2.项目管理包括（启动过程组）、（计划过程组）、（执行过程组）、（控制过程组）、（收尾过程组）5个过程组。 二、判断题 1、搬家属于项目。（√） 2、项目是为了创造一个唯一的产品或提供一个唯一的服务而进行的永久性的努力。（×） 3、过程管理就是.
【算法竞赛】堆
Sakura_ding的博客
10-01 995
堆是一种树形结构,树的根是堆顶,堆顶始终保持为所有元素的最优值。有最大堆和最小堆,最大堆的根节点是最大值,最小堆的根节点是最小值。本节都以最小堆为例进行讲解。堆一般用二叉树实现,称为二叉堆。二叉堆的典型应用有堆排序和优先队列。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 358
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 266
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 686
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1089
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 534
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值