二叉链表C++实现

最新推荐文章于 2022-12-01 09:37:10 发布
最新推荐文章于 2022-12-01 09:37:10 发布
阅读量1.6k 收藏 8
点赞数 1
文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/candand_python/article/details/105426256
版权

二叉树节点类

template<typename T>
class BNode {//创建二叉树结点类
public:
	T data;//存储数据
	BNode<T>* leftchild, * rightchild;//创建该结点的左右孩子指针
	BNode(T mydata = T())://二叉树结点类初始化
		leftchild(nullptr), rightchild(nullptr),data(mydata){}
	friend int IsExistLf(BNode<T>* Node)//判断该结点是否有左孩子，如果有取出其数据
	{
		if (Node->leftchild == nullptr)
			return 0;
		cout << Node->leftchild->data << endl;
		return 1;
	}
	friend int IsExistRt(BNode<T>* Node)//判断该结点是否有左孩子，如果有取出其数据
	{
		if (Node->rightchild == nullptr)
			return 0;
		cout << Node->rightchild->data << endl;
		return 1;
	}
};

这里的IsExistRt函数仅仅是为了测试用，其余没什么用

二叉树类

template<typename T>
class BinaryTreeLinkedList
{
public:
	BinaryTreeLinkedList();
	BNode<T>* Creat(BNode<T>* root);//初始化一棵二叉树，其前序序列由键盘输入BinaryTreeLinkedList；
	BNode<T>* CreateTree(T* a, size_t n, const T& invalid, size_t& index);
	//BNode<T>* Create(BNode<T>* root);
	~BinaryTreeLinkedList();//析构函数，释放二叉链表中各结点的存储空间
	void SetRecursiveFlag(bool ret);//设置RecursiveFlag

	void PreOrder(BNode<T>* root);//前序遍历二叉树
    void InOrder(BNode<T>* root);//中序遍历二叉树
    void PostOrder(BNode<T>* root);//后序遍历二叉树
    void Levelorder(BNode<T>* root);//层序遍历二叉树
	int Depth(BNode<T>* root);//返回二叉树的深度
	int LeafNodeNum(BNode<T>* root);//返回二叉树叶子结点的个数
	int AllNodeNum(BNode<T>* root);//返回二叉树所有结点的个数
	
private:
	static int num;
	BNode<T>* root;//指向根结点的头指针
	bool RecursiveFlag;	//RecursiveFlag是指采用递归编写遍历，当为false时采用循环编写遍历	
	void Release(BNode<T>* root);//析构函数调用
	
};

这里的Creat函数与CreatTree函数均编写有问题，用该方法创建的子树仅会有根结点，并且根节点的左右节点会变成空。

BinaryTreeLinkedList<char> myBT;
BNode<char>* root = nullptr;
root = myBT.Creat(root);
cout << IsExistLf(root) << endl;
cout << IsExistRt(root) << endl;

测试图片

我在测试时无论cin采用一次性输完字符串还是一个一个输入字符，最后都发现，递归进去了（内存已经建立了）,但是各个有数据的结点没有指针关系，猜测Creat函数的问题，由于是cin输入数据，而我使用的模板是char型，不管怎么输入，系统都认为他是个字符串，地址一直没变过。

函数定义

#pragma once
#ifndef BINARYTREE_H
#define BINARYTREE_H
#include<iostream>
#include<stack>//用栈和循环模拟递归
#include<deque>
#include<algorithm>
using std::cout;
using std::cin;
using std::endl;
using std::stack;
using std::deque;


template<typename T>
class BNode {//创建二叉树结点类
public:
	T data;//存储数据
	BNode<T>* leftchild, * rightchild;//创建该结点的左右孩子指针
	BNode(T mydata = T())://二叉树结点类初始化
		leftchild(nullptr), rightchild(nullptr),data(mydata){}
	friend int IsExistLf(BNode<T>* Node)//判断该结点是否有左孩子，如果有取出其数据
	{
		if (Node->leftchild == nullptr)
			return 0;
		cout << Node->leftchild->data << endl;
		return 1;
	}
	friend int IsExistRt(BNode<T>* Node)//判断该结点是否有左孩子，如果有取出其数据
	{
		if (Node->rightchild == nullptr)
			return 0;
		cout << Node->rightchild->data << endl;
		return 1;
	}
};

