数据结构 day07 基础知识学习 （二叉树 的 前中后遍历 ，插入节点，删除叶子节点， 二叉树的节点个数 ）

最新推荐文章于 2024-09-29 18:28:00 发布
最新推荐文章于 2024-09-29 18:28:00 发布
阅读量178 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/she666666/article/details/126023314
版权

一.今天有点迷。

二.希望大家看的懂代码 ，我已经很努力写注释了。

三.这次的知识很基础 ，（老师关于 二叉树节点删除的哪里 讲的有点差 ，主要是讲之前没有打好框架   （关于父节点的定义   ）   这个代码有运用 函数指针 ）

四.老师的代码 （4个文件 ）

1.tree.h

2.tree.c

3.main.c

4.makefile

五，代码：

1.tree.h

#ifndef __TREE_H__
#define __TREE_H__

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

typedef struct tree
{
    void* data;
    struct tree* left_tree;
    struct tree* right_tree;
    struct tree* parent;
}tree,* ptree;

typedef  int (*pcmp)(const void* data1,const void*  data2);
//插入数据

bool tree_insert(tree** t,tree* father, void *data,int size,pcmp cpm_fun);


//中序遍历
void tree_Inorder(tree* p,void (*Print)(const void* data_ptr));
//前序
void tree_preorder(tree* p,void (*Print)(const void* data_ptr));

//后序列
void tree_postorder(tree* p,void (*Print)(const void* data_ptr));


//自己写的　不用递归　
void tree_In(tree * t,void  (*Print)(const void * data_ptr));//中序遍历
void tree_post(tree * t,void  (*Print)(const void * data_ptr));//后序列
void tree_pre(tree * t,void  (*Print)(const void * data_ptr));//前序



//找出数据最大数据的节点
tree* tree_max(tree* t);

//找出二茶树中数据最小的节点
tree* tree_min(tree* t);

//查找data_ptr在二茶树中的位置
tree* tree_find(tree* t,void* data_ptr,pcmp cpm_fun);

//统计节点个数
unsigned int tree_size(tree* t);

//节点删除
bool tree_delete(tree** node,pcmp suju);
#endif

tree.c

/**********************************************

*作者 ：she001
*
*
************************************************/

#include "tree.h"
//插入数据
bool tree_insert(tree** t,tree* father, void *data,int size,pcmp cpm_fun)   //寻找合适的叶子节点 插入
{
    if (t == NULL || data == NULL || size <=0 || cpm_fun == NULL)
    {
        return false;
    }
    if(*t == NULL)
    {
        tree* pnew = (tree*)malloc(sizeof(tree));  //开辟节点  , 
        if(pnew == NULL)
        {
            return false;
        }
        pnew->left_tree  = NULL;       //双向的 
        pnew->right_tree = NULL;        
        pnew->parent     = father;
        pnew->data       = malloc(size);  
        if(pnew->data == NULL)
        {
            return false;
        }
        memcpy(pnew->data,data,size);  //内容复制过去   ，memcpy  直接复制内存 
        *t = pnew;                     //二级指针 改变一级指针的指向
        return true;                   
    }
    else
    {
        int temp = cpm_fun((*t)->data,data );               //接口函数　（比较函数　　－＞　　判定中）
        if(temp > 0)                                        //　判定　　这个节点的数适合在那里  这里是判定这个树，适合在树的左边　
        {
            return tree_insert(&((*t)->left_tree), *t,data,size,cpm_fun);     //递归　直到找到合适的地方　
        }
        else if(temp < 0)                                   //判定　　这个节点的数适合在那里  这里是判定这个树，适合在树的右边
        {
            return tree_insert(&((*t)->right_tree),*t,data,size,cpm_fun);       //递归　直到找到合适的地方　
        }
        else
        {
            return false;                                  //有相同的树　　所以　程序程序错误　，不可以建立新的节点
        }
    }
    
}

