二叉树

最新推荐文章于 2024-09-17 10:36:22 发布
最新推荐文章于 2024-09-17 10:36:22 发布
阅读量403 收藏
点赞数
分类专栏： C&C++ 文章标签： null access 算法 insert search struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cbeast/article/details/2584776
版权 
//二叉树处理头文件

//包括二叉树的结构定义,二叉树的创建,遍历算法(递归及非递归),

/*

 作者：成晓旭

 时间：2001年10月7日(18:49:38-20:00:00)

 内容：完成二叉树创建,二叉树的前,中,后序遍历(递归)

 时间：2001年10月7日(21:09:38-22:09:00)

 内容：完成二叉树的前,中序遍历(非递归)

 时间：2001年10月8日(10:09:38-11:29:00)

 内容：完成查找二叉树的静,动态查找(非递归)

*/

#include "stdlib.h"



#define MAXNODE 20

#define ISIZE 8

#define NSIZE0 7

#define NSIZE1 8

#define NSIZE2 15

//SHOWCHAR = 1(显示字符) SHOWCHAR = 0(显示数字)

#define SHOWCHAR 1

//二叉树结构体

struct BTNode

{

 int data;

 BTNode *rchild;

 BTNode *lchild;

};

//非递归二叉树遍堆栈

struct ABTStack

{

 BTNode *ptree;

 ABTStack *link;

};

char TreeNodeS[NSIZE0] = {'A','B','C','D','E','F','G'};

char PreNode[NSIZE0] = {'A','B','D','E','C','F','G'};

char MidNode[NSIZE0] = {'D','B','E','A','C','G','F'};

int TreeNodeN0[NSIZE1][2] = {{0,0},{1,1},{2,2},{3,3},{4,4},{5,5},{6,6},{7,7}};

int TreeNodeN1[NSIZE1][2] = {{0,0},{4,1},{2,2},{6,3},{1,4},{3,5},{5,6},{7,7}};

int TreeNode0[NSIZE1][2] = {{'0',0},{'D',1},{'B',2},{'F',3},{'A',4},{'C',5},{'E',6},{'G',7}};

