数据结构之链表二叉树实现

最新推荐文章于 2024-02-21 05:14:32 发布
最新推荐文章于 2024-02-21 05:14:32 发布
阅读量823 收藏 15
点赞数 4
分类专栏： 数据结构 文章标签： 链表二叉树 数据结构 DB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34767784/article/details/95781059
版权

文章目录

数据结构之链表二叉树实现

代码及思想

//链式二叉树
/*参考 
https://www.cnblogs.com/liuzeyu12a/p/10420665.html
https://blog.csdn.net/weixin_40411915/article/details/82808227
测试数据：abd###c#e##
*/ 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

typedef char ElemType;
typedef int Status; 
#define OK 1
#define ERROR 0

/***************结构体定义***************/
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

/***************函数定义***************/
void InitBiTree(BiTree &T);//二叉树初始化
void CreateBiTree(BiTree &T);//创建二叉树
bool BiTreeEmpty(BiTree &T);//判断二叉树是否为空
int BiTreeDepth1(BiTree &T);//求树的深度
int BiTreeDepth2(BiTree &T);//求树的深度
void Visit(ElemType e);//打印某一结点
void PreOrderTraverse(BiTree &T);//二叉树递归先序遍历 
void InOrderTraverse(BiTree &T);//二叉树递归中序遍历
void PostOrderTraverse(BiTree &T);//二叉树递归后序遍历
int CountLeaf1(BiTree &T,int &count1);//计算叶子结点数
int CountLeaf2(BiTree &T);//计算叶子结点数
int CountNode(BiTree T);//计算结点数 
int max(int a,int b);//返回较大值
ElemType Parent(BiTree &T,ElemType e);//求父节点的值
BiTree FindNode(BiTree &T,ElemType e);//寻找某个结点，返回指向这个节点的指针
void LeftSibling(BiTree &T,ElemType e);//输出某个结点的左兄弟
void RightSibling(BiTree &T,ElemType e);//输出某个结点的右兄弟 
 
Status levelTraverse(BiTree T);//二叉树层次遍历
Status preOrderTraverseEX(BiTree T);//先序遍历非递归
Status InOrderTraverseEX(BiTree T);//中序遍历非递归
Status PostOrderTraverseEX(BiTree T);//后序遍历非递归
Status DestroyBiTree(BiTree T);//二叉树销毁 
//https://blog.csdn.net/weixin_40411915/article/details/82808227

//https://blog.csdn.net/baidu_38304645/article/details/82964439
Status ExchangeBiTree(BiTree &T); //将树各节点的左右孩子互换
Status DeleteChild(BiTree &T,ElemType x);//删除根结点值为x的子树

/***************函数实现***************/
void InitBiTree(BiTree &T)//二叉树初始化
{
	T = (BiTNode *)malloc(sizeof(BiTNode));//malloc()的返回值可以强制类型转换
	T -> lchild = NULL;
	T -> rchild = NULL;
}
/* 
void CreateBiTree(BiTree *T)//递归创建二叉树 
{
	ElemType ch;
	scanf("%c",&ch);
	if(ch == '#')
		*T = NULL;
	else
	{
		cout<<"126511"<<endl;
		*T = (BiTree )malloc(sizeof(BiTNode));//创建新结点加入树 
		if(!T) return;	
		(*T)->data = ch;
		CreateBiTree(&(*T)->lchild);
		CreateBiTree(&(*T)->rchild);
	}
}
*/