//中序遍历
void tree_Inorder(tree* p,void (*Print)(const void* data_ptr))   //加了一个 函数借口  与写一个输出函数差不多   ，主要是老师写的 模板代码  ，但是今天老师的状态不对 思路有点不对  父母节点没写好，有bug 
{
    if(p == NULL)
    {
        return ;
    }
    tree_Inorder(p->left_tree,Print);                  // 递归　遍历二叉树
    Print(p->data);
    tree_Inorder(p->right_tree,Print);                 //递归　遍历二叉树
}
//5 2 8 9 25
/*  伪代码
void tree_Inorder(8)
{
  tree_Inorder(8->left_tree == 2)
  {
        tree_Inorder(2->left_tree)
        p-->２
        tree_Inorder(2->right_tree == 5)
        {
            tree_Inorder(5->left_tree)
             p-->5;
            tree_Inorder(5->right_tree)

        }

  }
  p-->8
  tree_Inorder(8->right_tree == 9)
  {
    tree_Inorder(9->left == NULL)
    p--->9
    tree_Inorder(9-->right === 25)
    {
        tree_Inorder(25->left == NULL)
        P-->25
        tree_Inorder(25->right == NULL)
    }
  }
}

*/
// 前序遍历
void tree_preorder(tree* p,void (*Print)(const void* data_ptr))
{
    if(p == NULL)
    {
        return ;
    }
    Print(p->data);
    tree_preorder(p->left_tree,Print);
    tree_preorder(p->right_tree,Print);
}
//后续遍历
void tree_postorder(tree* p,void (*Print)(const void* data_ptr))
{
    if(p == NULL)
    {
        return ;
    }
    tree_postorder(p->left_tree,Print);
    tree_postorder(p->right_tree,Print);
    Print(p->data);
}
//找出数据最大数据的节点
tree* tree_max(tree* t)
{
    if(t == NULL)
    {
        return NULL;
    }
    if(t->right_tree != NULL)           //从根节点　一直往右边查找　
    {
        return tree_max(t->right_tree);
    }
    return t;
// 2 5 8 9 25
}  
/**
 *  tree* tree_max(8)
 * {
 *      tree_max(8->right === 9)
 *      {
 *        tree_max(9-->right == 25)
 *        {
 *            if(25-->right )
 *         }
 *          return 25;     
 *      }
 * return 9
 * }
*/

//找出二茶树中数据最小的节点
tree* tree_min(tree* t)
{
    if(t == NULL)
    {
        return NULL;
    }
    if(t->left_tree != NULL)
    {
        return tree_min(t->left_tree);            //从根开始　一直往左边查找
    }
    return t;
}

//查找data_ptr在二茶树中的位置
tree* tree_find(tree* t,void* data_ptr,pcmp cpm_fun)
{
    if(t == NULL || data_ptr == NULL|| cpm_fun == NULL)
    {
        return NULL;
    }
    int temp = cpm_fun(t->data  ,data_ptr);                  //接口函数判断　这个数该往什么地方（左　或　右）　去找对比的数据
    if(temp < 0)
    {
        return tree_find(t->right_tree,data_ptr,cpm_fun);     //往左遍历
    }
    else if(temp > 0)
    {
        return tree_find(t->left_tree,data_ptr,cpm_fun);      //往右遍历
    }else
    {
        return t;
    }
}

//统计节点个数  2 5 8 9 25
unsigned int tree_size(tree* t)            
{
    if (t == NULL)
    {
        return 0;
    }
    return tree_size(t->left_tree)+tree_size(t->right_tree)+1;     //递归的调用　　　　是一个节点　它就会加一　空节点不会　
}
/*

tree_size(8)
{
    tree( 2 ) + tree(9) + 1
    tree(2)
    {
        return  tree(0) + tree(5) +1;
    }
    tree(9)
    {
        return  tree(0) + tree(25) +1;
    }
}
*/

