数据结构-二叉树

已于 2023-11-08 09:16:17 修改
阅读量79 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ 算法
于 2022-12-15 11:19:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62362934/article/details/128327343
版权

目录

一、main

二、function

三、com

一、main

#include <iostream>
#include "com.h"
using namespace std;

int main()
{
    int choice ;
    BiTree T , NewT , p , q ;
    do
    {
        printf("\t\t\t======================================================\n");
		printf("\t\t\t|                                                    |\n");
		printf("\t\t\t|                   二叉树的基本操作                 |\n");
		printf("\t\t\t|                                                    |\n");
		printf("\t\t\t|====================================================|\n");
		printf("\t\t\t|                  请选择要操作的命令                |\n");
		printf("\t\t\t|----------------------------------------------------|\n");
		printf("\t\t\t|                                                    |\n");
		printf("\t\t\t|   1.建立一棵二叉树            2.先序遍历二叉树     |\n");
		printf("\t\t\t|   3.中序遍历二叉树            4.后序遍历二叉树     |\n");
		printf("\t\t\t|   5.求二叉树的深度            6.二叉树的节点总数   |\n");
		printf("\t\t\t|   7.求叶子节点个数            8.单分支节点总数     |\n");
		printf("\t\t\t|   9.双分支节点总数            10.交换左右子树      |\n");
		printf("\t\t\t|   11.层序遍历                 0.退出整个系统       |\n");
		printf("\t\t\t|----------------------------------------------------|\n");
		printf("\t\t\t|                       附加指令                     |\n");
		printf("\t\t\t|   12.复制二叉树               13.先序非递归遍历    |\n");
		printf("\t\t\t|   14.中序非递归遍历           15.后序非递归遍历    |\n");
		printf("\t\t\t|   16.判断两个二叉树是否完全相同                    |\n");
		printf("\t\t\t|                                                    |\n");
		printf("\t\t\t|                                                    |\n");
		printf("\t\t\t======================================================\n");
		printf("选择（0---16):\t");
		cin >> choice ;
        switch (choice)
        {
        case 0 : // 0.退出
            cout << "退出成功" ;
            cout << endl ;
            break ;  //return 0 ;
        case 1 :  //1.建立一棵二叉树
            CreateBiTree(T) ;
            cout << "创建成功" ;
            cout << endl ;
            break ;
        case 2 :  //2.先序遍历二叉树
            cout << "遍历结果为：" ;
            PreOrderTraverse(T) ;
            cout << endl ;
            break ;
        case 3 :  //3.中序遍历二叉树
            cout << "遍历结果为：" ;
            InOrderTraverse(T) ;
            cout << endl ;
            break ;
        case 4 :  //4.后序遍历二叉树
            cout << "遍历结果为：" ;
            PostOrderTraverse(T) ;
            cout << endl ;
            break ;
        case 5 : //5.求二叉树的深度
            cout << "二叉树的深度为：" << Depth(T) ;
            cout << endl ;
            break ;
        case 6 : //6.二叉树的节点总数
            cout << "二叉树的节点总数为：" << NodeCount(T) ;
            cout << endl ;
            break ;
        case 7 :
			cout << "二叉树的叶子节点总数为：" << LeafCount(T) ;
            cout << endl ;
            break ;
        case 8 :
			cout << "二叉树的单分支节点总数为：" << CountSingleeNode(T) ;
            cout << endl ;
            break ;
        case 9 :
			cout << "二叉树的双分支节点总数为：" << CountDoubleNode(T) ;
            cout << endl ;
            break ;
        case 10 :
			ChangeLeftRight(T) ;
			cout << "交换成功" << endl ;
			cout << "交换后的先序遍历：" ;
			PreOrderTraverse(T) ;
			cout << endl ;
			cout << "交换后的中序遍历：" ;
			InOrderTraverse(T) ;
			cout << endl << endl ;
            break ;  //abd###c#e##
        case 11 : // 11.层序遍历
        	cout << "遍历结果为：" ;
            LevelOrder(T) ;
            cout << endl ;
            break ;
            
            //  附加指令
		case 12 : //12.复制二叉树 
			Copy(T , NewT) ;
			cout << "复制成功" << endl ;
			cout << "新树的先序遍历：" ;
			PreOrderTraverse(NewT) ;
			cout << endl ;
			cout << "新树的中序遍历：" ;
			InOrderTraverse(NewT) ;
			cout << endl << endl ;
            break ;  //abd###c#e##
        case 13 : // 先序非递归遍历
			cout << "先序非递归遍历：" ;
            PreOrder(T) ;
            cout << endl ;
            break ;
        case 14 : //4.中序非递归遍历
			cout << "中序非递归遍历：" ;
            InOrder(T) ;
            cout << endl ;
            break ;
        case 15 : // 后序非递归遍历
			cout << "后序非递归遍历：" ;
//            PostOrder(T) ;
            cout << endl ;
            break ;
        case 16 ://16.判断两个二叉树是否完全相同
        	cout << "请输入树p：" ;
        	CreateBiTree(p) ;
        	cout << "请输入树q：" ;
        	CreateBiTree(q) ;	
        	cout << "树p的先序遍历：" ;
			PreOrderTraverse(p) ;
			cout << endl ;
			cout << "新p的中序遍历：" ;
			InOrderTraverse(p) ;
			cout << endl << endl ;
			
        	cout << "新q的先序遍历：" ;
			PreOrderTraverse(q) ;
			cout << endl ;
			cout << "新q的中序遍历：" ;
			InOrderTraverse(q) ;
			cout << endl << endl ;
        	if(isSame(p , q))  cout << "两棵树相同" ;
			else   cout << "两棵树不相同" ;
			cout << endl ;
            break ;
        default :
			cout << "输入不合法，请重新输入" ;
			cout << endl ;	 
        }
    }while(choice != 0) ;
    return 0;
}