template<typename T>
class BinaryTreeLinkedList
{
public:
	BinaryTreeLinkedList();
	BNode<T>* Creat(BNode<T>* root);//初始化一棵二叉树，其前序序列由键盘输入BinaryTreeLinkedList；
	BNode<T>* CreateTree(T* a, size_t n, const T& invalid, size_t& index);
	//BNode<T>* Create(BNode<T>* root);
	~BinaryTreeLinkedList();//析构函数，释放二叉链表中各结点的存储空间
	void SetRecursiveFlag(bool ret);//设置RecursiveFlag

	void PreOrder(BNode<T>* root);//前序遍历二叉树
    void InOrder(BNode<T>* root);//中序遍历二叉树
    void PostOrder(BNode<T>* root);//后序遍历二叉树
    void Levelorder(BNode<T>* root);//层序遍历二叉树
	int Depth(BNode<T>* root);//返回二叉树的深度
	int LeafNodeNum(BNode<T>* root);//返回二叉树叶子结点的个数
	int AllNodeNum(BNode<T>* root);//返回二叉树所有结点的个数
	
private:
	static int num;
	BNode<T>* root;//指向根结点的头指针
	bool RecursiveFlag;	//RecursiveFlag是指采用递归编写遍历，当为false时采用循环编写遍历	
	void Release(BNode<T>* root);//析构函数调用
	
};
template<typename T>
int BinaryTreeLinkedList<T>::num = 0;

template<typename T>
BinaryTreeLinkedList<T>::BinaryTreeLinkedList() :root(nullptr), RecursiveFlag(true)
{
}

//初始化一棵二叉树，其前序序列由键盘输入BinaryTreeLinkedList；
template<typename T>
BNode<T>* BinaryTreeLinkedList<T>::Creat(BNode<T>* root)
{
	char ch;
	//cin.get(ch);
	cin >> ch;
	//if (ch == '#')
	//	//root = nullptr;
	//else
	//{
	//	root = new BNode<T>(ch);
	//	//root->data = ch;
	//	cout << "数据为: " << root->data << "地址为: " << root << endl;
	//	Creat(root->leftchild);
	//	Creat(root->rightchild);
	//}
	if ((ch != '#'))
	{
		root = new BNode<T>(ch);
        cout << "数据为: " << root->data << "地址为: " << root << endl;
	    Creat(root->leftchild);
	    Creat(root->rightchild);		
	}	
	return root;
}

template<typename T>
BNode<T>* BinaryTreeLinkedList<T>::CreateTree(T* a, size_t n, const T& invalid, size_t& index)
{
	//BNode<T>* root = nullptr;
	if (a[index] != invalid)
	{
		root = new BNode<T>(a[index]);
		//root->data = a[index];
		cout << "数据为: " << root->data << "地址为: " << root << endl;
		root->leftchild = CreateTree(a, n, invalid, ++index);
		
		root->rightchild = CreateTree(a, n, invalid, ++index);
	}
	return root;
}



//析构函数，释放二叉链表中各结点的存储空间
template<typename T>
BinaryTreeLinkedList<T>::~BinaryTreeLinkedList()
{
	Release(root);
}

//设置RecursiveFlag
template<typename T>
void BinaryTreeLinkedList<T>::SetRecursiveFlag(bool ret)
{
	RecursiveFlag = ret;
}

//前序遍历二叉树
//若二叉树为空，则空操作返回，否则
//（1）访问根结点；
//（2）前序遍历根结点的左子树；
//（3）前序遍历根结点的右子树。
template<typename T>
void BinaryTreeLinkedList<T>::PreOrder(BNode<T>* root)
{
	if (RecursiveFlag)//采用递归遍历
	{
	if (!root)
		return;
	else
	{
		//++num;
		cout << root->data << "  ";
		PreOrder(root->leftchild);
		PreOrder(root->rightchild);
	}
	}
	else //采用栈和循环遍历
	{
		stack<BNode<T>*> mystack;//创建一个可以存储二叉树结点的栈
		if (root)
		{
			循环前的初始化
			//mystack.push(root);//将根结点压入栈中
			//cout << root->data << "  ";
			//root = root->leftchild;
			while (root || !mystack.empty())//当当前结点不为空或者栈不空都应执行循环
			{
				while (root)//如果此时该结点的左孩子不为空指针，那么要继续压栈
				{
					mystack.push(root);
					cout << root->data << "  ";//打印当前结点信息
					root = root->leftchild;
				}
				if (!mystack.empty())//此时该结点的左孩子为空指针，那么我们需要访问该结点的右孩子
				{
					root = mystack.top();//获取当前结点的指针
					root = root->rightchild;
					mystack.pop();//此结点的弹出，它的信息已经全部利用完了(左右孩子都访问了一遍所以他没有利用价值了)
				}
			}
		}
	}
}

