二叉树链式描述和二叉排序树实现（C++类模板）

最新推荐文章于 2023-04-14 22:21:55 发布
最新推荐文章于 2023-04-14 22:21:55 发布
阅读量681 收藏 4
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43290168/article/details/114757750
版权

二叉树链式描述和二叉排序树实现

二叉树链式描述

二叉树链式描述可以根据定义指针域数量的不同分为二叉链表表示和三叉链表表示。
1.二叉链表表示
每个结点包括数据域和指针域，指针域分别为leftchild指向左孩子和rightchild指向右孩子，也就意味着双亲结点有指向孩子结点的指针，但是孩子结点不包含指向双亲结点的指针。数据域用以存放结点中元素值。
二叉链表表示在这里插入图片描述
2.三叉链表表示
每个结点的指针域分别为leftchild指向左孩子和rightchild指向右孩子和parent指向双亲结点，也就意味着双亲结点有指向孩子结点的指针，孩子结点也包含指向双亲结点的指针。根节点没有双亲结点。所以它的parent指针为空（NULL）。
在这里插入图片描述

二叉链表实现

方法主要包括：
1.简单构造函数（有参、无参）

2.判断二叉树是否为空
思路：初始根结点如果为空，则二叉树为空。

3.按照指定元素创建根结点
思路：先判断根结点是否为空，为空则直接将指定元素值赋值给根结点的数据域，否则new一个新节结点，并以指定元素作为该结点的数据域。

4.获取根结点

5.将一个结点作为指定节点的左、右孩子插入二叉树
思路：首先定义局部指针变量，创建新结点，将将指定节点指向左孩子（右孩子）的指针指向新节点。

6.修改、获取指定结点的元素值

7.获取指定节点的左、右孩子

8.递归中序、先序、后序遍历二叉树
思路：先序：根左右；中序：左根右；后序：左右根。

9.逐层遍历
思路：先从根结点开始（从第一层开始遍历），同一层中，自左向右遍历。通常采用队列实现遍历算法。首先将根结点插入队列，接着循环遍历，当队列不为空时，先将队首元素出队，访问其元素数据，紧接着判断是否存在左孩子，若存在，将左孩子结点插入队列；然后判断是否存在右孩子，若存在，将右孩子结点插入队列。以此循环，直到队列为空停止遍历。

10.非递归遍历（待续）

11.按非递归方式获取指定结点的双亲结点
思路：首先将根结点插入队列，接着循环遍历，当队列不空时，将队首结点出队作为当前指定结点，如果当前结点的左孩子或右孩子等于指定结点，则返回该结点，即为该指定结点的双亲结点。否则继续向下层寻找当前节点的左孩子、右孩子，直至队列为空。

12.删除以指定结点为根的子树
思路：首先定义一个结点指针并置空（用来存储双亲结点），判断指定结点是否为根结点，若为根结点，直接置空（实现逻辑上删除子树），如果指定结点不为根结点，则需要寻找指定结点的双亲结点，接着删除其左子树或右子树。若要在物理上真正实现删除子树，还需将结点内存进行释放。

13.按关键字查找结点
思路：根据指定元素进行查找，将根结点插入队列，利用循环方式查找，将队首元素出队，判断该元素是否与指定关键字相等，若相等，返回该结点。如果该结点有左孩子或右孩子，将左孩子、右孩子插入队列继续循环，直到队列为空完成查找。

14.将元素插入二叉排序树

二叉排序树定义：

根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。在这里插入图片描述
思路：首先判断二叉排序树是否为空，为空则以指定元素创建根结点；若不为空，则先获取根结点及根结点元素，如果指定元素等于根结点元素，意味着该元素已经存在于树中（假定树中不能有重复元素），如果该元素值小于根结点元素值，（则需要将该元素插入进该根结点的左子树中），当然如果左子树存在，意味着没办法继续插入新元素，这时候需要继续寻找新的位置；若大于，插入进右子树中（同左子树情形）。

15.生成二叉排序树
思路：将数组中的元素依次插入到二叉排序树中，调用14方法。

16.递归方式实现查找二叉排序树
思路：先获取给定结点的元素值并赋值给X，将给定元素值K与X后进行比较，若K=X，则查找成功；若K<X,则在给定结点的左子树中继续寻找（利用递归调用进行），若K>X,则在给定结点的左子树中继续寻找，直到结束。