二、function

#include <iostream>
#include "com.h"
using namespace std;

// 1.建立一棵二叉树
void CreateBiTree(BiTree &T)
{
    char ch ;
    cin >> ch ;
    if(ch == '#')  T = NULL ; // 回溯
    else
    {
        T = new BiTNode ;
        T->data = ch ;
        CreateBiTree(T->lchild) ;
        CreateBiTree(T->rchild) ;
    }
}

// 2.先序遍历二叉树 
void PreOrderTraverse(BiTree T)
{
    if(T)
    {
        cout << T->data << " " ;
        PreOrderTraverse(T->lchild) ;
        PreOrderTraverse(T->rchild) ;
    }
}

// 3.中序遍历二叉树
void InOrderTraverse(BiTree T)
{
    if(T)
    {
        InOrderTraverse(T->lchild) ;
        cout << T->data << " " ;
        InOrderTraverse(T->rchild) ;
    }
}

// 4.后序遍历二叉树
void PostOrderTraverse(BiTree T)
{
    if(T)
    {
        PostOrderTraverse(T->lchild) ;
        PostOrderTraverse(T->rchild) ;
        cout << T->data << " " ;
    }
}

//5.求二叉树的深度
int Depth(BiTree T)
{
    if(!T)  return 0 ;
    else
    {
        int m , n ;
        m = Depth(T->lchild) ;  // 左边的最大深度 
        n = Depth(T->rchild) ; // 右边的最大深度  
        return  max(m , n) + 1 ;  // 直接左右最大值加一 
    }
}

//6.二叉树的节点总数 
int NodeCount(BiTree T)
{
    if(T == NULL)  return 0 ; //空，为零
    else  return NodeCount(T->lchild) + NodeCount(T->rchild) + 1 ; //左加右再加一
}




//  求叶子节点个数 
int LeafCount(BiTree T)
{
	if(T == NULL)  return 0 ;
	if(T->lchild == NULL && T->rchild == NULL)  return 1 ;
	else   return LeafCount(T->lchild) + LeafCount(T->rchild) ;
} 