//删除node节点
bool tree_delete(tree** node,pcmp suju) //  只修改叶子节点　（老师的思路不太清晰）
{
    if(*node == NULL)
    {
        return false;
    }
    //左子树　和右子树　都为ＮＵＬＬ　　说明是叶子节点  只修改叶子节点
    if((*node)->left_tree == NULL && (*node)->right_tree == NULL)
    {
        int mm = suju((*node)->data,(*node)->parent->data);
        if(mm)   //写的程序　把void * 类型的　确定下来了　
        {
            (*node)->parent->right_tree = NULL;                          //把这个节点的父母节点的右节点指向空　　
        }
        else
        {
            (*node)->parent->left_tree = NULL;                          //把这个节点的父母节点的左节点指向空　　
        }
        free((*node)->data);   //释放节点数据
        free((*node));          //释放 　节点　
        (*node)->parent = NULL;  //防止野指针
        return true;
    }
    return false;
}



void tree_In(tree * t,void  (*Print)(const void * data_ptr))//中序遍历
{
    if(t ==NULL)
    {
        printf("空间开辟失败！\n");
        return; 
    }
    //准备一个栈
    ptree stack[100];
    int stack_num=-1 ;
    ptree temp = t;
    while(stack_num!=-1 || temp!=NULL )
    {
        while(temp!=NULL)
        {
             
            stack[++stack_num]=temp;
            temp=temp->left_tree;
        }
        if(stack_num!=-1) //注意打印过的数据，其指针不再进栈　数据思路还行
        {
            temp=stack[stack_num--];
            Print(temp->data);              //先打左节点 再打本身 
            temp=temp->right_tree;
        }
    }
}

void tree_post(tree * t,void  (*Print)(const void * data_ptr))//后序列
{
    if(t ==NULL)
    {
        printf("空间开辟失败！\n");
        return; 
    }
    //准备一个栈
    ptree stack[100];
    int stack_num=-1 ;
    ptree temp = t;
    ptree plastVisit=NULL; //访问标记
    while(temp!=NULL )
    {   
        stack[++stack_num] =temp;
        temp=temp->left_tree;  //先移到　最左边
    }
    while(stack_num!=-1)
    {
        temp=stack[stack_num--];
        if(temp->right_tree==NULL || temp->right_tree==plastVisit)
        {
            Print(temp->data);    //到了节点打印数据　或者右边的树已经打过
            plastVisit=temp;   //标记这个最右的节点已经走过
        }
        else
        {
            stack[++stack_num]=temp;   
            temp=temp->right_tree;
            while(temp!=NULL)
            {
                stack[++stack_num]=temp;
                temp=temp->left_tree;
            }

        }
    }

}
void tree_pre(tree * t,void  (*Print)(const void * data_ptr))//前序
{
     if(t ==NULL)
    {
        printf("空间开辟失败！\n");
        return; 
    }
    //准备一个栈
    ptree stack[100];
    int stack_num=-1 ;
    ptree temp = t;
    while(stack_num!=-1 || temp!=NULL)  //开始因为　节点不是空的所以可以进去
    {
        while(temp!=NULL)
        {
            Print((temp->data));
            stack[++stack_num] = temp;  //走过的路需要记载　进栈
            temp=temp->left_tree;
        }
        if(stack_num!=-1)
        {
            temp=stack[stack_num];       
            stack_num--;
            temp=temp->right_tree;   //看看这个节点的右节点
        }
    }


}

main.c

#include "tree.h"
#include <time.h>

int int_cmp_fun(const void* data1,const void*  data2)  //数据插入树中　的函数
{
    if(data1 ==NULL || data2 == NULL)
    {
        return 0;
    }
    return (*(int*)data1) - (*(int*)data2);
}

void Print(const void* data_ptr)              // 打印函数
{
    if(data_ptr == NULL)
    {
        return ;
    }
    printf("%d\t",*(int*)data_ptr);

}