代码

bintree.h

#include<string>
#include"linkqueue.h"
using namespace std;

template < class T >
class linkednode
{
	template <class T>
	friend class linkedbintree;
public:
	//无参构造
	linkednode()
	{
		m_pleftchild = m_prightchild = NULL;
	}
	//有参   
	linkednode(const T&x)
	{
		m_pleftchild = m_prightchild = NULL;
		m_data = x;
	}
private:
	T m_data;
	linkednode<T>*m_pleftchild, *m_prightchild;

};
template<class T>
class linkedbintree
{
public:
	linkedbintree();
	~linkedbintree();
	bool isempty();
	linkednode<T>*creatroot(const T&x);
	void clear();
	linkednode<T>*getroot();
	//将一个节点作为指定节点的左孩子插入
	linkednode<T>*insertleftchild(linkednode<T>*pnode, const T&x);
	//将一个节点作为指定节点的右孩子插入
	linkednode<T>*insertrightchild(linkednode<T>*pnode, const T&x);
	//修改指定节点的元素值
	bool modifynodevalue(linkednode<T>*pnode, const T&x);
	//获取指定节点的元素值
	bool getnodevalue(linkednode<T>*pnode,  T&x);
	linkednode<T>*getrightchild(linkednode<T>*pnode);
	linkednode<T>*getleftchild(linkednode<T>*pnode);

	//递归先序遍历
	void preorder(linkednode<T>*pnode);
	//中序
	void inorder(linkednode<T>*pnode);
	//后序
	void postorder(linkednode<T>*pnode);

	//非递归先序
	void preorder();
	//中序
	void inorder();
	//后序
	void postorder();

	//逐层遍历
	void levelorder();

	//按非递归方式获取指定节点的双亲结点
	linkednode<T>*getparent(linkednode<T>*pnode);
	//删除以指定节点为根的子树
	void deletetree(linkednode<T>*pnode);
	//由deletetree函数调用删除以指定节点为根的子树
	void deletetreenode(linkednode<T>*pnode);
	//按关键字查找节点
	linkednode<T>*searchbykey(const T &x);

	//将元素插入二叉排序树
	void insertBST(linkedbintree<T>&btree, T K);
	//生成二叉排序树
	void creatBST(T R[], int size, linkedbintree<T>&btree);
	//递归方式实现查找二叉排序树
	linkednode<T>*searchBST(linkednode<T>*proot, T K);
private:
	linkednode<T>*m_proot;
};

顺便提供队列链表描述代码：
linkqueue.h

#include<string>
#include<iostream>
using namespace std;

template < class T >
class linknode
{
template<class T>
friend class linkqueue;
public:
	linknode()
	{
		next = NULL;
	}
private:
	T data;
	linknode<T>* next;
};
template < class T >
class linkqueue
{
public:
	linkqueue();
	~linkqueue();
	bool isempty();
	bool isfull();
	bool insert(const T & x);
	bool getelement(T & x);
	bool Delete(T &x);
	void output(ostream &out)const;
private:
	int  size;
	linknode<T>*front, *back;
};
//构造函数
template <class T>
linkqueue<T>::linkqueue()
{
	front = NULL;
	back = NULL;
	size = 0;
}
//析构函数
template <class T>
linkqueue<T>::~linkqueue()
{
	T x;
	while (front != NULL)//当队列不为空时 删除队首元素
		Delete(x);
}
//判断队列是否为空  为空则返回大小为0
template <class T>
bool linkqueue<T>::isempty()
{
	return size == 0;
}
//插入元素   队尾插入
template <class T>
bool linkqueue<T>::insert(const T&x)
{
	//new出新的节点 用P接收
	linknode<T>*p = new  linknode < T > ;
	//如果p为空，返回错误
	if (p == NULL)
	{
		return false;
	}
	//如果不为空 
	else
	{
		//向p中插入数据
		p->data = x;
		//判断当前队列是否为空，为空则插入元素既是队尾又是队首
		if (front == NULL)
		{
			back = p;
			front = p;
		}
		//当前不为空，  队尾更新为p
		else
		{
			back->next = p;
			back = p;
		}
		size++;
		return true;
	}
}
//获取元素
template <class T>
bool linkqueue<T>::getelement(T&x)
{
	if (isempty())
	{
		return false;
	}
	else
	{
		//首部的值赋给X
		x = front->data;
		return true;
	}
}
//删除元素
template<class  T>
bool linkqueue<T>::Delete(T &x)
{
	//创建节点p 
	linknode<T>*p;
	if (isempty())
	{
		return false;
	}
	else
	{   //p指向front  front值赋给x  front指向下一节点
		p = front;
		x = front->data;
		front = front->next;
		delete(p);
		size--;
		return true;
	}
}
//输出队列
template<class  T>
void linkqueue<T>::output(ostream &out)const
{
	linknode<T>*p;
	p = front;
	for (int i = 0; i < size; i++)
	{
		cout << p->data << endl;
		p=p->next;
	}
}
//重载运算符
template<class T>
ostream &operator<<(ostream& out, const linkqueue<T>&x)
{
	x.output(out);
	return out;
};