int TreeNode1[NSIZE1][2] = {{'0',0},{'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7}};

int TreeNode2[NSIZE2][2] = {{'0',0},{'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7},{'H',8},{'I',9},{'J',10},{'K',11},{'L',12},{'M',13},{'N',14}};

int InsertNode[ISIZE] = {-10,-8,-5,-1,0,12,14,16};

//char *prestr = "ABDECFG";

//char *midstr = "DBEACGF";

/*

 二叉树创建函数dCreateBranchTree1()<递归算法>

 参数描述：

  int array[]: 二叉树节点数据域数组

  int i:   当前节点的序号

  int n:   二叉树节点个数

 返回值:

  dCreateBranchTree1 = 新建二叉树的根节点指针

 备注:

  根节点 = array[(i+j)/2];

  左子节点 = [array[i],array[(i+j)2-1]]

  右子节点 = [array[(i+j)/2+1,array[j]]

*/

BTNode *dCreateBranchTree1(char array[],int i,int n)

{

 BTNode *p; /*二叉树节点*/

 if(i>=n)

  return(NULL);

 p = (BTNode *)malloc(sizeof(BTNode));

 p->data = array[i];

 p->lchild = dCreateBranchTree1(array,2*i+1,n);

 p->rchild = dCreateBranchTree1(array,2*i+2,n);

 return(p);

}

/*

 二叉树创建函数dCreateBranchTree2()<递归算法>

 参数描述：

  int array[]: 二叉树节点数据域数组

  int i:   当前节点的序号

  int n:   二叉树节点个数

 返回值:

  dCreateBranchTree2 = 新建二叉树的根节点指针

 备注:

  根节点 = array[(i+j)/2];

  左子节点 = [array[i],array[(i+j)2-1]]

  右子节点 = [array[(i+j)/2+1,array[j]]

*/

BTNode *dCreateBranchTree2(char array[],int i,int j)

{

 BTNode *p; /*二叉树节点*/

 if(i>j)

  return(NULL);

 p = (BTNode *)malloc(sizeof(BTNode));

 p->data = array[(i+j)/2];

 p->lchild = dCreateBranchTree2(array,i,(i+j)/2-1);

 p->rchild = dCreateBranchTree2(array,(i+j)/2+1,j);

 return(p);

}

/*

 二叉树创建函数dCreateBranchTree3()<非递归算法>

 已知二叉树的前,中序遍历序列串,构造对应的二叉树

 <编程思想>:

  首先,在前序遍历序列中的首元素是二叉树的根节点,接着

 ,在中序遍历序列中找到此节点,那么在此节点以前的节点必为

 其左孩子节点,以后的必为其右孩子节点;

  然后,在中序遍历序列中,根节点的左子树和右子树再分别

 对应子树前序遍历序列的首字符确定子树的根节点,再由中序

 遍历序列中根节点的位置分别确定构成它们的左子树和右子树

 的节点;

  依次类推,确定二叉树的全部节点,构造出二叉树.

 参数描述：

  char *pre:  前序遍历序列

  char *mid:  中序遍历序列

  int n:   遍历序列中节点个数

 返回值:

  dCreateBranchTree3 = 新建二叉树的根节点指针

*/

BTNode *dCreateBranchTree3(char *pre,char *mid,int n)

{

 BTNode *p;

 char *t;

 int left;

 if(n<=0)

  return(NULL);

 p = (BTNode *)malloc(sizeof(BTNode));

 p->data = *pre;

 for(t=mid;t<mid+n;t++)

  if(*t==*pre) break;  /*在中序遍历序列中查找根节点*/

 left = t - mid;  /*左子树的节点个数*/

 p->lchild = dCreateBranchTree3(pre+1,t,left);

 p->rchild = dCreateBranchTree3(pre+1+left,t+1,n-1-left);

 return(p);

}

/*

 二叉树创建函数CreateBranchTree()<非递归算法>

 参数描述：

  int array[]: 二叉树节点数据域数组

  int n:   二叉树节点个数

 返回值:

  CreateBranchTree = 新建二叉树的根节点指针

*/

BTNode *CreateBranchTree(int array[][2],int n)

{

 BTNode *head,*p;

 BTNode *NodeAddr[MAXNODE]; //节点地址临时缓冲区

 int i,norder,rorder;

 head = NULL;

 printf("二叉树原始数据<新建顺序>：/t");

 for(i=1;i<=n;i++)

 {

  p = (BTNode *)malloc(sizeof(BTNode));

  if(p==NULL)

  {

   printf("/n新建节点时内存溢出！/n");

   return(NULL);

  }

  else

  {

   p->data = array[i][0];

   p->lchild = p->rchild = NULL;

   norder = array[i][1];

   NodeAddr[norder] = p;

   if(norder>1)

   {

    rorder = norder / 2; /*非根节点:挂接在自己的父节点上*/

    if(norder % 2 == 0)

     NodeAddr[rorder]->lchild = p;

    else

     NodeAddr[rorder]->rchild = p;

   }

   else

    head = p; /*根节点*/

   if(SHOWCHAR)

    printf("%c    ",p->data);

   else

    printf("%d    ",p->data);

  }

 }

 return(head);

}

//------------------------------递归部分------------------------------

/*

 二叉树前序遍历函数dpre_Order_Access()<递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针  

*/

void dpre_Order_Access(BTNode *head)

{

 if(head!=NULL)

 {

  if(SHOWCHAR)

   printf("%c    ",head->data);

  else

   printf("%d    ",head->data);

  dpre_Order_Access(head->lchild); /*递归遍历左子树*/

  dpre_Order_Access(head->rchild); /*递归遍历右子树*/

 }

}

/*

 二叉树中序遍历函数dmid_Order_Access()<递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针  

*/

void dmid_Order_Access(BTNode *head)

{

 if(head!=NULL)

 {

  dmid_Order_Access(head->lchild); /*递归遍历左子树*/

  if(SHOWCHAR)

   printf("%c    ",head->data);

  else

   printf("%d    ",head->data);

  dmid_Order_Access(head->rchild); /*递归遍历右子树*/

 }

}

/*

 二叉树后序遍历函数dlast_Order_Access()<递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针  

*/

void dlast_Order_Access(BTNode *head)

{

 if(head!=NULL)

 {

  dlast_Order_Access(head->lchild); /*递归遍历左子树*/

  dlast_Order_Access(head->rchild); /*递归遍历右子树*/

  if(SHOWCHAR)

   printf("%c    ",head->data);

  else

   printf("%d    ",head->data);

 }

}

//------------------------------递归部分------------------------------

//------------------------------非递归部分------------------------------

/*

 二叉树前序遍历函数pre_Order_Access()<非递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针  

*/

void pre_Order_Access(BTNode *head)

{

 BTNode *pt;

 ABTStack *ps,*top;

 pt = head;

 top = NULL;

 printf("/n二叉树的前序遍历结果<非递归>：/t");

 while(pt!=NULL ||top!=NULL)  /*二叉树未遍历完,或堆栈非空*/

 {

  while(pt!=NULL)

  {

   if(SHOWCHAR)

    printf("%c    ",pt->data);  /*访问根节点*/

   else

    printf("%d    ",pt->data);  /*访问根节点*/

   ps = (ABTStack *)malloc(sizeof(ABTStack));  /*根节点进栈*/

   ps->ptree = pt;

   ps->link = top;

   top = ps;

   pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if(top!=NULL)

  {

   pt = top->ptree; /*栈顶节点出栈*/

   ps = top;

   top = top->link;

   free(ps); /*释放栈顶节点空间*/

   pt = pt->rchild; /*遍历节点右子树*/

  }

 }

}

/*

 二叉树中序遍历函数mid_Order_Access()<非递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针 

*/

void mid_Order_Access(BTNode *head)

{

 BTNode *pt;

 ABTStack *ps,*top;

 int counter =1;

 pt = head;

 top = NULL;

 printf("/n二叉树的中序遍历结果<非递归>：/t");

 while(pt!=NULL ||top!=NULL)  /*二叉树未遍历完,或堆栈非空*/

 {

  while(pt!=NULL)

  {  

   ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根节点进栈*/

   ps->ptree = pt;

   ps->link = top;

   top = ps;

   pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if(top!=NULL)

  {

   pt = top->ptree; /*栈顶节点出栈*/

   ps = top;

   top = top->link;

   free(ps); /*释放栈顶节点空间*/

   if(SHOWCHAR)

    printf("%c    ",pt->data); /*访问根节点*/

   else

    printf("%d    ",pt->data); /*访问根节点*/

   pt = pt->rchild; /*遍历节点右子树*/

  }

 }

}

/*

 二叉树后序遍历函数last_Order_Access()<非递归算法>

 参数描述：

  BTNode *head: 二叉树的根节点指针  

*/

void last_Order_Access(BTNode *head)

{

 BTNode *pt;

 ABTStack *ps,*top;

 int counter =1;

 pt = head;

 top = NULL;

 printf("/n二叉树的后序遍历结果<非递归>：/t");

 while(pt!=NULL ||top!=NULL)  /*二叉树未遍历完,或堆栈非空*/

 {

  while(pt!=NULL)

  {  

   ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根节点进栈*/

   ps->ptree = pt;

   ps->link = top;

   top = ps;

   pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if(top!=NULL)

  {

   pt = top->ptree; /*栈顶节点出栈*/

   ps = top;

   top = top->link;

   free(ps); /*释放栈顶节点空间*/

   printf("%c    ",pt->data); /*访问根节点*/

   pt = pt->rchild; /*遍历节点右子树*/

  }

 }

}

/*

 二叉查找树静态查找函数static_Search_STree()<非递归算法>

 参数描述：

  BTNode *head: 二叉查找树的根节点指针

  int key:  查找关键码

 返回值:

  static_Search_STree = 键值为key的节点指针(找到) 

  static_Search_STree = NULL(没有找到)

*/

BTNode *static_Search_STree(BTNode *head,int key)

{

 while(head!=NULL)

 {

  if(head->data == key)

  {

   printf("/n数据域=%d/t地址=%d/t/n",head->data,head);

   return(head); /*找到*/

  }

  if(head->data > key)

   head = head->lchild; /*继续沿左子树搜索*/

  else

   head = head->rchild; /*继续沿右子树搜索*/

 }

 return(NULL); /*没有查找*/

}

/*

 二叉查找树动态查找函数dynamic_Search_STree()<非递归算法>

 参数描述：

  BTNode *head:  二叉查找树的根节点指针

  BTNode **parent: 键值为key的节点的父节点指针的指针

  BTNode **head:  键值为key的节点指针的指针(找到)或NULL(没有找到)

  int key:   查找关键码

 注意:

  *parent == NULL 且 *p == NULL 没有找到(二叉树为空)

  *parent == NULL 且 *p != NULL 找到(找到根节点)

  *parent != NULL 且 *p == NULL 没有找到(叶节点)<可在parent后插入节点>

  *parent != NULL 且 *p != NULL 找到(中间层节点)

*/

void dynamic_Search_STree(BTNode *head,BTNode **parent,BTNode **p,int key)

{

 *parent = NULL;

 *p = head;

 while(*p!=NULL)

 {

  if((*p)->data == key)

   return; /*找到*/

  *parent = *p; /*以当前节点为父,继续查找*/

  if((*p)->data > key)

   *p = (*p)->lchild; /*继续沿左子树搜索*/

  else

   *p = (*p)->rchild; /*继续沿右子树搜索*/

 }

}

/*

 二叉查找树插入节点函数Insert_Node_STree()<非递归算法>

 参数描述：

  BTNode *head: 二叉查找树的根节点指针

  int key:  查找关键码

 返回值:

  Insert_Node_STree = 1 插入成功

  Insert_Node_STree = 0 插入失败(节点已经存在)

*/

int Insert_Node_STree(BTNode *head,int key)

{

 BTNode *p,*q,*nnode;

 dynamic_Search_STree(head,&p,&q,key);

 if(q!=NULL)

  return(0);  /*节点在树中已经存在*/

 nnode = (BTNode *)malloc(sizeof(BTNode)); /*新建节点*/

 nnode->data = key;

 nnode->lchild = nnode->rchild = NULL;

 if(p==NULL)

  head = p; /*原树为空,新建节点为查找树*/

 else

 {

  if(p->data > key)

   p->lchild = nnode; /*作为左孩子节点*/

  else

   p->rchild = nnode; /*作为右孩子节点*/

 }

 return(1); /*插入成功*/

}

/*

 二叉查找树插入一批节点函数Insert_Batch_Node_STree()<非递归算法>

 参数描述：

  BTNode *head: 二叉查找树的根节点指针

  int array[]: 被插入的数据域数组

  int n:   被插入的节点数目

*/

void Insert_Batch_Node_STree(BTNode *head,int array[],int n)

{

 int i;

 for(i=0;i<n;i++)

 {

  if(!Insert_Node_STree(head,array[i]))

   printf("/n插入失败<键值为%d的节点已经存在>！/n",array[i]); 

 }

}

//------------------------------非递归部分------------------------------
cbeast
关注
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树详解
热门推荐
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
二叉树的遍历实验报告.pdf
11-11
二叉树是一种重要的数据结构，它由有限个节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求解等多种场景。本实验报告将探讨二叉树的遍历...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 519
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 311
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
输出一个三位数
2301_77501988的博客
09-13 424
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1205
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 498
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 607
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 4146
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
【例题】lanqiao4425 咖啡馆订单系统
最新发布
m0_73676887的博客
09-17 170
样例输入样例输出3 2样例说明输入的数组为：【3，1，2】增量序列为：【2，1】当增量 h=2：对于每一个索引 i，我们会将数组元素 arr[i] 与 arr[i−h] 进行比较，并进行可能的交换。当增量 h=1：这就是一个普通的插入排序。总结：总共进行了 3 次比较，2 次交换。
二分系列(二分查找)9/12
2301_78191305的博客
09-12 986
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
选择排序
shylyly_的博客
09-13 1082
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值