//中序遍历二叉树
//若二叉树为空，则空操作返回，否则
//（1）中序遍历根结点的左子树；
//（2）访问根结点；
//（3）中序遍历根结点的右子树。
template<typename T>
void BinaryTreeLinkedList<T>::InOrder(BNode<T>* root)
{
	if (RecursiveFlag)//采用递归遍历
	{
		if (root)
		{
			PreOrder(root->leftchild);
			cout << root->data << "  ";
			PreOrder(root->rightchild);
		}
		else
			return;
	}
	else //采用栈和循环遍历
	{
		stack<BNode<T>*> mystack;//创建一个可以存储二叉树结点的栈
		if (root)
		{
			while (root || !mystack.empty())
			{
				while (root)//只进行压栈和结点向左伸展
				{
					mystack.push(root);
					root = root->leftchild;
				}
				if (!mystack.empty())//当左孩子为空时，需要打印该结点的信息，同时访问该结点的右孩子
				{
					root = mystack.top();//获取当前结点的指针
					cout << root->data << "  ";//打印当前最左侧结点的信息
					root = root->rightchild;
					mystack.pop();//出栈
				}
			}
			return;
		}
		return;
	}
}

//后序遍历二叉树
//若二叉树为空，则空操作返回，否则
//（1）后序遍历根结点的左子树；
//（2）后序遍历根结点的右子树；
//（3）问根结点。
template<typename T>
void BinaryTreeLinkedList<T>::PostOrder(BNode<T>* root)
{
	if (RecursiveFlag)//采用递归遍历
	{
		if (root)
		{
			PostOrder(root->leftchild);
			PostOrder(root->rightchild);
			cout << root->data << "  ";
		}
		else
			return;
	}
	else //采用循环遍历
	{
		//stack<BNode<T>*> mystack;//创建一个可以存储二叉树结点的栈
		//if (root)
		//{
		//	while (root || mystack.size() != 1)//当当前结点不为空或者栈不空都应执行循环
		//	{
		//		while (root)//如果此时该结点的左孩子不为空指针，那么要继续压栈
		//		{
		//			mystack.push(root);
		//			root = root->leftchild;
		//		}
		//		if (!mystack.empty())//此时该结点的左孩子为空指针，那么我们需要访问该结点的右孩子
		//		{
		//			if (mystack.size() != 1&&root->rightchild)
		//			{
		//				root = mystack.top();//获取当前结点的指针
		//				cout << root->data << "  ";//打印当前最左侧结点的信息
		//				root = root->rightchild;
		//				mystack.pop();//出栈
		//			}
		//			else//说明现在仅剩下根结点了
		//			{
		//				root = mystack.top();
		//				root = root->rightchild;
		//			}
		//		}
		//	}
		//	root = mystack.top();//访问最后一个结点根结点
		//	cout << root->data << "  ";
		//	mystack.pop();
		//	return;
		//}
		//return;
	}
}

//层序遍历二叉树
template<typename T>
void BinaryTreeLinkedList<T>::Levelorder(BNode<T>* root)
{
	deque<BNode<T>*> mydeque;
	if (root)
	{
		//循环起端初始化
		mydeque.push_back(root);
		while (!mydeque.empty())//当队列不空时要继续出队和入队，因为队列先进先出
		{
			root = mydeque.front();//取出队列队头元素
			cout << root->data << "  ";
			mydeque.pop_front();//出队
			if (root->leftchild) {
				mydeque.push_back(root->leftchild);
			}
			if (root->rightchild) {
				mydeque.push_back(root->rightchild);
			}
		}
	}
	return;
}


//返回二叉树的深度
template<typename T>
int BinaryTreeLinkedList<T>::Depth(BNode<T>* root)
{
	if (root) 
	{
		int dpt1 = Depth(root->leftchild);//获取当前结点的左子树深度
		int dpt2 = Depth(root->rightchild);//获取当前结点的右子树深度
		return (dpt1 > dpt2) ? (dpt1 + 1) : (dpt2 + 1);//仅选择当前最深的数值+基础值1，根结点默认深度为1
	}
	else
		return 0;
}

//返回二叉树叶子结点的个数
template<typename T>
int BinaryTreeLinkedList<T>::LeafNodeNum(BNode<T>* root)
{
	if (root == nullptr)
		return 0;
	else if (root->leftchild == nullptr && root->rightchild == nullptr)
		return 1;
	else
		return LeafNodeNum(root->leftchild) + LeafNodeNum(root->rightchild);
}