测试：
bintree.cpp

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



template <class T>
linkedbintree<T>::linkedbintree()
{
	m_proot = NULL;
}

template <class T>
linkednode<T>*linkedbintree<T>::creatroot(const T&x)
{
	if (m_proot != NULL)
	{
		m_proot->m_data = x;
	}
	else
	{
		m_proot = new linkednode<T>(x);
	}
	return m_proot;
}
template <class T>
bool linkedbintree<T>::isempty()
{
	if (m_proot == NULL)
	{
		return true;
	}
	return false;
}
template <class T>
linkednode<T>*linkedbintree<T>::getroot()
{
	return m_proot;
}
//将一个节点作为指定节点的左孩子插入
template <class T>
linkednode<T>*linkedbintree<T>::insertleftchild(linkednode<T>*pnode, const T&x)
{
	//局部指针  
	linkednode<T> *pnewnode;
	//参数1为空 没有节点
	if (pnode == NULL)
	{
		return NULL;
	}
	// 创建新节点，参数x作为新节点的data域
	pnewnode = new linkednode<T>(x);
	// 节点为空。。。创建失败
	if (pnewnode == NULL)
	{
		return NULL;
	}
	//将指定节点指向左孩子的指针 指向新节点
	pnode->m_pleftchild = pnewnode;
	return pnewnode;
}
//将一个节点作为指定节点的右孩子插入
template <class T>
linkednode<T>*linkedbintree<T>::insertrightchild(linkednode<T>*pnode, const T&x)
{
	//局部指针  
	linkednode<T> *pnewnode;
	//参数1为空 没有节点
	if (pnode == NULL)
	{
		return NULL;
	}
	// 创建新节点，参数x作为新节点的data域
	pnewnode = new linkednode<T>(x);
	// 节点为空。。。创建失败
	if (pnewnode == NULL)
	{
		return NULL;
	}
	//新节点指向左孩子的指针 指向新节点
	pnode->m_prightchild = pnewnode;
	return pnewnode;
}
//修改指定节点的元素值
template <class T>
bool linkedbintree<T>::modifynodevalue(linkednode<T>*pnode, const T&x)
{
	if (pnode == NULL)
	{
		return false;
	}
	pnode->m_data = x;
	return true;
}
//获取指定节点的元素值
template <class T>
bool linkedbintree<T>::getnodevalue(linkednode<T>*pnode, T&x)
{
	if (pnode == NULL)
	{
		return false;
	}
	x = pnode->m_data;
	return true;
}
//获取指定节点的左孩子节点
template <class T>
linkednode<T>*linkedbintree<T>::getleftchild(linkednode<T>*pnode)
{
	if (pnode == NULL)
	{
		return NULL;
	}
	return pnode->m_pleftchild;
}
//获取指定节点的右孩子节点
template <class T>
linkednode<T>*linkedbintree<T>::getrightchild(linkednode<T>*pnode)
{
	if (pnode == NULL)
	{
		return NULL;
	}
	return pnode->m_prightchild;
}