// 单分支节点数
int CountSingleeNode(BiTree T)
{
	int num = 0 ;
	if(T)
	{
		if((T->lchild == NULL && T->rchild != NULL) || (T->lchild != NULL && T->rchild == NULL))
			num ++ ;
		num += CountSingleeNode(T->lchild) ;
		num += CountSingleeNode(T->rchild) ;
	}
	return num ;	
} 

// 双分支
int	CountDoubleNode(BiTree T)
{
	int num = 0;
	if (T)
	{
		if (T->lchild != NULL && T->rchild != NULL)
			num ++ ;
		num += CountDoubleNode(T->lchild);
		num += CountDoubleNode(T->rchild);
	}
	return num;
}


// 交换左右子树
void ChangeLeftRight(BiTree &T)
{
	BiTree temp ;
	if(T)
	{
		ChangeLeftRight(T->lchild) ;
		ChangeLeftRight(T->rchild) ;
		temp = T->lchild ;
		T->lchild = T->rchild ;
		T->rchild = temp ;
	}
} 

// 层序遍历
void LevelOrder(BiTree T)
{
	BiTree b ;
	SqQueue Q ;
	InitQueue(Q) ;
	if(T)
	{
		EnQueue(Q , T) ;
		while(!QueueEmpty(Q))
		{
			DeQueue(Q , b) ;
			cout << b->data << " " ;
			if(b->lchild != NULL)  EnQueue(Q , b->lchild) ;
			if(b->rchild != NULL)  EnQueue(Q , b->rchild) ;
		}
	}
} 


//  附加指令

// 复制 
void Copy(BiTree T , BiTree &NewT)
{
	if(T == NULL)
	{
		NewT = NULL ;
		return ;
	}
	else
	{
		NewT = new BiTNode ;
		NewT->data = T->data ;
		Copy(T->lchild , NewT->lchild) ;
		Copy(T->rchild , NewT->rchild) ;
	}
} 
// 先序非递归遍历
void PreOrder(BiTree T)
{
	LinkStack S ;
	InitStack(S) ;
	BiTree p = T , q ;
	while(p || !StackEmpty(S))
	{
		while(p)
		{
			cout << p->data << " " ;
			Push(S , p) ;
			p = p->lchild ;
		}
		if(!StackEmpty(S))
		{
			Pop(S , q) ;
			p = q->rchild ;
		}
	}
}
//中序非递归遍历
void InOrder(BiTree T)
{
	LinkStack S ;
	InitStack(S) ;
	BiTree p = T , q ;
	q = new BiTNode ; 
	while(p || !StackEmpty(S))
	{
		if(p)
		{
			Push(S , p) ;
			p = p->lchild ;  // 一直向左下遍历 
		}
		else
		{
			Pop(S , q) ;
			cout << q->data << " " ;
			p = q->rchild ;
		}
	}
}

//16.判断两个二叉树是否完全相同
bool isSame(BiTree p, BiTree q) 
{
	//先进行判空
	//两棵树均为空，则是相同的树
	if (p == NULL && q == NULL) {
		return true;
	}
	//只有一棵树是空树，则必不是相同的树
	if (p == NULL || q == NULL) {
		return false;
	}
	//其他情况，左子树相同，右子树相同，结点的值相同
	return p->data == q->data && isSame(p->lchild, q->lchild) && isSame(p->rchild, q->rchild);
}




// 栈
// 初始化
Status InitStack(LinkStack &S)
{
	S = NULL ;
	return OK ;
} 
// 判断栈是否为空
Status StackEmpty(LinkStack S)
{
	if(S == NULL)  return 1 ; //空 
	else  return 0 ;  //非空 
}
// 入栈
Status Push(LinkStack &S , SElemType e)
{
	LinkStack p ;
	p = new StackNode ;//新建p存放插入元素 
	p->data = e , p->next = S ;
	S = p ;
	return OK ;	
} 