int  bijiao(const void* data1,const void * data2) //删除二叉树节点所利用的函数
{
    if(data1 ==NULL || data2 == NULL)
    {
        return 0;
    }
    return (*(int*)data1) - (*(int*)data2);
}
int main()
{
    srand(time(NULL));
    tree* t = NULL;
    int arr[6] = {4,2,8,0,5,7} ;
    for(int i  = 0 ; i < 6;++i)
    {
        tree_insert(&t,NULL,&arr[i],sizeof(int),int_cmp_fun);
    }  
    tree* ptemp = tree_min(t);       //查找最小树的空间节点
    printf("\n%d\n",*((int*)(ptemp->data)));
    unsigned int gg =tree_size(t); 
    tree_In(t,Print);
    printf("\n");
    printf("树的空间节点数目为：%u\n",gg);
    tree_post(t,Print);


    /*
    tree_Inorder(t,Print);          //中序遍历
    printf("\n-------------------\n");
    tree_postorder(t,Print);        //后序遍历
    printf("\n-------------------\n");
    tree_preorder(t,Print);         //前序遍历
    printf("\n-------------------\n");
    ptemp = tree_find(t,&arr[3],int_cmp_fun);     //查找　０　这个数据的节点
    tree_delete(&ptemp,bijiao);                   //删除之前　找到的节点
    tree_Inorder(t,Print);                         //中序遍历
    printf("\n-------------------\n");
    ptemp = tree_find(t,&arr[5],int_cmp_fun);       //查找　7　这个数据的节点
    tree_delete(&ptemp,bijiao);                     //删除之前　找到的节点
    tree_Inorder(t,Print);                            //中序遍历
   
    ptemp = tree_max(t);                           //查找最大树的空间节点
    printf("\n%d\n",*(int*)(ptemp->data));         //打印这个节点　的数据
    */
    return 0;
}

makefile

OUT : tree.o main.o 
	gcc -g main.o tree.o -o OUT
tree.o : tree.c
	gcc -g -c tree.c -o tree.o
main.o : main.c
	gcc -g -c main.c -o main.o 
clean:
	rm *.o OUT