//返回二叉树所有结点的个数
template<typename T>
int BinaryTreeLinkedList<T>::AllNodeNum(BNode<T>* root)
{
	if (root == nullptr)
		return 0;
	else
		return AllNodeNum(root->leftchild) + AllNodeNum(root->rightchild) + 1;
}


//析构函数调用
template<typename T>
void BinaryTreeLinkedList<T>::Release(BNode<T>* root)
{
	if (root)//如果当前结点不为空时，则进入递归
	{
		Release(root->leftchild);//释放左子树
		Release(root->rightchild);//释放右子树
		delete root;
	}
	return;
}
#endif // !BINARYTREE_

测试部分

#include<iostream>
#include"binary_tree.h"

int main()
{
	BinaryTreeLinkedList<char> myBT;
	BNode<char>* root = new BNode<char>('A');//按照前序遍历创建节点
	root->leftchild= new BNode<char>('B');
	root->leftchild->rightchild = new BNode<char>('D');
	root->rightchild = new BNode<char>('C');
	cout << "树的深度为:" << myBT.Depth(root) << endl;
	cout << "树的叶子结点个数为:" << myBT.LeafNodeNum(root) << endl;
	cout << "树的所有结点个数为:" << myBT.AllNodeNum(root) << endl;
	//myBT.SetRecursiveFlag(false);
	cout << "递归前序遍历:" << endl;
	myBT.PreOrder(root);
	cout << endl;
	cout << "递归中序遍历:" << endl;
	myBT.InOrder(root);
	cout << endl;
	cout << "递归后序遍历:" << endl;
	myBT.PostOrder(root);
	cout << endl;
	cout << "层序遍历:" << endl;
	myBT.Levelorder(root);
	cout << endl;
	myBT.SetRecursiveFlag(false);
	cout << "栈与循环前序遍历:" << endl;
	myBT.PreOrder(root);
	//cout << endl;
	//cout << "栈与循环中序遍历:" << endl;
	//myBT.InOrder(root);
	//cout << endl;
	cout << endl;
	//size_t index = 0;
	//char x[9] = { 'A','B','#','D','#','#','C','#','#' };
	//root = myBT.CreateTree(x, sizeof(x) / sizeof(char), '#', index);
	//root = myBT.Creat(root);
	//cout << IsExistLf(root) << endl;
	//cout << IsExistRt(root) << endl;
}

测试结果

树的深度为:3
树的叶子结点个数为:2
树的所有结点个数为:4
递归前序遍历:
A  B  D  C
递归中序遍历:
B  D  A  C
递归后序遍历:
D  B  C  A
层序遍历:
A  B  C  D
栈与循环前序遍历:
A  B  D  C

 

由于我的创建子树函数有问题，测试时我自己手动创建的二叉树结点

未完成的任务

  1. 解决创建子树的问题
  2. 后序遍历循环做法错误，下次再编写

 

 