//递归先序遍历
template <class T>
void linkedbintree<T>::preorder(linkednode<T>*pnode)
{
	if (pnode == NULL)
	{
		return;
	}
	cout << pnode->m_data << " ";
	preorder(pnode->m_pleftchild);
	preorder(pnode->m_prightchild);

}
//递归中序遍历
template <class T>
void linkedbintree<T>::inorder(linkednode<T>*pnode)
{
	if (pnode == NULL)
	{
		return;
	}
	inorder(pnode->m_pleftchild);
	cout << pnode->m_data << " ";
	inorder(pnode->m_prightchild);
}
//递归后序遍历
template <class T>
void linkedbintree<T>::postorder(linkednode<T>*pnode)
{
	if (pnode == NULL)
	{
		return;
	}
	postorder(pnode->m_pleftchild);
	postorder(pnode->m_prightchild);
	cout << pnode->m_data << " ";
}
//逐层遍历
template <class T>
void linkedbintree<T>::levelorder()
{
	//q为linkqueue类型的队列   存放linkednode类型的指针
	linkqueue<linkednode <T>*>q;
	linkednode<T>*pnode = NULL;
	if (m_proot == NULL)
	{
		return;
	}
	//将根节点插入进队列
	q.insert(m_proot);
	//如果队列不为空
	while (!q.isempty())
	{
		//将元素从队首出队
		q.Delete(pnode);
		//访问元素数据
		cout << pnode->m_data << " ";
		//如果存在左孩子，则将左孩子节点插入队列
		if (pnode->m_pleftchild)
		{
			q.insert(pnode->m_pleftchild);
		}
		//如果存在右孩子，则将右孩子节点插入队列
		if (pnode->m_prightchild)
		{
			q.insert(pnode->m_prightchild);
		}
	}
}
//按非递归方式获取指定节点的双亲结点
template<class T>
linkednode<T>*linkedbintree<T>::getparent(linkednode<T>*pnode)
{
	linkqueue<linkednode <T>*>q;
	linkednode<T>*pcurnode = NULL;
	if (pnode == m_proot)
	{
		return NULL;
	}
	if (m_proot == NULL)
	{
		return NULL;
	}
	//将根节点放入队列中去
	q.insert(m_proot);
	//如果队列不为空
	while (!q.isempty())
	{
		//将队首节点取出来给pcurnode
		q.Delete(pcurnode);
		//如果当前节点的左孩子或者右孩子等于指定节点   则返回该节点  即为指定节点的双亲节点
		if (pcurnode->m_pleftchild == pnode || pcurnode->m_prightchild == pnode)
		{
			return pcurnode;
		}
		if (pcurnode->m_pleftchild)
		{
			q.insert(pcurnode->m_pleftchild);
		}
		if (pcurnode->m_prightchild)
		{
			q.insert(pcurnode->m_prightchild);
		}
	}
	return NULL;
}
//删除以指定节点为根的子树
template<class T>
void linkedbintree<T>::deletetree(linkednode<T>*pnode)
{
	//定义一个节点为双亲节点  置为空
	linkednode<T>*pparentnode = NULL;
	//如果指定节点为空节点  则不返回
	if (pnode == NULL)
	{
		return;
	}
	//如果根节点为指定节点  则将指定节点（根节点）置空
	if (m_proot == pnode)
	{
		m_proot == NULL;
	}
	//找到指定节点的双亲结点赋值给新节点   如果不为空 即找到了双亲结点  则删除其左孩子或者右孩子
	else if ((pparentnode = getparent(pnode)) != NULL)
	{
		if (pparentnode->m_pleftchild == pnode)
		{
			pparentnode->m_pleftchild == NULL;
		}
		if (pparentnode->m_prightchild == pnode)
		{
			pparentnode->m_prightchild == NULL;
		}
	}
	else
		return;
	deletetreenode(pnode);
}