// 出栈
Status Pop(LinkStack &S , SElemType &e)
{
	if(S == NULL)  return ERROR ; //没有栈顶可删 
	LinkStack p = S ; //p临时保存栈顶，准备删除  
	e = S->data ; // 删除元素保存在e中 
	S = S->next ;
	delete p ; //释放空间 
	return OK ;
}


// 队列 
// 初始化
Status InitQueue(SqQueue &Q)
{
	Q.base = new QElemType[MAXQSIZE] ;
	if(!Q.base)  return ERROR ; 
	Q.front = Q.rear = 0 ; // 开始为空 0
	return OK ; 
} 
// 入队
Status EnQueue(SqQueue &Q , QElemType e)
{
	if((Q.rear+1)%MAXQSIZE == Q.front)  return ERROR ; // 已满
	Q.base[Q.rear] = e ;
	Q.rear = (Q.rear+1) % MAXQSIZE ;
	return OK ;	
}
// 出队
Status DeQueue(SqQueue &Q , QElemType &e)
{
	if(Q.front == Q.rear)  return ERROR ; // 空队列
	e = Q.base[Q.front] ; // 传回到主函数
	Q.front = (Q.front+1) % MAXQSIZE ;
	return OK ;
}
// 判空
bool QueueEmpty(SqQueue Q)
{
	if(Q.front == Q.rear)  return true ;
	else  return false ;
}

三、com

#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED
#define OK 1
#define ERROR 0

typedef int Status ;
typedef char TElemType ;
typedef struct BiTNode{
    TElemType data ;
    struct BiTNode *lchild , *rchild ;
}BiTNode , *BiTree ;
extern void CreateBiTree(BiTree &T) ;
extern void PreOrderTraverse(BiTree T) ;
extern void InOrderTraverse(BiTree T) ;
extern void PostOrderTraverse(BiTree T) ;
extern int Depth(BiTree T) ;
extern int NodeCount(BiTree T) ;
extern int LeafCount(BiTree T) ;
extern int CountSingleeNode(BiTree T) ;
extern int	CountDoubleNode(BiTree T) ;
extern void ChangeLeftRight(BiTree &T) ;
extern void LevelOrder(BiTree T) ;
// 附加 
extern void Copy(BiTree T , BiTree &NewT) ;
extern void PreOrder(BiTree T) ;
extern void InOrder(BiTree T) ;
extern void PostOrder(BiTree T) ;
bool isSame(BiTree p, BiTree q) ;//16.判断两个二叉树是否完全相同



// 队列 
typedef BiTree QElemType ;
#define MAXQSIZE 5 
typedef struct QNode{
	QElemType *base ;
	int front ;
	int rear ;
}SqQueue;


// 栈 
typedef BiTree SElemType ;
typedef struct StackNode{
	SElemType data ;
	struct StackNode *next ;
}StackNode , *LinkStack;
// 
extern Status InitQueue(SqQueue &Q) ;
extern Status EnQueue(SqQueue &Q , QElemType e) ;
extern Status DeQueue(SqQueue &Q , QElemType &e) ;
extern bool QueueEmpty(SqQueue Q) ;

//
extern Status InitStack(LinkStack &S) ;
extern Status StackEmpty(LinkStack S) ;
extern Status Push(LinkStack &S , SElemType e) ;
extern Status Pop(LinkStack &S , SElemType &e) ;
#endif // HEADER_H_INCLUDED