-Gentle-
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
遍历二叉树
Crystal_oscillator的专栏
03-12 613
<br />typedef struct BiTNode { TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; void CreateBiTree(BiTree &T) { TElemType temp; scanf("%d",&temp); if(temp==-1) T=NULL; else { T=new
二叉链表（孩子—兄弟）存储表示（代码实现）
weixin_62659979的博客
11-08 655
二叉链表（孩子—兄弟）存储表示（代码实现）
c++数据结构二叉树（二叉链表实现）基本操作实现
weixin_53144360的博客
11-11 5169
二叉树： 二叉树（Binarytree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 性质： 二叉树性质 性质1：二叉树的第i层上至多有2i-1（i≥1）个节点。 性质2：深度为h的二叉树中至多含有2h-1个节点。 性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2...
【数据结构】C++二叉树的实现（二叉链表），包括初始化，前序、中序、后序、层次遍历，计算节点数、叶子数、高度、宽度，二叉树的复制和销毁
standingflower的博客
12-01 3008
二叉树的实现（二叉链表），包括初始化，前序、中序、后续、层次遍历，计算节点数、叶子数、高度、宽度，二叉树的复制和销毁。
数据结构C++边学边做--二叉树的实现（二叉链表实现遍历操作）
qq_39400324的博客
02-12 3604
二叉树的实现（二叉链表实现遍历操作）一、二叉树的遍历二、二叉链表的数据结构定义三、二叉链表类实现1.类声明2.BiTree->构造函数：Create创建二叉链表3.~BiTree->析构函数：Release释放二叉链表4.PreOrder->前序遍历5.InOrder->中序遍历6.PostOrder->后序遍历7.LevelOrder->层序遍历四、二叉链表的测试1.主函数2.输出结果五、源代码获取（免积分） 一、二叉树的遍历   二叉树是一种重要的树状结构，因其结构相
二叉链表的应用c++代码_二叉链表c++代码_
09-30
文档“二叉链表的应用c++代码.doc”中可能包含具体的C++实现细节，包括如何构建和操作二叉链表。通过阅读并理解这段代码，你可以进一步巩固对二叉链表概念和C++编程的理解，并能将其应用于实际项目中。 总的来说，...
数据结构 二叉链表 C++实现.pdf
05-20
数据结构 二叉链表 C++ 实现 本文将详细介绍二叉链表的数据类型描述、链式存储结构的建立算法、基本运算的实现等知识点，并提供了 C++ 语言的实现代码。 数据类型描述 在计算机科学中，二叉树是一种特殊的树形...
二叉树的二叉链表实现
07-03
使用二叉链表实现二叉树，提供常见的操作：各种遍历，求树高，节点数。
C++实现树（二叉链表实现）
07-26
本文将深入探讨如何使用C++语言通过二叉链表实现树，以及树的一些基本操作和遍历方法。 首先，我们要了解什么是树。树是一种抽象的数据结构，它由节点（或称为顶点）和边组成，每个节点可以有零个或多个子节点。在...
基本操作实现树的二叉链表
05-17
在"看数据结构写代码（31） 树的二叉链表实现"这个文件中，应该包含了具体的C++、Java或Python代码示例，详细展示了如何构建二叉链表树结构，并进行上述三种遍历操作。这些代码通常会包括节点类定义、树的构造函数、...
c++建立二叉链表树以及哈夫曼树
04-20
理解二叉树线索化的实质是建立结点与其在相应序列中的前驱或后继之间的直接联系。二叉树的线索化过程是基于对二叉树进行遍历，而线索二叉树上的线索又为相应的遍历提供了方便
C++二叉树（二叉链表实现）
07-24
二叉树的建立、遍历、复制、交换左右等等常见功能
C/C++数据结构（九） —— 链式二叉树
Edison's 小宇宙
11-05 2265
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如双亲与孩子的关系，左右兄弟的关系等。
二叉树链表C++实现
jiaxiaoye2005的专栏
01-23 3145
（1）用递归方法创建二叉链表 （2）用递归算法对二叉树进行先序遍历，中序遍历和后序遍历，并输出遍历结果 （3）对二叉树进行层次遍历，并输出遍历序列 （4）求二叉树的深度并输出 #include //头文件 #include #include typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild;
数据结构-实验二  树和二叉树的实现
brandong
09-26 6203
 广州大学学生实验报告 开课实验室：计算机科学与工程实验（电子楼417）     2018年05月16日 学院 计算机科学与教育软件学院 年级、专业、班 网络161 姓名 卟咚君 学号 1606100*** 实验课...
二叉树的遍历（先序、中序、后序和层次遍历）
DX奥特曼的博客
12-29 3万+
采用二叉链表结构实现二叉树，并以递归遍历思想实现二叉树的创建、二叉树的遍历（先序、中序、后序和层次遍历）、二叉树叶子节点统计、二叉树深度统计的算法；同时，结合课件和实例代码，实现二叉树的中序非递归遍历算法。存储结构和操作接口定义如下: /*①二叉树的二叉链表存储结构定义*/ typedef struct BiTNode { ElemType data; struct BiTNode *l
二叉树的层次遍历
fandoudou123的专栏
09-23 466
层次遍历： a.访问根节点 b.从左到右访问第2层的所有节点 c.从左到右访问第3层的所有节点，。。。。 package pac1; public class Demo22 { /** * @param args * 层次遍历二叉树 */ public static void main(String[] args) { // TODO Auto-ge
C语言二叉树创建（一定看的懂）
热门推荐
TheSevenSky
06-02 8万+
  先贴一个百度出来的二叉树的图 二叉树 就是首先得有一个根节点.这个节点的入度为0也就是它只有子节点没有父节点 如1号节点     每个节点又有一个左儿子和一个右儿子 当然也可以没有 接下来就是创建.创建一棵树得现有这棵树的结点和树根     首先来声明一个树的结点   typedef struct node{ //树的结点 int data; struct no...
建立二叉树的二叉链表c++
最新发布
07-30
建立二叉树的二叉链表可以通过递归的方式实现。根据引用[2]中的代码，可以使用Create_BiTree函数来建立二叉树的二叉链表。该函数首先读取一个字符，如果是字母，则创建一个新的节点，并将该字符赋值给节点的val属性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值