_She001
关注
专栏目录
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
从二叉树中删去所有叶结点
霸道总裁爱上网
10-23 9011
删除所有叶子结点 void Del_0(BiTree T) //删除叶子结点 { BiTNode *p = T; if (p == NULL) return; else if (p->lchild == NULL && p->rchild == NULL) free(p); Del_0(T->lchild); Del_0(T->rchild...
删除二叉树叶子节点的问题
weixin_53294082的博客
08-06 491
采用递归的方式，将二叉树的叶子结点都删掉，通过数组构建二叉树，深度优先遍历算法获取二叉树路径
二叉排序树的删除+图解
热门推荐
Frank---7的博客
03-30 5万+
图解 第一种情况 第二种情况 第三种情况 代码实现 package com.atguigu.binarysorttree; import com.sun.javafx.sg.prism.NGImageView; import javafx.scene.transform.Rotate; import java.io.InputStream; import java.util.Timer; /** * @创建人 wdl * @创建时间 2021/3/29 * @描述 */ public
二叉树上删除叶子结点用以建立双向链表(C语言实现）
weixin_62788105的博客
07-14 588
已知一棵以二叉链表存储的二叉树，按从右到左的次序，利用叶子结点建立一个带头结点的双向链表。（1）从键盘输入扩展的先序结点数据，建立二叉树。（2）找叶子结点，找到后从二叉树中删除，然后插入到双向链表中。（3）要求程序通过一个主菜单进行控制，通过选择菜单项序号调用各功能函数。[提示]前序、中序、后序遍历二叉树，访问叶子结点的相对次序都是从左至右。因此，可以采用头插法建立双向链表。树的二叉链表的结点与双向链表的结点结构相同，只是对两个指针域的解释不同。typedef struct tree {char data;
力扣：450. 删除二叉搜索树中的节点
weixin_44788175的博客
03-24 923
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
春节7天练丨Day5：二叉树和堆1
08-03
首先，二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用广泛，例如二叉查找树（Binary Search Tree，BST）是其中一种常见的类型。二叉查找树的特点是，...
代码随想录 Day14 二叉树
02-07
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树广泛应用于各种计算机科学领域，如数据管理、算法设计、编译器设计等。 #### 二、`TreeNode`类的定义 在Java中，...
华清创客数据结构课件与代码.rar
12-01
在“华清创客数据结构课件与代码.rar”这个压缩包中，包含了一系列关于数据结构的课程资料和相关的C语言实现代码，旨在帮助学习者深入理解和掌握这一关键领域。 首先，我们从“Day1-数据结构概述及顺序表”开始。...
数据结构与算法 腾讯精选练习50 V1.0.pdf
04-20
- 两数相加（Day01）：涉及到链表数据结构的操作，包括链表的遍历和节点值的计算。 - 寻找两个有序数组的中位数（Day02）：考查二分查找算法的使用和对有序数据进行查找的效率。 - 最长回文子串（Day03）：学习字符...
leetcode 450.删除二叉搜索树中的结点
最新发布
m0_54244065的博客
09-29 299
【代码】leetcode 450.删除二叉搜索树中的结点。
删除二叉树的所有叶子节点（递归与非递归）
m0_52063239的博客
10-09 2083
删除二叉树的所有叶子节点（递归与非递归）
二叉树中删除所有叶子结点
csdnzzkk的博客
12-04 1389
void Del（BitNode *&p）{ if（pnull）return； else if（p->lchildnull&&p->rchild==null）{ free（p）； p=null； } else{ Del（p->lchild）； Del（p->rchild）； } }
有序二叉树节点的删除
qq_52331401的博客
01-02 732
一、删除节点有三种情况 1，删除叶子节点 2，删除只有一个子树的节点 3，删除有两个子树的节点 二、步骤： （一），删除叶子节点： 1,找到要删除的叶子节点（targetNode） 2,找到目标结点的父节点parentNode（考虑是否有父节点） 3,确定删除的节点是其父节点的左子树还是右子树 4,根据前边的情况进行删除 左子树：parent.left = null 右子树：parent.right = null （二），删除只有一个子树的节点 1,找到要删除的叶子节点（targe
剪掉二叉树叶子节点
未闻花开
01-04 1035
Time Limit: 1sec Memory Limit:256MB Description 实现下述函数，剪去非空二叉树中的所有的叶子节点void cutLeaves(BinaryNode* &root)given the following definition:typedef int T; struct BinaryNode{ T data; //store data Bi
数据结构习题——二叉树叶子结点的删除/删除以元素X为根的子树
无由页的博客
04-29 3382
前言 关于结点的删除例题，两道题目又类似的地方，一起记录下来。 正文 题目一： 二叉树叶子结点的删除 之前我认为的是，只要free()掉叶子结点就可以了，但是为了避免野指针的出现，我们还需要将指向叶子结点的双亲的左右指针置为NULL！ 代码 void Del_0(BiTree T) //删除叶子结点 { BiTNode *p = T; if ((p->lchild == NULL &am...
二叉树中删除一个节点
花落归尘醉的专栏
06-15 1万+
二叉树的删除可以算是二叉树最为复杂的操作，删除的时候要考虑到很多种情况： 1.被删除的节点是叶子节点 2.被删除的节点只有左孩子节点 3.被删除的节点只有右孩子节点 4.被删除的有两个孩子节点   所以在删除的时候，这4种情况都必须考虑进去，并且这4中情况之下，还会有细的划分，下面就细说怎么删除。   在二叉树中想要删除一个节点，首先需要找到这个节点，由于二叉树在插入节点的时候会遵
二叉树叶子节点数目及其遍历算法解析
资源摘要信息: "本资源提供了关于二叉树的原代码，主要涉及两个方面：首先是计算二叉树中叶子节点的数目；其次是实现二叉树的前序、中序和后序遍历。这些内容是数据结构与算法中非常经典的部分，对于理解二叉树结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值