魔莫摸墨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构-二叉树】二叉树
檀越的博客
09-12 2万+
二叉树是一种常见的树状数据结构，它由节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。每个节点包含一个值或数据项，这些节点通过边（通常称为链接或指针）相互连接起来，形成一个层次结构。
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3371
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
二叉树的实现(数据结构+C语言)
weixin_49312527的博客
02-12 1911
一.主函数调用 a.我们使用数组存储二叉树中的所有结点,以前序遍历的方式存储(下面创建的时候就必须采用前序的方式创建二叉树,在数组中的存储方式必须和创建时的方式相同)空结点以#表示.在主函数中我们只需定义一个指针用来存储根节点就行,根据根节点我们便可以访问到二叉树中的所有结点. //主函数 int main(){ BTDataType str[]="ABD##E#H##CF##G##"; int num=0; int k=0; char x,Empty; BTNode* root;
数据结构 - 二叉树的遍历
了解➔熟悉➔掌握➔精通
02-18 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 二叉树的遍历 N：访问根结点，L：遍历根结点的左子树，R：遍历根结点的右子树。 给定一棵二叉树的前序遍历序列和中序遍历序列可以惟一确定一棵二叉树。 二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。 ...
头歌实践平台-数据结构-二叉树及其应用
toptopniba的博客
11-13 3646
【代码】头歌实践平台-数据结构-二叉树及其应用。
数据结构--二叉树--详解
热门推荐
weixin_45796387的博客
03-20 11万+
本章目录1. 树概念及结构1.1树概念1.2树的表示2. 二叉树概念及结构3. 二叉树顺序结构及概念4. 二叉树链式结构及实现 1. 树概念及结构 1.1树概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点。 除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的
数据结构-二叉树的链式存储
qq_45967533的博客
03-20 1万+
文章目录二叉树的链式结构链式结构的遍历二叉树链式存储的实现二叉树节点的创建前序遍历中序遍历后序遍历二叉树元素个数叶节点的个数第k层节点的个数查找元素二叉树销毁二叉树的层序遍历判断是否为完全二叉树 二叉树的链式结构 二叉树的存储结构有顺序结构和链式结构两种，顺序结构我已经在上篇进行了详细的讲解，地址：数据结构-二叉树的顺序存储与堆（堆排序），本篇我们就主要讲解二叉树的链式存储。 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右
数据结构 - 二叉树（C++）
了解➔熟悉➔掌握➔精通
02-26 5万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 二叉树的定义 二叉树（BinaryTree）是n（n&gt;=0）个结点的有限集，它或者是空集（n=0），或者由一个根结点及两棵互不相交的、分别称为这个根的左子树和右子树的二叉树组成。 二叉树的性质 性质1　二叉树第i层上的...
数据结构--二叉树遍历(详细过程)
m0_56283131的博客
04-21 3万+
详细到啰嗦的程度，完全0基础都可完成。
数据结构-二叉树的顺序存储
weixin_45599288的博客
09-13 3288
二叉树的顺序存储二叉树的概念及结构二叉树的性质顺序存储堆的初始化 二叉树的概念及结构 概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树 的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒。 现实中的二叉树 数据结构中的二叉树 3.特殊的二叉树 3.1满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-二叉树相关功能及算法
06-11
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树的应用广泛，涉及搜索、排序、编译器设计等多个领域。本主题将深入探讨...
数据结构-二叉树的广度优先遍历
08-23
// 定义二叉树的节点结构 typedef struct Node { int data; struct Node* left; struct Node* right; } Node; // 创建新节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); new...
数据结构-二叉树的基本操作
09-26
二叉树相关的完整代码
数据结构-二叉树的创建与遍历（链式存储结构）
11-13
二叉树作为数据结构中的重要概念，是用于表示有限数据集的一种方式，特别是链式存储结构。在这个主题中，我们将深入探讨如何创建二叉树以及如何遍历它们。 首先，我们来理解二叉树的基本概念。二叉树是由节点构成的...
C语言：刷题笔记
weixin_45930573的博客
09-04 413
c语言刷题记录
【C++】STL—vector的使用
2301_77112794的博客
09-04 705
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1250
vector的简单模拟实现！！！
C语言 | Leetcode C语言题解之第389题找不同
最新发布
m0_59237910的博客
09-07 498
C语言 | Leetcode C语言题解之第389题找不同
数据结构-二叉树结点计数方法解析
"这篇资料主要讨论了数据结构中的树，特别是二叉树的节点计数方法，以及相关术语和操作。由雷惊风主讲，涵盖了树的基本概念、二叉树的定义、性质、遍历等核心内容。" 在数据结构中，树是一种重要的抽象数据类型，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值