//由deletetree函数调用删除以指定节点为根的子树
template<class T>
void linkedbintree<T>::deletetreenode(linkednode<T>*pnode)
{
	linkqueue<linkednode <T>*>q;
	linkednode<T>*pcurnode = NULL;
	if (pnode == NULL)
	{
		return;
	}
	q.insert(pnode);
	while (!q.isempty())
	{
		//将队首节点取出来给pcurnode
		q.Delete(pcurnode);
		if (pcurnode->m_pleftchild)
		{
			q.insert(pcurnode->m_pleftchild);
		}
		if (pcurnode->m_prightchild)
		{
			q.insert(pcurnode->m_prightchild);
		}
		delete pcurnode;
	}
}
//按关键字查找节点
template<class T>
linkednode<T>*linkedbintree<T>::searchbykey(const T &x)
{
	linkqueue<linkednode <T>*>q;
	linkednode<T>*pmatchnode = NULL;
	if (m_proot == NULL)
	{
		return NULL;
	}
	//将根节点插入队列
	q.insert(m_proot);
	while (!q.isempty())
	{
		//将队首节点取出来
		q.Delete(pmatchnode);
		if (pmatchnode->m_data == x)
		{
			return pmatchnode;
		}
		if (pmatchnode->m_pleftchild)
		{
			q.insert(pmatchnode->m_pleftchild);
		}
		if (pmatchnode->m_prightchild)
		{
			q.insert(pmatchnode->m_prightchild);
		}
	}
	return NULL;
}
//清除二叉树
template<class T>
void linkedbintree<T>::clear()
{
	deletetree(m_proot);
}
//析构函数
template<class T>
linkedbintree<T>::~linkedbintree()
{
	clear();
}
//插入二叉排序树
template<class T>
void insertBST(linkedbintree<T>&btree, T K)
{
	//创建新节点
	linkednode <T>*pnode = NULL, *pchild = NULL;
	T x;
	//如果树为空 则直接以节点元素K创建根节点
	if (btree.isempty())
	{
		btree.creatroot(K);
	}
	//如果树不为空，则先获取根节点
	pnode = btree.getroot();
	//当根节点不为空

	while (pnode)
	{
		//获取根节点的数值
		btree.getnodevalue(pnode, x);
		//如果K=根节点数值  则K已经是树中的节点
		if (K == x)
		   return;
		//如果K<x  则将K插入到该节点的左子树中
		if (K < x)
		{
			//如果左子树存在，则继续寻找新的位置
			if ((pchild = btree.getleftchild(pnode)) != NULL)
			{
				pnode = pchild;
			}
			else
				//如果左子树不存在，则将新元素K作为根节点的左孩子插入
			{
				btree.insertleftchild(pnode, K);
				return;
			}
		}
		//如果K>x  则将K插入到该节点的右子树中
		else
		{   //如果右子树存在，则继续寻找新的位置
			if ((pchild = btree.getrightchild(pnode)) != NULL)
			{
				pnode = pchild;
			}
			else
				//如果右子树不存在，则将新元素K作为根节点的右孩子插入
			{
				btree.insertrightchild(pnode, K);
				return;
			}
		}
	}
}