void CreateBiTree(BiTree &T)//递归创建二叉树 
{
	ElemType ch;
	scanf("%c",&ch);
	if(ch == '#')
		T = NULL;
	else
	{
		T = (BiTNode *)malloc(sizeof(BiTNode));//创建新结点加入树 
	//	if(!T) return;	
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}


bool BiTreeEmpty(BiTree &T)//判断二叉树是否为空
{
	if(T)
		return false;
	return true;
}

int BiTreeDepth1(BiTree &T)//求树的深度
{
	int lDepth,rDepth;
	if(BiTreeEmpty(T))
		return ERROR;
	if(T->lchild)
		lDepth = BiTreeDepth1(T->lchild);
	else
		lDepth = 0;
	if(T->rchild)
		rDepth = BiTreeDepth1(T->rchild);
	else
		rDepth = 0;
	return lDepth > rDepth ? lDepth+1 : rDepth+1;//二叉树深度为左右子树深度较大值加1 
}

int BiTreeDepth2(BiTree &T)//求树的深度
{
	int lDepth,rDepth;
	if(T == NULL)
		return 0;
	else
		return max(BiTreeDepth2(T->lchild),BiTreeDepth2(T->rchild))+1;//二叉树深度为左右子树深度较大值加1 
}

void Visit(ElemType e)//打印某一结点
{
	cout<<e<<" ";
}

void PreOrderTraverse(BiTree &T)//二叉树递归先序遍历
{
	if(T)
	{
		Visit(T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);	
	} 
} 

void InOrderTraverse(BiTree &T)//二叉树递归中序遍历
{
	if(T)
	{
		InOrderTraverse(T->lchild);
		Visit(T->data);
		InOrderTraverse(T->rchild);
	}
}

void PostOrderTraverse(BiTree &T)//二叉树递归后序遍历
{
	if(T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		Visit(T->data);
	}
}

int CountLeaf1(BiTree &T,int &count1)//计算叶子结点数
{
	if(T)
	{
		if((T->lchild == NULL) && (T->rchild == NULL))//判断是否为叶子结点 
		{
			count1++;	
		}	
		CountLeaf1(T->lchild,count1);
		CountLeaf1(T->rchild,count1);
	}	
	return count1;
}

int CountLeaf2(BiTree &T)//计算叶子结点数
{
	if(T == NULL)
		return 0;
	if(T->lchild == NULL && T->rchild == NULL)
		return 1;
	else
	{
		return CountLeaf2(T->lchild)+CountLeaf2(T->rchild);
	}
}

int CountNode(BiTree T)//计算结点数
{
	if(T == NULL)
		return 0;
	return CountNode(T->lchild)+CountNode(T->rchild)+1;
}

int max(int a,int b)//返回较大值
{
	return a > b ? a : b;	
}

ElemType Parent(BiTree &T,ElemType e)//求父节点的值
{
	if(T)
	{
		if( T->lchild && (T->lchild->data == e) || T->rchild && (T->rchild->data == e) )
			return T->data;
		else
		{
			Parent(T->lchild,e);
			Parent(T->rchild,e);
		}
	}
	return ' ';//失败返回空字符 
}

BiTree FindNode(BiTree &T,ElemType e)//寻找某个结点，返回指向这个节点的指针
{
	if(T == NULL)
		return NULL;
	if(T->data == e)
		return T;
	BiTree node = FindNode(T->lchild,e);
	if(node != NULL)
		return node;
	else
		return FindNode(T->rchild,e);
}

void LeftSibling(BiTree &T,ElemType e)//输出某个结点的左兄弟
{
	ElemType ch = Parent(T,e);//找到父节点
	BiTree temp = FindNode(T,ch);
	if(temp->lchild != NULL)
	{
		if(temp->lchild->data != e)
		{
			cout<<"此节点的左兄弟为："<<temp->lchild->data<<endl;	
		}	
		else
		{
			cout<<"此节点没有左兄弟"<<endl;
		}
	} 
}

void RightSibling(BiTree &T,ElemType e)//输出某个结点的右兄弟
{
	ElemType ch = Parent(T,e);
	BiTree temp = FindNode(T,ch);
	if(temp->rchild != NULL)
	{
		if(temp->rchild->data != e)
		{
			cout<<"此节点的右兄弟为："<<temp->rchild->data<<endl;
		}
		else
		{
			cout<<"此节点没有右兄弟"<<endl;
		}
	}	
} 

typedef struct 
{
	ElemType data[100];//数据基址
	int front,rear;//队头队尾指针；
	int length;//当前分配的容量 
}Tqueue;

Status levelTraverse(BiTree T)//二叉树层次遍历，队列 
{
	BiTree Tqueue[100];
	BiTNode *p = NULL;
	int front=0,rear=0;
	if(T)
	{
		rear = (rear + 1) % 100;
		Tqueue[rear] = T;
		printf("%c",p->data);
		if(p->lchild)
		{
			rear = (rear + 1)%100;
			Tqueue[rear] = p->lchild;
		}
		if(p->rchild)
		{
			rear = (rear + 1) % 100;
			Tqueue[rear] = p->rchild;
		}
	}
	return 1;
}

Status preOrderTraverseEX(BiTree T)//先序遍历非递归
{
	BiTree arr[100];
	BiTNode *temp = NULL;
	int len = 0;
	if(T)
	{
		arr[len] = T;
		len++;
		while(len != 0)
		{
			temp = arr[len - 1];
			while(temp)
			{
				printf("%c\n",temp->data);
				arr[len] = temp->lchild;
				len++;
				temp = arr[len-1];
			}
			temp = arr[len-1];
			len--;
			if(len != 0)
			{
				temp = arr[len - 1];
				len--;
				arr[len] = temp->rchild;
				len++;
			}
		}
		return 1;
	}
	return 0;
}

Status InOrderTraverseEX(BiTree T)//中序遍历非递归
{
	BiTree arr[100];
	BiTNode* temp = NULL;
	int len = 0;
	if (T)
	{
		arr[len] = T;
		len++;
		while (len!=0)
		{
			temp = arr[len - 1];
			while (temp)
			{
				arr[len] = temp->lchild;
				len++;
				temp = arr[len - 1];
			}
			temp = arr[len - 1];
			len--;
			if (len!=0)
			{
				temp = arr[len - 1];
				len--;
				printf("%c\n", temp->data);
				arr[len] = temp->rchild;
				len++;
			}
		}
		return 1;
	}
	return 0;
}

Status PostOrderTraverseEX(BiTree T)//后序遍历非递归
{
	BiTree arr[100];
	BiTNode* pre = NULL,* temp = T;
	int len = 0;
	if (temp)
	{
		while (temp || !(len == 0))
		{
			while (temp)
			{
				arr[len] = temp;
				len++;
				temp = temp->lchild;
			}
			if (!(len == 0))
			{
				temp = arr[len - 1];
				if (temp->rchild != NULL && temp->rchild != pre) // 右节点存在且没有被访问过
				{
					arr[len] = temp;
					temp = temp->rchild;
				}
				else
				{
					printf("%c\n", temp->data);
					pre = temp;
					temp = NULL;
				}
			}
		}
		return 1;
	}
	return 0;
}

Status DestroyBiTree(BiTree T)//二叉树递归销毁
{
	BiTNode *TL = NULL,*TR = NULL;
	if(T == NULL)
		return 0;
	TL = T->lchild;
	TR = T->rchild;
	T->lchild = NULL;
	T->rchild = NULL;
	free(T);
	T = NULL;
	DestroyBiTree(TL);
	DestroyBiTree(TR);
	return OK;
} 


Status ExchangeBiTree(BiTree &T){
//blog.csdn.net/baidu_38304645/article/details/82964439 
    //将树各节点的左右孩子互换
    BiTNode * temp;
    if(T){//如果树存在 交换左右孩子
         temp=T->lchild;
	 T->lchild=T->rchild;
	 T->rchild=temp;
	 ExchangeBiTree(T->lchild);//递归左子树 互换左右孩子
	 ExchangeBiTree(T->rchild);//递归右子树 互换左右孩子
    }
    return OK;
}


/*
void InitBiTree(BiTree &T);//二叉树初始化
void CreateBiTree(BiTree &T);//创建二叉树
bool BiTreeEmpty(BiTree &T);//判断二叉树是否为空
int BiTreeDepth(BiTree &T);//求树的深度
void Visit(ElemType e);//打印某一结点
void PreOrderTraverse(BiTree &T);//二叉树递归先序遍历 
void InOrderTraverse(BiTree &T);//二叉树递归中序遍历
void PostOrderTraverse(BiTree &T);//二叉树递归后序遍历
int CountLeaf1(BiTree &T);//计算叶子结点数
int CountLeaf2(BiTree &T);//计算叶子结点数
int CountNode(BiTree T);//计算结点数 
int max(int a,int b);//返回较大值
ElemType Parent(BiTree &T,ElemType e);//求父节点的值
BiTree FindNode(BiTree &T,ElemType e);//寻找某个结点，返回指向这个节点的指针
void LeftSibling(BiTree &T,ElemType e);//输出某个结点的左兄弟
void RightSibling(BiTree &T,ElemType e);//输出某个结点的右兄弟 

Status levelTraverse(BiTree T);//二叉树层次遍历
Status preOrderTraverseEX(BiTree T);//先序遍历非递归
Status InOrderTraverseEX(BiTree T);//中序遍历非递归
Status PostOrderTraverseEX(BiTree T);//后序遍历非递归
Status DestroyBiTree(BiTree T);//二叉树销毁 
*/ 

/***************主函数测试***************/
int main()
{
	BiTree T;
	char B='b',C='c';
	int count1=0,count2=0; 
	
	InitBiTree(T);
	cout<<"请输入二叉树初始化数据，'#'为空结点"<<endl; 
	CreateBiTree(T);
	
	cout<<"*前序遍历为："<<endl;
	PreOrderTraverse(T); 
	cout<<endl;
	
	cout<<"*中序遍历为："<<endl;
	InOrderTraverse(T);
	cout<<endl;
	
	cout<<"*后序遍历为："<<endl;
	PostOrderTraverse(T);
	cout<<endl;
	
	cout<<"#树的高度为(法一、法二)："<<BiTreeDepth1(T)<<" "<<BiTreeDepth2(T)<<endl;
	cout<<"#树的叶子结点个数为(法一、法二)："<<CountLeaf1(T,count1)<<" "<<CountLeaf2(T)<<endl;
	cout<<"#树的结点个数为："<<CountNode(T)<<endl;
	cout<<"#元素'b'的父亲结点为："<<Parent(T,B)<<endl;
	cout<<"#元素'b'的右兄弟结点为："<<endl;
	RightSibling(T,B);
	cout<<"#元素'c'的左兄弟结点为："<<endl;
	LeftSibling(T,C);
	cout<<"#元素'c'的右兄弟结点为："<<endl;
	RightSibling(T,C);
	
	DestroyBiTree(T);
	
	return 0;
}

测试截图

在这里插入图片描述

李霁明
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之二叉树链表
followMyInclinations的专栏
10-22 4404
2.二叉树      二叉树是n个结点的有限集合，该集合或者为空集（称为空二叉树），或者有一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成      特点：           ①每个结点最多有两棵子树，所以二叉树中不存在度 大于2的结点           ②左子树和右子树是有顺序的，次序不能任意颠倒           ③即使树中某结点只有一棵子树，也要区分
数据结构之双向链表、二叉树
莫慌 吃口药
10-02 338
package exam; /** * 定义双向链表 * 1.头、尾节点、链表长度 * 2.自定义节点Node，属性前指针、后指针、内容（preNode、nextNode、ele） * 3.节点前、节点后添加元素方法； 节点删除方法； 重写输出链表方法toString * */ public class MyLinkedList{ private M...
二叉树——从建立到销毁
m0_68416190的博客
11-25 1875
二叉树建立、遍历、搜索、销毁。
【数据结构】二叉树的销毁 & 二叉树系列所有源代码（终章）
m0_71676870的博客
09-26 2252
数据结构】二叉树的销毁 & 二叉树系列所有源代码（终章） 一，二叉树的销毁 二，二叉树系列所有源代码 BTee.h BTee.c Queue.h Queue.c
二叉树的创建销毁和如何层序遍历
学代码的咸鱼的博客
05-22 802
大家好！前面的二叉树的学习，我们都是先手动构建二叉树的，这篇就说一下如何真正的去构建一棵二叉树。而且，我还会说一下前面没有说的一种遍历方式：层序遍历。 如何层序遍历 我们要进行层序遍历，要借助一个数据结构——队列。 思路： 1.先把根入队列，借助队列先进先出的性质。 2.上一层节点出的时候，带下一层的节点进去。 下面，我举个例子： 首先，我将1放到队列中： 我们看队列不为空，我们将1取出来，然后把它的孩子2和4带进去。 我们看队列不为空，我们将2取出来，然后把它的孩子3带进去，NULL就不进去了。
吐血整理 二叉树(链表实现)的基本操作详解！
weixin_62976968的博客
05-31 2973
本文是对二叉树这种数据结构基本操作与部分练习题的总结，内容庞大、详细、易懂，是你学习路上不容错过的优质博客！
链表与二叉树
weixin_43454088的博客
05-01 1152
文章目录链表概述数组和链表的区别：链表的分类二叉树概述二叉树的种类1、斜树2、满二叉树3、完全二叉树二叉树的性质（⭐）二叉树的遍历方式 链表 概述 链表（Linked List）是由一组不必相连（可以连续也可以不连续）的内存结构（节点），按特定的顺序链接在一起的抽象数据类型。 数组和链表的区别： 数组： 数组是一种连续存储线性结构、元素类型相同，大小相等 数组的优点： 存取速快 数组的缺点： 事先必须知道数组的长度 插入和删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
数据结构之二叉树链表.rar
12-11
本项目“数据结构之二叉树链表”着重探讨了如何在C++环境中实现链表形式的二叉树，以及相关的操作。 二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。在数组存储的二叉树中，...
C语言数据结构旋转链表的实现
08-29
链表作为基本的数据结构之一，有着广泛的应用。本篇将深入探讨如何实现链表的旋转操作，特别是针对单向链表的右旋操作。 首先，我们要理解链表的基本概念。链表是由一系列节点构成的，每个节点包含数据和指向下一个...
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
20 二叉树：销毁
Ultravioletrays的博客
05-01 1483
20二叉树：销毁 作者:冯向阳时间限制:1S章节:DS:树 截止日期:2022-06-30 23:55:00 问题描述 : 目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树A...
二叉树（6）——二叉树的创建和销毁
最新发布
linxiaogua123的博客
02-21 509
本节讲解二叉树的创建和销毁以及判断二叉树是否是完全二叉树。
链表实现二叉树
qq_73881574的博客
04-06 1069
如果子树为空 返回0 不为空返回1。执行逻辑：判断左右子树中高度大的那颗，在此基础上加上自身返回上一级。执行逻辑：统计左右子树叶子的个数 加上自身 返回上一级。将一层的节点全部遍历完了以后再遍历下一层。递归的算法：当根为NULL时，开始返回。执行逻辑：将NULL也push进队列。返回条件：子树为空 或者找到目标值。执行逻辑：即找k-1层子树的个数。返回条件：走到目标层（k==1）执行逻辑：先寻找所有的左子树。是层层返回的 而不是一下返回。出谁，将谁的子树全部带入。返回条件： 为空返回0。
数据结构：二叉树的链式结构
Yikefore的博客
06-03 5551
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
链表实现 二叉树
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-30 2103
链表实现二叉树
数据结构(12)--二叉树的静态链表存储和遍历的实现
热门推荐
小白的专栏
02-29 1万+
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.二叉树的定义 二叉树(Binary Tree)是结点的有限集合，这个集合或者是空，或者是由一个根结点和两棵互不相交的称为左子树和右子树的二叉树构成。 以上对二叉树的定义也是一种递归的方式，二叉树...
数据结构之顺序队列实现
李霁明的博客
06-25 1286
文章目录数据结构之循环队列实现代码及思想测试截图 数据结构之循环队列实现 代码及思想 #include <iostream> #include <cstdio> #include <cstdlib> using namespace std; #define MAXSIZE 7//初始分配量 #define INCREASE 10//分配增量 #define ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李霁明

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值