//生成二叉排序树
template<class T>
void creatBST(T R[], int size, linkedbintree<T>&btree)
{
	//将数组中的元素依次插入到二叉排序树中

	for (int i = 0; i <= size; i++)
	{
		insertBST(btree, R[i]);
	}
}
//递归方式实现查找二叉排序树
template<class T>
linkednode<T>*searchBST(linkednode<T>*proot, T K)
{
	//定义二叉树对象
	linkedbintree<T>btree;
	T x;
	//如果子树为空，则查找失败
	if (proot == NULL)
	{
		return NULL;
	}
	//获取给定节点的元素值
	btree.getnodevalue(proot, x);
	//如果K=x  查找成功
	if (K == x)
		return proot;
	//如果K<x  在左子树中进行查找(递归调用）
	else if (K < x)
		return searchBST(btree.getleftchild(proot), K);
	//如果K>x  在右子树中进行查找(递归调用）
	else
		return searchBST(btree.getrightchild(proot), K);
}
int main()
{
	int treedata[] = { 12, 23, 56, 24, 13, 85, 25, 16, 14 };
	int size = sizeof(treedata) / sizeof(treedata[0]);
	int K = 56, X = 25;
	linkedbintree<int> btree;
	creatBST(treedata, size, btree);
	linkednode<int>*node = btree.searchbykey(12);
	cout << "中序遍历：";
	btree.inorder(node);
	cout << endl;
	cout << "后序遍历：";
	btree.postorder(node);
	cout << endl;
	
	linkednode<int>*node1 = btree.searchbykey(K);
	btree.modifynodevalue(node1, 55);
	cout << "修改后中序遍历" << endl;
	btree.inorder(node);
	cout << endl;
	//根据给定元素K进行二叉排序树的查找，用pnode指向匹配元素所在节点
	linkednode<int>*pnode;
	pnode = searchBST(btree.getroot(), K);
	//如果pnode不为空  则查找成功
	if (pnode != NULL)
	{
		//获取匹配元素的值并输出
		btree.getnodevalue(pnode, X);
		cout << "已找到该元素:" << X << endl;
	}
	else
		cout << "没有找到该元素。" << endl;
	system("pause");
	return 0;
;

输出结果：
在这里插入图片描述
这里出现了一串未知数字，找了半天错误，没解决，应该是逻辑漏洞。。。。

暗月li
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用二叉链创建二叉树（顺序表等更？）
^.^
11-08 287
//链式存储结构 #include<iostream> #include<cstring> #include<cstdlib> using namespace std; //声明结构体 typedef struct node { char data; struct node *lchild; struct node *rchild; }...
c++实现链式二叉树类模板
weixin_43575269的博客
05-20 272
c++实现链式二叉树类模板 #include<iostream> using namespace std; //-------------提前声明二叉树类模板--------------------- template<class T> class BinaryTree; //-------------二叉树结点类----------------------------- template<class T> class BinaryTree
查找算法【二叉查找树】 - 二叉查找树的插入
谢谢你们的关注
10-27 769
查找算法【二叉查找树】 - 二叉查找树的插入
详解二叉排序树及其基本操作
qq_45801780的博客
11-22 3063
详解二叉排序树及其基本操作 二叉排序树又称二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。 1. 二叉排序树的定义 二叉排序树或者是一颗空树，或者是具有下列性质的二叉树： (1) 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2) 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； (3) 它的左、右子树也分别为二叉排序树。 由定义可得到二叉排序树的一个重要性质：中序遍历一颗二叉排序树时可以得到一个结点值递增的有序序列。 在下面讨论二叉排序树的操作中，使用二叉链表作为存
顺序数组，二叉链表创建二叉排序树，及遍历方法（数据结构c++）
weixin_73748464的博客
04-14 1860
对于任意节点，它的左子树上的所有节点的值都小于该节点的值；对于任意节点，它的右子树上的所有节点的值都大于该节点的值；左、右子树都是二叉排序树。这个性质保证了二叉排序树的中序遍历是有序的，因此也被称为二叉查找树。二叉排序树可以进行高效的查找、插入、删除操作，时间复杂度为O(log n)。
有关二叉树的基本操作
absorb2601078490的博客
06-26 1151
​本文只有代码，介绍了有关二叉树的基本操作。 已经过调试没有很大问题。 如有错误，还请批评指正。
C++模板实现二叉树
m0_46346690的博客
11-07 447
Github完整代码下载地址 完整头文件在项目的路径为：inc/chapter6.h BinaryTree 类定义 BinaryTree类实现的二叉树能够实现以下功能： 清空二叉树 查找 插入 移除 前序(preorder)，中序（inorder），后序（postorder）的方式遍历整个二叉树 template <typename elemType> class BinaryTree{ friend class BTnode<elemType>; public:
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
14.3 二叉搜索树的操作和实现 14.3.1 类binarySearchTree 14.3.2 搜索 14.3.3 插入 14.3.4 删除 14.3.5 二叉搜索树的高度 14.4 带有相同关键字元素的二叉搜索树 14.5 索引二叉搜索树 14.6 应用 14.6.1 直方图 14.6.2...
数据结构各种算法实现(C++模板)
10-16
### 数据结构各种算法实现(C++模板) #### 1、顺序表 **Seqlist.h** 在C++中，顺序表是一种基本的数据结构，它通过数组来存储数据元素，并且提供了基本的操作方法，如插入、删除等。在这个实现中，顺序表类`...
数据结构算法C/C++
12-16
C++的模板和STL（标准模板库）提供了更高级的数据结构，如vector（动态数组）、list（双向链表）、set（自平衡二叉查找树）和map（关联数组）。STL还包含了许多算法，如find、sort、unique等，可以极大地提高代码的...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
1.4 C＋＋程序的编写和实现 1.5 关于C＋＋上机实践 习题 第2章 数据类型与表达式 2.1 C＋＋的数据类型 2.2 常量 2.2.1 什么是常量 2.2.2 数值常量 2.2.3 字符常量 2.2.4 符号常量 2.3 变量 2.3.1 什么是变量 2.3.2 ...
二叉排序树链表实现
freepenix 的学习之路
09-10 1357
二叉排序数的（递归）定义：1、若左子树非空，则左子树所有节点的值均小于它的根节点；2、若右子树非空，则右子树所有节点的值均大于于它的根节点；3、左右子树也分别为二叉排序树。 如图： 链表实现（比较简单）： #include #include typedef struct node { int data; struct node * lchild; str
数据结构之二叉排序树（C++实现）
cheng_jack_li的博客
09-11 3267
二叉树是数据结构中的一个非常非常重要的板块，俗话说不到长城非好汉，那么不会二叉树就不算了解数据结构。什么是二叉树，在之前我们了解了链表，但是我们在使用的时候就会发现一个问题就是，链表的每一个节点只能在同一方向指向一个节点，也就是不能分叉，可是在实际应用中必须要有分叉的存在，怎么办呢，前辈们就提出了二叉排序树的概念。通过前边的学习我们了解了单链表有两个区域，就是数据域和指针域，双向链表为了实现反向遍历多加了一个区域叫前驱指针域，所以双向链表就有了三个域，前驱指针域，后继指针域和数据域，同理我们就能猜出来，二叉
C++模板二叉排序树
qq_43621555的博客
04-02 123
什么是二叉查找树： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。以下是实现过程，不知是否有bug，刚写完就给上传到了知乎。 以下是代码，看了很多人的总是感觉不是我想要的感觉于是自己写一个。 如有错误请指正 #pragma once #include"预编译.h" using namespace std; template<typename T> struct TreeNode { T val; TreeNode* le
C++实现二叉搜索树（二叉排序树）模板类
FS's Home
12-09 2685
参考了Weiss的数据结构与算法分析C++描述第三版完成二叉搜索树
二叉树类模板-C++实现
m0_55464171的博客
05-18 2009
二叉树是一种重要的数据结构，本文将用C++实现二叉树及其一些基本操作：遍历，插入，删除，查找…… 1）定义二叉树的模板类，并声明一些方法 template<class T> class tree { private: struct TreeNode; //树的结点 typedef TreeNode*NodePtr; static T out_of_range; //防止迭代器越界的静态变量 protected: NodePtr _root; //根结点 public: class
4.2二叉树
xiexieya233的博客
05-05 2224
学习总结 4.2.1二叉树的定义与分类 1.二叉树的递归定义 二叉树(Binary Tree)是一种重要的树结构，它的特点是每一个结点最多只能有两棵子树。二叉树的递归定义如下:二叉树或者是一棵空树，或者是一棵由一个根结点和两棵互不相交的分别称为根的左子树和右子树的子树所组成的非空树。 由二叉树定义可以看出，二叉树中每一个结点的孩子只能是0、1或2个,并且每一个孩子都有左右之分。位于左边的孩子称为左孩子，位于右边的孩子称为右孩子;以左孩子为根的子树称为左子树，以右孩子为根的...
数据结构之二叉树(1)
u011408270的专栏
03-25 157
题目描述 1、输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 思路： (1) 首先设置标志位result = false，因为一旦匹配成功result就设为true，剩下的代码不会执行，如果匹配不成功，默认返回false (2) 递归思想，如果根节点相同则递归调用DoesTree1HaveTree2（），如果根节点不相同，则判断tree1的左子树...
c++数据结构二叉树（二叉链表实现）基本操作实现
weixin_53144360的博客
11-11 5210
二叉树： 二叉树（Binarytree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 性质： 二叉树性质 性质1：二叉树的第i层上至多有2i-1（i≥1）个节点。 性质2：深度为h的二叉树中至多含有2h-1个节点。 性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2...
二叉树链式存储结构 二叉排序树
最新发布
11-22
二叉树链式存储结构是指通过链表的方式来存储二叉树，每个节点包含三个部分：数据域、左子树指针和右子树指针。二叉排序树是一种特殊的二叉树，它的左子树中的所有节点的值都小于根节点的值，右子树中的所有节点的值都大于根节点的值。以下是构造二叉排序树并输入其中序遍历的Python代码示例： ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None class BinarySearchTree: def __init__(self): self.root = None def insert(self, val): if not self.root: self.root = TreeNode(val) else: self._insert(val, self.root) def _insert(self, val, node): if val < node.val: if node.left: self._insert(val, node.left) else: node.left = TreeNode(val) else: if node.right: self._insert(val, node.right) else: node.right = TreeNode(val) def inorder_traversal(self, node): if node: self.inorder_traversal(node.left) print(node.val) self.inorder_traversal(node.right) bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(7) bst.insert(1) bst.insert(9) bst.inorder_traversal(bst.root) ``` 输出结果为：1 3 5 7 9，即二叉排序树的中序遍历结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值